lbbs/src/article_cache.c

/***************************************************************************
                                           article_cache.c  -  description
                                                         -------------------
        Copyright            : (C) 2004-2025 by Leaflet
        Email                : leaflet@leafok.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "article_cache.h"
#include "log.h"
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <strings.h>
#define _POSIX_C_SOURCE 200809L
#include <string.h>

#define ARTICLE_HEADER_MAX_LEN 4096

inline static int article_cache_path(char *file_path, size_t buf_len, const char *cache_dir, const ARTICLE *p_article)
{
        if (file_path == NULL || cache_dir == NULL || p_article == NULL)
        {
                log_error("article_cache_path() NULL pointer error\n");
                return -1;
        }

        snprintf(file_path, buf_len, "%s%d", cache_dir, p_article->cid);

        return 0;
}

int article_cache_generate(const char *cache_dir, const ARTICLE *p_article, const char *content, int overwrite)
{
        char data_file[FILE_PATH_LEN];
        int fd;
        ARTICLE_CACHE cache;
        size_t buf_size;

        if (cache_dir == NULL || p_article == NULL || content == NULL)
        {
                log_error("article_cache_generate() NULL pointer error\n");
                return -1;
        }

        if (article_cache_path(data_file, sizeof(data_file), cache_dir, p_article) < 0)
        {
                log_error("article_cache_path(dir=%s, cid=%d) error\n", cache_dir, p_article->cid);
                return -1;
        }

        if (!overwrite)
        {
                if ((fd = open(data_file, O_RDONLY)) != -1) // check data file
                {
                        close(fd);
                        return 0;
                }
        }

        buf_size = ARTICLE_HEADER_MAX_LEN + strlen(content) + 1;
        cache.p_data = malloc(buf_size);
        if (cache.p_data == NULL)
        {
                log_error("malloc(size=%ld) error OOM\n", buf_size);
                return -1;
        }

        if ((fd = open(data_file, O_WRONLY | O_CREAT | O_TRUNC, 0640)) == -1)
        {
                log_error("open(%s) error (%d)\n", data_file, errno);
                return -2;
        }

        // TODO: Generate article header
        cache.data_len = (size_t)snprintf(cache.p_data,
                                                                          ARTICLE_HEADER_MAX_LEN + strlen(content) + 1,
                                                                          "%s",
                                                                          content);

        bzero(cache.line_offsets, sizeof(cache.line_offsets));
        cache.line_total = split_data_lines(cache.p_data, SCREEN_COLS, cache.line_offsets, MAX_SPLIT_FILE_LINES);
        if (cache.line_total >= MAX_SPLIT_FILE_LINES)
        {
                log_error("split_data_lines(%s) truncated over limit lines\n", data_file);
        }

        if (write(fd, &cache, sizeof(cache)) == -1)
        {
                log_error("write(%s, cache) error (%d)\n", data_file, errno);
                close(fd);
                return -3;
        }
        if (write(fd, cache.p_data, cache.data_len) == -1)
        {
                log_error("write(%s, data) error (%d)\n", data_file, errno);
                close(fd);
                return -3;
        }

        if (close(fd) == -1)
        {
                log_error("close(%s) error (%d)\n", data_file, errno);
                return -2;
        }

        free(cache.p_data);

        return 0;
}

int article_cache_load(ARTICLE_CACHE *p_cache, const char *cache_dir, const ARTICLE *p_article)
{
        char data_file[FILE_PATH_LEN];
        int fd;

        if (p_cache == NULL || cache_dir == NULL || p_article == NULL)
        {
                log_error("article_cache_load() NULL pointer error\n");
                return -1;
        }

        if (article_cache_path(data_file, sizeof(data_file), cache_dir, p_article) < 0)
        {
                log_error("article_cache_path(dir=%s, cid=%d) error\n", cache_dir, p_article->cid);
                return -1;
        }

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

        if (read(fd, (void *)p_cache, sizeof(ARTICLE_CACHE)) == -1)
        {
                log_error("read(%s, cache) error (%d)\n", data_file, errno);
                close(fd);
                return -3;
        }

        p_cache->p_data = malloc(p_cache->data_len + 1);
        if (p_cache->p_data == NULL)
        {
                log_error("malloc(size=%ld) error OOM\n", p_cache->data_len + 1);
                close(fd);
                return -1;
        }

        if (read(fd, p_cache->p_data, p_cache->data_len) == -1)
        {
                log_error("read(%s, data) error (%d)\n", data_file, errno);
                close(fd);
                return -3;
        }
        p_cache->p_data[p_cache->data_len] = '\0';

        if (close(fd) == -1)
        {
                log_error("close(%s) error (%d)\n", data_file, errno);
                return -2;
        }

        return 0;
}

int article_cache_unload(ARTICLE_CACHE *p_cache)
{
        if (p_cache == NULL || p_cache->p_data == NULL)
        {
                log_error("article_cache_unload() NULL pointer error\n");
                return -1;
        }

        free(p_cache->p_data);
        p_cache->p_data = NULL;

        return 0;
}
1	sysadm	1.1	/***************************************************************************
2			article_cache.c - description
3			-------------------
4			Copyright : (C) 2004-2025 by Leaflet
5			Email : leaflet@leafok.com
6			***************************************************************************/
7
8			/***************************************************************************
9			* *
10			* This program is free software; you can redistribute it and/or modify *
11			* it under the terms of the GNU General Public License as published by *
12			* the Free Software Foundation; either version 3 of the License, or *
13			* (at your option) any later version. *
14			* *
15			***************************************************************************/
16
17			#include "article_cache.h"
18	sysadm	1.2	#include "log.h"
19			#include <errno.h>
20			#include <stdio.h>
21			#include <fcntl.h>
22			#include <stdlib.h>
23			#include <unistd.h>
24			#include <sys/mman.h>
25			#include <sys/stat.h>
26			#include <strings.h>
27			#define _POSIX_C_SOURCE 200809L
28			#include <string.h>
29	sysadm	1.1
30	sysadm	1.2	#define ARTICLE_HEADER_MAX_LEN 4096
31
32			inline static int article_cache_path(char file_path, size_t buf_len, const char cache_dir, const ARTICLE *p_article)
33			{
34			if (file_path == NULL \|\| cache_dir == NULL \|\| p_article == NULL)
35			{
36			log_error("article_cache_path() NULL pointer error\n");
37			return -1;
38			}
39
40			snprintf(file_path, buf_len, "%s%d", cache_dir, p_article->cid);
41
42			return 0;
43			}
44
45			int article_cache_generate(const char cache_dir, const ARTICLE p_article, const char *content, int overwrite)
46	sysadm	1.1	{
47	sysadm	1.2	char data_file[FILE_PATH_LEN];
48			int fd;
49			ARTICLE_CACHE cache;
50			size_t buf_size;
51
52			if (cache_dir == NULL \|\| p_article == NULL \|\| content == NULL)
53			{
54			log_error("article_cache_generate() NULL pointer error\n");
55			return -1;
56			}
57
58			if (article_cache_path(data_file, sizeof(data_file), cache_dir, p_article) < 0)
59			{
60			log_error("article_cache_path(dir=%s, cid=%d) error\n", cache_dir, p_article->cid);
61			return -1;
62			}
63
64			if (!overwrite)
65			{
66			if ((fd = open(data_file, O_RDONLY)) != -1) // check data file
67			{
68			close(fd);
69			return 0;
70			}
71			}
72
73			buf_size = ARTICLE_HEADER_MAX_LEN + strlen(content) + 1;
74			cache.p_data = malloc(buf_size);
75			if (cache.p_data == NULL)
76			{
77			log_error("malloc(size=%ld) error OOM\n", buf_size);
78			return -1;
79			}
80
81			if ((fd = open(data_file, O_WRONLY \| O_CREAT \| O_TRUNC, 0640)) == -1)
82			{
83			log_error("open(%s) error (%d)\n", data_file, errno);
84			return -2;
85			}
86
87			// TODO: Generate article header
88			cache.data_len = (size_t)snprintf(cache.p_data,
89			ARTICLE_HEADER_MAX_LEN + strlen(content) + 1,
90			"%s",
91			content);
92
93			bzero(cache.line_offsets, sizeof(cache.line_offsets));
94			cache.line_total = split_data_lines(cache.p_data, SCREEN_COLS, cache.line_offsets, MAX_SPLIT_FILE_LINES);
95			if (cache.line_total >= MAX_SPLIT_FILE_LINES)
96			{
97			log_error("split_data_lines(%s) truncated over limit lines\n", data_file);
98			}
99
100			if (write(fd, &cache, sizeof(cache)) == -1)
101			{
102			log_error("write(%s, cache) error (%d)\n", data_file, errno);
103			close(fd);
104			return -3;
105			}
106			if (write(fd, cache.p_data, cache.data_len) == -1)
107			{
108			log_error("write(%s, data) error (%d)\n", data_file, errno);
109			close(fd);
110			return -3;
111			}
112
113			if (close(fd) == -1)
114			{
115			log_error("close(%s) error (%d)\n", data_file, errno);
116			return -2;
117			}
118
119			free(cache.p_data);
120
121	sysadm	1.1	return 0;
122			}
123
124			int article_cache_load(ARTICLE_CACHE p_cache, const char cache_dir, const ARTICLE *p_article)
125			{
126	sysadm	1.2	char data_file[FILE_PATH_LEN];
127			int fd;
128
129			if (p_cache == NULL \|\| cache_dir == NULL \|\| p_article == NULL)
130			{
131			log_error("article_cache_load() NULL pointer error\n");
132			return -1;
133			}
134
135			if (article_cache_path(data_file, sizeof(data_file), cache_dir, p_article) < 0)
136			{
137			log_error("article_cache_path(dir=%s, cid=%d) error\n", cache_dir, p_article->cid);
138			return -1;
139			}
140
141			if ((fd = open(data_file, O_RDONLY)) == -1)
142			{
143			log_error("open(%s) error (%d)\n", data_file, errno);
144			return -2;
145			}
146
147			if (read(fd, (void *)p_cache, sizeof(ARTICLE_CACHE)) == -1)
148			{
149			log_error("read(%s, cache) error (%d)\n", data_file, errno);
150			close(fd);
151			return -3;
152			}
153
154			p_cache->p_data = malloc(p_cache->data_len + 1);
155			if (p_cache->p_data == NULL)
156			{
157			log_error("malloc(size=%ld) error OOM\n", p_cache->data_len + 1);
158			close(fd);
159			return -1;
160			}
161
162			if (read(fd, p_cache->p_data, p_cache->data_len) == -1)
163			{
164			log_error("read(%s, data) error (%d)\n", data_file, errno);
165			close(fd);
166			return -3;
167			}
168			p_cache->p_data[p_cache->data_len] = '\0';
169
170			if (close(fd) == -1)
171			{
172			log_error("close(%s) error (%d)\n", data_file, errno);
173			return -2;
174			}
175
176	sysadm	1.1	return 0;
177			}
178
179			int article_cache_unload(ARTICLE_CACHE *p_cache)
180			{
181	sysadm	1.2	if (p_cache == NULL \|\| p_cache->p_data == NULL)
182			{
183			log_error("article_cache_unload() NULL pointer error\n");
184			return -1;
185			}
186
187			free(p_cache->p_data);
188			p_cache->p_data = NULL;
189
190	sysadm	1.1	return 0;
191			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1