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_NAME_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");
                return -1;
        }

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

        if (fstat(fd, &sb) < 0)
        {
                log_error("fstat(fd) error (%d)", 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)", errno);
                close(fd);
                return -2;
        }

        if (close(fd) < 0)
        {
                log_error("close(fd) error (%d)", 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);

        strncpy(filepath, filename, sizeof(filepath) - 1);
        filepath[sizeof(filepath) - 1] = '\0';
        snprintf(shm_name, sizeof(shm_name), "/FILE_SHM_%s", basename(filepath));

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

        if ((fd = shm_open(shm_name, O_CREAT | O_EXCL | O_RDWR, 0600)) == -1)
        {
                log_error("shm_open(%s) error (%d)", shm_name, errno);
                return -2;
        }
        if (ftruncate(fd, (off_t)size) == -1)
        {
                log_error("ftruncate(size=%d) error (%d)", 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)", errno);
                close(fd);
                return -2;
        }

        if (close(fd) < 0)
        {
                log_error("close(fd) error (%d)", 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)", 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)", errno);
                return -2;
        }

        return 0;
}

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

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

        strncpy(filepath, filename, sizeof(filepath) - 1);
        filepath[sizeof(filepath) - 1] = '\0';
        snprintf(shm_name, sizeof(shm_name), "/FILE_SHM_%s", basename(filepath));

        if (shm_unlink(shm_name) == -1 && errno != ENOENT)
        {
                log_error("shm_unlink(%s) error (%d)", 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_NAME_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");
                return NULL;
        }

        strncpy(filepath, filename, sizeof(filepath) - 1);
        filepath[sizeof(filepath) - 1] = '\0';
        snprintf(shm_name, sizeof(shm_name), "/FILE_SHM_%s", basename(filepath));

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

        if (fstat(fd, &sb) < 0)
        {
                log_error("fstat(fd) error (%d)", 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)", errno);
                close(fd);
                return NULL;
        }

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

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