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];
        char shm_name[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';
        snprintf(shm_name, sizeof(shm_name), "/%s", basename(filepath));

        if ((fd = shm_open(shm_name, O_CREAT | O_EXCL | O_RDWR, 0600)) == -1)
        {
                log_error("shm_open(%s) error (%d)\n", shm_name, 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];
        char shm_name[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';
        snprintf(shm_name, sizeof(shm_name), "/%s", basename(filepath));

        if (shm_unlink(shm_name) == -1 && errno != ENOENT)
        {
                log_error("shm_unlink(%s) error (%d)\n", shm_name, 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];
        char shm_name[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';
        snprintf(shm_name, sizeof(shm_name), "/%s", basename(filepath));

        if ((fd = shm_open(shm_name, O_RDONLY, 0600)) == -1)
        {
                log_error("shm_open(%s) error (%d)\n", shm_name, 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.23	char shm_name[FILE_PATH_LEN];
36	sysadm	1.1	int fd;
37			struct stat sb;
38			void *p_data;
39	sysadm	1.3	size_t data_len;
40	sysadm	1.1	size_t size;
41	sysadm	1.3	void *p_shm;
42			long line_total;
43			long line_offsets[MAX_SPLIT_FILE_LINES];
44			long *p_line_offsets;
45	sysadm	1.22
46			if (filename == NULL)
47			{
48			log_error("NULL pointer error\n");
49			return -1;
50			}
51	sysadm	1.1
52			if ((fd = open(filename, O_RDONLY)) < 0)
53			{
54			log_error("open(%s) error (%d)\n", filename, errno);
55			return -1;
56			}
57
58			if (fstat(fd, &sb) < 0)
59			{
60			log_error("fstat(fd) error (%d)\n", errno);
61	sysadm	1.22	close(fd);
62	sysadm	1.1	return -1;
63			}
64
65	sysadm	1.3	data_len = (size_t)sb.st_size;
66			p_data = mmap(NULL, data_len, PROT_READ, MAP_SHARED, fd, 0L);
67	sysadm	1.1	if (p_data == MAP_FAILED)
68			{
69			log_error("mmap() error (%d)\n", errno);
70	sysadm	1.22	close(fd);
71	sysadm	1.1	return -2;
72			}
73
74			if (close(fd) < 0)
75			{
76			log_error("close(fd) error (%d)\n", errno);
77			return -1;
78			}
79
80	sysadm	1.16	line_total = split_data_lines(p_data, SCREEN_COLS, line_offsets, MAX_SPLIT_FILE_LINES, 1, NULL);
81	sysadm	1.1
82	sysadm	1.3	// Allocate shared memory
83	sysadm	1.22	size = sizeof(struct shm_header_t) + data_len + 1 + sizeof(long) * (size_t)(line_total + 1);
84
85			if (unload_file(filename) < 0)
86	sysadm	1.3	{
87			return -2;
88			}
89	sysadm	1.1
90	sysadm	1.22	strncpy(filepath, filename, sizeof(filepath) - 1);
91			filepath[sizeof(filepath) - 1] = '\0';
92	sysadm	1.23	snprintf(shm_name, sizeof(shm_name), "/%s", basename(filepath));
93	sysadm	1.22
94	sysadm	1.23	if ((fd = shm_open(shm_name, O_CREAT \| O_EXCL \| O_RDWR, 0600)) == -1)
95	sysadm	1.3	{
96	sysadm	1.23	log_error("shm_open(%s) error (%d)\n", shm_name, errno);
97	sysadm	1.22	return -2;
98	sysadm	1.3	}
99	sysadm	1.22	if (ftruncate(fd, (off_t)size) == -1)
100	sysadm	1.3	{
101	sysadm	1.22	log_error("ftruncate(size=%d) error (%d)\n", size, errno);
102			close(fd);
103			return -2;
104	sysadm	1.3	}
105
106	sysadm	1.22	p_shm = mmap(NULL, size, PROT_READ \| PROT_WRITE, MAP_SHARED, fd, 0L);
107			if (p_shm == MAP_FAILED)
108			{
109			log_error("mmap() error (%d)\n", errno);
110			close(fd);
111			return -2;
112			}
113
114			if (close(fd) < 0)
115			{
116			log_error("close(fd) error (%d)\n", errno);
117			return -1;
118			}
119
120			((struct shm_header_t *)p_shm)->shm_size = size;
121	sysadm	1.8	((struct shm_header_t *)p_shm)->data_len = data_len;
122			((struct shm_header_t *)p_shm)->line_total = line_total;
123	sysadm	1.17	memcpy((char *)p_shm + sizeof(struct shm_header_t), p_data, data_len);
124	sysadm	1.1
125	sysadm	1.3	if (munmap(p_data, data_len) < 0)
126			{
127			log_error("munmap() error (%d)\n", errno);
128	sysadm	1.22	munmap(p_shm, size);
129	sysadm	1.3	return -2;
130			}
131	sysadm	1.1
132	sysadm	1.17	p_data = (char *)p_shm + sizeof(struct shm_header_t);
133			p_line_offsets = (long )((char )p_data + data_len + 1);
134	sysadm	1.3	memcpy(p_line_offsets, line_offsets, sizeof(long) * (size_t)(line_total + 1));
135	sysadm	1.1
136	sysadm	1.22	if (munmap(p_shm, size) < 0)
137	sysadm	1.9	{
138	sysadm	1.22	log_error("munmap() error (%d)\n", errno);
139			return -2;
140	sysadm	1.9	}
141
142	sysadm	1.22	return 0;
143			}
144
145			int unload_file(const char *filename)
146			{
147			char filepath[FILE_PATH_LEN];
148	sysadm	1.23	char shm_name[FILE_PATH_LEN];
149	sysadm	1.22
150			if (filename == NULL)
151	sysadm	1.3	{
152	sysadm	1.22	log_error("NULL pointer error\n");
153			return -1;
154	sysadm	1.1	}
155
156	sysadm	1.22	strncpy(filepath, filename, sizeof(filepath) - 1);
157			filepath[sizeof(filepath) - 1] = '\0';
158	sysadm	1.23	snprintf(shm_name, sizeof(shm_name), "/%s", basename(filepath));
159	sysadm	1.22
160	sysadm	1.23	if (shm_unlink(shm_name) == -1 && errno != ENOENT)
161	sysadm	1.3	{
162	sysadm	1.23	log_error("shm_unlink(%s) error (%d)\n", shm_name, errno);
163	sysadm	1.22	return -2;
164	sysadm	1.3	}
165	sysadm	1.1
166			return 0;
167			}
168
169	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)
170	sysadm	1.1	{
171	sysadm	1.22	char filepath[FILE_PATH_LEN];
172	sysadm	1.23	char shm_name[FILE_PATH_LEN];
173	sysadm	1.22	int fd;
174			void *p_shm = NULL;
175			struct stat sb;
176			size_t size;
177	sysadm	1.1
178	sysadm	1.22	if (filename == NULL \|\| p_data_len == NULL \|\| p_line_total == NULL \|\| pp_data == NULL \|\| pp_line_offsets == NULL)
179	sysadm	1.1	{
180	sysadm	1.22	log_error("NULL pointer error\n");
181			return NULL;
182	sysadm	1.1	}
183
184	sysadm	1.22	strncpy(filepath, filename, sizeof(filepath) - 1);
185			filepath[sizeof(filepath) - 1] = '\0';
186	sysadm	1.23	snprintf(shm_name, sizeof(shm_name), "/%s", basename(filepath));
187	sysadm	1.22
188	sysadm	1.23	if ((fd = shm_open(shm_name, O_RDONLY, 0600)) == -1)
189	sysadm	1.1	{
190	sysadm	1.23	log_error("shm_open(%s) error (%d)\n", shm_name, errno);
191	sysadm	1.22	return NULL;
192	sysadm	1.1	}
193
194	sysadm	1.22	if (fstat(fd, &sb) < 0)
195	sysadm	1.1	{
196	sysadm	1.22	log_error("fstat(fd) error (%d)\n", errno);
197			close(fd);
198			return NULL;
199	sysadm	1.1	}
200
201	sysadm	1.22	size = (size_t)sb.st_size;
202	sysadm	1.1
203	sysadm	1.22	p_shm = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0L);
204			if (p_shm == MAP_FAILED)
205	sysadm	1.1	{
206	sysadm	1.22	log_error("mmap() error (%d)\n", errno);
207			close(fd);
208	sysadm	1.1	return NULL;
209			}
210
211	sysadm	1.22	if (close(fd) < 0)
212	sysadm	1.1	{
213	sysadm	1.22	log_error("close(fd) error (%d)\n", errno);
214	sysadm	1.1	return NULL;
215			}
216
217	sysadm	1.22	if (((struct shm_header_t *)p_shm)->shm_size != size)
218	sysadm	1.11	{
219	sysadm	1.22	log_error("Shared memory size mismatch (%ld != %ld)\n", ((struct shm_header_t *)p_shm)->shm_size, size);
220			munmap(p_shm, size);
221	sysadm	1.11	return NULL;
222			}
223
224	sysadm	1.8	p_data_len = ((struct shm_header_t )p_shm)->data_len;
225			p_line_total = ((struct shm_header_t )p_shm)->line_total;
226	sysadm	1.17	pp_data = (char )p_shm + sizeof(struct shm_header_t);
227			pp_line_offsets = (const long )((const char )(pp_data) + *p_data_len + 1);
228	sysadm	1.3
229			return p_shm;
230	sysadm	1.1	}
231	sysadm	1.11
232	sysadm	1.22	int detach_file_shm(void *p_shm)
233	sysadm	1.11	{
234	sysadm	1.22	size_t size;
235
236	sysadm	1.11	if (p_shm == NULL)
237			{
238	sysadm	1.22	return -1;
239	sysadm	1.11	}
240
241	sysadm	1.22	size = ((struct shm_header_t *)p_shm)->shm_size;
242
243			if (munmap(p_shm, size) < 0)
244	sysadm	1.11	{
245	sysadm	1.22	log_error("munmap() error (%d)\n", errno);
246			return -2;
247	sysadm	1.11	}
248
249			return 0;
250			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1