lbbs/src/file_loader.c

/* SPDX-License-Identifier: GPL-3.0-or-later */
/*
 * file_loader
 *   - shared memory based file loader
 *
 * Copyright (C) 2004-2025  Leaflet <leaflet@leafok.com>
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "file_loader.h"
#include "log.h"
#include "str_process.h"
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>

struct shm_header_t
{
        size_t shm_size;
        size_t data_len;
        long line_total;
};

int load_file(const char *filename)
{
        char filepath[FILE_PATH_LEN];
        int fd;
        struct stat sb;
        void *p_data;
        size_t data_len;
        size_t size;
        void *p_shm;
        long line_total;
        long line_offsets[MAX_SPLIT_FILE_LINES];
        long *p_line_offsets;

        if (filename == NULL)
        {
                log_error("NULL pointer error\n");
                return -1;
        }

        if ((fd = open(filename, O_RDONLY)) < 0)
        {
                log_error("open(%s) error (%d)\n", filename, errno);
                return -1;
        }

        if (fstat(fd, &sb) < 0)
        {
                log_error("fstat(fd) error (%d)\n", errno);
                close(fd);
                return -1;
        }

        data_len = (size_t)sb.st_size;
        p_data = mmap(NULL, data_len, PROT_READ, MAP_SHARED, fd, 0L);
        if (p_data == MAP_FAILED)
        {
                log_error("mmap() error (%d)\n", errno);
                close(fd);
                return -2;
        }

        if (close(fd) < 0)
        {
                log_error("close(fd) error (%d)\n", errno);
                return -1;
        }

        line_total = split_data_lines(p_data, SCREEN_COLS, line_offsets, MAX_SPLIT_FILE_LINES, 1, NULL);

        // Allocate shared memory
        size = sizeof(struct shm_header_t) + data_len + 1 + sizeof(long) * (size_t)(line_total + 1);

        if (unload_file(filename) < 0)
        {
                return -2;
        }

        strncpy(filepath, filename, sizeof(filepath) - 1);
        filepath[sizeof(filepath) - 1] = '\0';

        if ((fd = shm_open(basename(filepath), O_CREAT | O_EXCL | O_RDWR, 0600)) == -1)
        {
                log_error("shm_open(%s) error (%d)\n", basename(filepath), errno);
                return -2;
        }
        if (ftruncate(fd, (off_t)size) == -1)
        {
                log_error("ftruncate(size=%d) error (%d)\n", size, errno);
                close(fd);
                return -2;
        }

        p_shm = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0L);
        if (p_shm == MAP_FAILED)
        {
                log_error("mmap() error (%d)\n", errno);
                close(fd);
                return -2;
        }

        if (close(fd) < 0)
        {
                log_error("close(fd) error (%d)\n", errno);
                return -1;
        }

        ((struct shm_header_t *)p_shm)->shm_size = size;
        ((struct shm_header_t *)p_shm)->data_len = data_len;
        ((struct shm_header_t *)p_shm)->line_total = line_total;
        memcpy((char *)p_shm + sizeof(struct shm_header_t), p_data, data_len);

        if (munmap(p_data, data_len) < 0)
        {
                log_error("munmap() error (%d)\n", errno);
                munmap(p_shm, size);
                return -2;
        }

        p_data = (char *)p_shm + sizeof(struct shm_header_t);
        p_line_offsets = (long *)((char *)p_data + data_len + 1);
        memcpy(p_line_offsets, line_offsets, sizeof(long) * (size_t)(line_total + 1));

        if (munmap(p_shm, size) < 0)
        {
                log_error("munmap() error (%d)\n", errno);
                return -2;
        }

        return 0;
}

int unload_file(const char *filename)
{
        char filepath[FILE_PATH_LEN];

        if (filename == NULL)
        {
                log_error("NULL pointer error\n");
                return -1;
        }

        strncpy(filepath, filename, sizeof(filepath) - 1);
        filepath[sizeof(filepath) - 1] = '\0';

        if (shm_unlink(basename(filepath)) == -1 && errno != ENOENT)
        {
                log_error("shm_unlink(%s) error (%d)\n", basename(filepath), errno);
                return -2;
        }

        return 0;
}

void *get_file_shm_readonly(const char *filename, size_t *p_data_len, long *p_line_total, const void **pp_data, const long **pp_line_offsets)
{
        char filepath[FILE_PATH_LEN];
        int fd;
        void *p_shm = NULL;
        struct stat sb;
        size_t size;

        if (filename == NULL || p_data_len == NULL || p_line_total == NULL || pp_data == NULL || pp_line_offsets == NULL)
        {
                log_error("NULL pointer error\n");
                return NULL;
        }

        strncpy(filepath, filename, sizeof(filepath) - 1);
        filepath[sizeof(filepath) - 1] = '\0';

        if ((fd = shm_open(basename(filepath), O_RDONLY, 0600)) == -1)
        {
                log_error("shm_open(%s) error (%d)\n", basename(filepath), errno);
                return NULL;
        }

        if (fstat(fd, &sb) < 0)
        {
                log_error("fstat(fd) error (%d)\n", errno);
                close(fd);
                return NULL;
        }

        size = (size_t)sb.st_size;

        p_shm = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0L);
        if (p_shm == MAP_FAILED)
        {
                log_error("mmap() error (%d)\n", errno);
                close(fd);
                return NULL;
        }

        if (close(fd) < 0)
        {
                log_error("close(fd) error (%d)\n", errno);
                return NULL;
        }

        if (((struct shm_header_t *)p_shm)->shm_size != size)
        {
                log_error("Shared memory size mismatch (%ld != %ld)\n", ((struct shm_header_t *)p_shm)->shm_size, size);
                munmap(p_shm, size);
                return NULL;
        }

        *p_data_len = ((struct shm_header_t *)p_shm)->data_len;
        *p_line_total = ((struct shm_header_t *)p_shm)->line_total;
        *pp_data = (char *)p_shm + sizeof(struct shm_header_t);
        *pp_line_offsets = (const long *)((const char *)(*pp_data) + *p_data_len + 1);

        return p_shm;
}

int detach_file_shm(void *p_shm)
{
        size_t size;

        if (p_shm == NULL)
        {
                return -1;
        }

        size = ((struct shm_header_t *)p_shm)->shm_size;

        if (munmap(p_shm, size) < 0)
        {
                log_error("munmap() error (%d)\n", errno);
                return -2;
        }

        return 0;
}
1	sysadm	1.18	/* SPDX-License-Identifier: GPL-3.0-or-later */
2			/*
3			* file_loader
4			* - shared memory based file loader
5			*
6	sysadm	1.20	* Copyright (C) 2004-2025 Leaflet <leaflet@leafok.com>
7	sysadm	1.18	*/
8	sysadm	1.1
9	sysadm	1.21	#ifdef HAVE_CONFIG_H
10			#include "config.h"
11			#endif
12
13	sysadm	1.1	#include "file_loader.h"
14	sysadm	1.15	#include "log.h"
15			#include "str_process.h"
16			#include <errno.h>
17	sysadm	1.1	#include <fcntl.h>
18			#include <stdlib.h>
19	sysadm	1.3	#include <string.h>
20			#include <time.h>
21	sysadm	1.15	#include <unistd.h>
22	sysadm	1.1	#include <sys/mman.h>
23			#include <sys/stat.h>
24	sysadm	1.3
25	sysadm	1.8	struct shm_header_t
26			{
27	sysadm	1.22	size_t shm_size;
28	sysadm	1.8	size_t data_len;
29			long line_total;
30			};
31
32	sysadm	1.11	int load_file(const char *filename)
33	sysadm	1.1	{
34	sysadm	1.22	char filepath[FILE_PATH_LEN];
35	sysadm	1.1	int fd;
36			struct stat sb;
37			void *p_data;
38	sysadm	1.3	size_t data_len;
39	sysadm	1.1	size_t size;
40	sysadm	1.3	void *p_shm;
41			long line_total;
42			long line_offsets[MAX_SPLIT_FILE_LINES];
43			long *p_line_offsets;
44	sysadm	1.22
45			if (filename == NULL)
46			{
47			log_error("NULL pointer error\n");
48			return -1;
49			}
50	sysadm	1.1
51			if ((fd = open(filename, O_RDONLY)) < 0)
52			{
53			log_error("open(%s) error (%d)\n", filename, errno);
54			return -1;
55			}
56
57			if (fstat(fd, &sb) < 0)
58			{
59			log_error("fstat(fd) error (%d)\n", errno);
60	sysadm	1.22	close(fd);
61	sysadm	1.1	return -1;
62			}
63
64	sysadm	1.3	data_len = (size_t)sb.st_size;
65			p_data = mmap(NULL, data_len, PROT_READ, MAP_SHARED, fd, 0L);
66	sysadm	1.1	if (p_data == MAP_FAILED)
67			{
68			log_error("mmap() error (%d)\n", errno);
69	sysadm	1.22	close(fd);
70	sysadm	1.1	return -2;
71			}
72
73			if (close(fd) < 0)
74			{
75			log_error("close(fd) error (%d)\n", errno);
76			return -1;
77			}
78
79	sysadm	1.16	line_total = split_data_lines(p_data, SCREEN_COLS, line_offsets, MAX_SPLIT_FILE_LINES, 1, NULL);
80	sysadm	1.1
81	sysadm	1.3	// Allocate shared memory
82	sysadm	1.22	size = sizeof(struct shm_header_t) + data_len + 1 + sizeof(long) * (size_t)(line_total + 1);
83
84			if (unload_file(filename) < 0)
85	sysadm	1.3	{
86			return -2;
87			}
88	sysadm	1.1
89	sysadm	1.22	strncpy(filepath, filename, sizeof(filepath) - 1);
90			filepath[sizeof(filepath) - 1] = '\0';
91
92			if ((fd = shm_open(basename(filepath), O_CREAT \| O_EXCL \| O_RDWR, 0600)) == -1)
93	sysadm	1.3	{
94	sysadm	1.22	log_error("shm_open(%s) error (%d)\n", basename(filepath), errno);
95			return -2;
96	sysadm	1.3	}
97	sysadm	1.22	if (ftruncate(fd, (off_t)size) == -1)
98	sysadm	1.3	{
99	sysadm	1.22	log_error("ftruncate(size=%d) error (%d)\n", size, errno);
100			close(fd);
101			return -2;
102	sysadm	1.3	}
103
104	sysadm	1.22	p_shm = mmap(NULL, size, PROT_READ \| PROT_WRITE, MAP_SHARED, fd, 0L);
105			if (p_shm == MAP_FAILED)
106			{
107			log_error("mmap() error (%d)\n", errno);
108			close(fd);
109			return -2;
110			}
111
112			if (close(fd) < 0)
113			{
114			log_error("close(fd) error (%d)\n", errno);
115			return -1;
116			}
117
118			((struct shm_header_t *)p_shm)->shm_size = size;
119	sysadm	1.8	((struct shm_header_t *)p_shm)->data_len = data_len;
120			((struct shm_header_t *)p_shm)->line_total = line_total;
121	sysadm	1.17	memcpy((char *)p_shm + sizeof(struct shm_header_t), p_data, data_len);
122	sysadm	1.1
123	sysadm	1.3	if (munmap(p_data, data_len) < 0)
124			{
125			log_error("munmap() error (%d)\n", errno);
126	sysadm	1.22	munmap(p_shm, size);
127	sysadm	1.3	return -2;
128			}
129	sysadm	1.1
130	sysadm	1.17	p_data = (char *)p_shm + sizeof(struct shm_header_t);
131			p_line_offsets = (long )((char )p_data + data_len + 1);
132	sysadm	1.3	memcpy(p_line_offsets, line_offsets, sizeof(long) * (size_t)(line_total + 1));
133	sysadm	1.1
134	sysadm	1.22	if (munmap(p_shm, size) < 0)
135	sysadm	1.9	{
136	sysadm	1.22	log_error("munmap() error (%d)\n", errno);
137			return -2;
138	sysadm	1.9	}
139
140	sysadm	1.22	return 0;
141			}
142
143			int unload_file(const char *filename)
144			{
145			char filepath[FILE_PATH_LEN];
146
147			if (filename == NULL)
148	sysadm	1.3	{
149	sysadm	1.22	log_error("NULL pointer error\n");
150			return -1;
151	sysadm	1.1	}
152
153	sysadm	1.22	strncpy(filepath, filename, sizeof(filepath) - 1);
154			filepath[sizeof(filepath) - 1] = '\0';
155
156			if (shm_unlink(basename(filepath)) == -1 && errno != ENOENT)
157	sysadm	1.3	{
158	sysadm	1.22	log_error("shm_unlink(%s) error (%d)\n", basename(filepath), errno);
159			return -2;
160	sysadm	1.3	}
161	sysadm	1.1
162			return 0;
163			}
164
165	sysadm	1.22	void get_file_shm_readonly(const char filename, size_t p_data_len, long p_line_total, const void pp_data, const long pp_line_offsets)
166	sysadm	1.1	{
167	sysadm	1.22	char filepath[FILE_PATH_LEN];
168			int fd;
169			void *p_shm = NULL;
170			struct stat sb;
171			size_t size;
172	sysadm	1.1
173	sysadm	1.22	if (filename == NULL \|\| p_data_len == NULL \|\| p_line_total == NULL \|\| pp_data == NULL \|\| pp_line_offsets == NULL)
174	sysadm	1.1	{
175	sysadm	1.22	log_error("NULL pointer error\n");
176			return NULL;
177	sysadm	1.1	}
178
179	sysadm	1.22	strncpy(filepath, filename, sizeof(filepath) - 1);
180			filepath[sizeof(filepath) - 1] = '\0';
181
182			if ((fd = shm_open(basename(filepath), O_RDONLY, 0600)) == -1)
183	sysadm	1.1	{
184	sysadm	1.22	log_error("shm_open(%s) error (%d)\n", basename(filepath), errno);
185			return NULL;
186	sysadm	1.1	}
187
188	sysadm	1.22	if (fstat(fd, &sb) < 0)
189	sysadm	1.1	{
190	sysadm	1.22	log_error("fstat(fd) error (%d)\n", errno);
191			close(fd);
192			return NULL;
193	sysadm	1.1	}
194
195	sysadm	1.22	size = (size_t)sb.st_size;
196	sysadm	1.1
197	sysadm	1.22	p_shm = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0L);
198			if (p_shm == MAP_FAILED)
199	sysadm	1.1	{
200	sysadm	1.22	log_error("mmap() error (%d)\n", errno);
201			close(fd);
202	sysadm	1.1	return NULL;
203			}
204
205	sysadm	1.22	if (close(fd) < 0)
206	sysadm	1.1	{
207	sysadm	1.22	log_error("close(fd) error (%d)\n", errno);
208	sysadm	1.1	return NULL;
209			}
210
211	sysadm	1.22	if (((struct shm_header_t *)p_shm)->shm_size != size)
212	sysadm	1.11	{
213	sysadm	1.22	log_error("Shared memory size mismatch (%ld != %ld)\n", ((struct shm_header_t *)p_shm)->shm_size, size);
214			munmap(p_shm, size);
215	sysadm	1.11	return NULL;
216			}
217
218	sysadm	1.8	p_data_len = ((struct shm_header_t )p_shm)->data_len;
219			p_line_total = ((struct shm_header_t )p_shm)->line_total;
220	sysadm	1.17	pp_data = (char )p_shm + sizeof(struct shm_header_t);
221			pp_line_offsets = (const long )((const char )(pp_data) + *p_data_len + 1);
222	sysadm	1.3
223			return p_shm;
224	sysadm	1.1	}
225	sysadm	1.11
226	sysadm	1.22	int detach_file_shm(void *p_shm)
227	sysadm	1.11	{
228	sysadm	1.22	size_t size;
229
230	sysadm	1.11	if (p_shm == NULL)
231			{
232	sysadm	1.22	return -1;
233	sysadm	1.11	}
234
235	sysadm	1.22	size = ((struct shm_header_t *)p_shm)->shm_size;
236
237			if (munmap(p_shm, size) < 0)
238	sysadm	1.11	{
239	sysadm	1.22	log_error("munmap() error (%d)\n", errno);
240			return -2;
241	sysadm	1.11	}
242
243			return 0;
244			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1