lbbs/src/bwf.c

/* SPDX-License-Identifier: GPL-3.0-or-later */
/*
 * bwf
 *   - bad words filter
 *
 * Copyright (C) 2004-2026  Leaflet <leaflet@leafok.com>
 */

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

#define PCRE2_CODE_UNIT_WIDTH 8

#include "bwf.h"
#include "log.h"
#include <errno.h>
#include <pcre2.h>
#include <stdio.h>
#include <string.h>

enum _bwf_constant_t
{
        BWF_max_pattern_len = 64,
        BWF_max_pattern_cnt = 1000,
};

static char bwf_pattern_str[(BWF_max_pattern_len + 1) * BWF_max_pattern_cnt];
static pcre2_code *bwf_code = NULL;

int bwf_load(const char *filename)
{
        FILE *fp;
        char line[BWF_max_pattern_len + 1];
        size_t len_line;
        char *p = bwf_pattern_str;
        int line_id = 0;

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

        if ((fp = fopen(filename, "r")) == NULL)
        {
                log_error("fopen(%s) error: %d", filename, errno);
                return -2;
        }

        while (fgets(line, sizeof(line), fp) != NULL)
        {
                len_line = strnlen(line, sizeof(line) - 1);
                if (!feof(fp) && line[len_line - 1] != '\n')
                {
                        log_error("Data line %d (len=%d) is truncated", line_id, len_line);
                        bwf_pattern_str[0] = '\0';
                        return -3;
                }

                while (len_line > 0 && (line[len_line - 1] == '\n' || line[len_line - 1] == '\r'))
                {
                        line[len_line - 1] = '\0';
                        len_line--;
                }

                if (len_line == 0)
                {
                        continue;
                }

                if (p > bwf_pattern_str)
                {
                        *p++ = '|';
                }

                if (len_line + 2 > sizeof(bwf_pattern_str) - 1 - (size_t)(p - bwf_pattern_str))
                {
                        log_error("Data in %s exceed length limit %d", filename, sizeof(bwf_pattern_str) - 1);
                        bwf_pattern_str[0] = '\0';
                        return -3;
                }

                *p++ = '(';
                p = mempcpy(p, line, strnlen(line, sizeof(bwf_pattern_str) - 1 - (size_t)(p - bwf_pattern_str)));
                *p++ = ')';
                line_id++;
        }

        *p = '\0';

        fclose(fp);

        log_debug("Debug: bwf_pattern_str: %s", bwf_pattern_str);

        return 0;
}

int bwf_compile(void)
{
        int errorcode;
        PCRE2_SIZE erroroffset;

        bwf_cleanup();

        bwf_code = pcre2_compile((PCRE2_SPTR)bwf_pattern_str, PCRE2_ZERO_TERMINATED, PCRE2_CASELESS, &errorcode, &erroroffset, NULL);
        if (bwf_code == NULL)
        {
                log_error("pcre2_compile() error: %d", errorcode);
                return -1;
        }

        return 0;
}

void bwf_cleanup(void)
{
        if (bwf_code != NULL)
        {
                pcre2_code_free(bwf_code);
                bwf_code = NULL;
        }
}

int check_badwords(char *str, char c_mask)
{
        pcre2_match_data *match_data;
        PCRE2_SIZE startoffset = 0;
        PCRE2_SIZE *ovector;
        uint32_t match_count;
        int ret;
        int i;
        int total_match_count = 0;

        if (bwf_code == NULL)
        {
                log_error("BWF not loaded");
                return -1;
        }

        match_data = pcre2_match_data_create_from_pattern(bwf_code, NULL);

        while (1)
        {
                ret = pcre2_match(bwf_code, (PCRE2_SPTR)str, PCRE2_ZERO_TERMINATED, startoffset, 0, match_data, NULL);
                if (ret == PCRE2_ERROR_NOMATCH)
                {
                        ret = total_match_count;
                        break;
                }
                else if (ret < 0)
                {
                        log_error("pcre2_match() error: %d", ret);
                }
                else if (ret == 0)
                {
                        log_error("Vector of offsets is too small");
                }
                else // ret >= 1
                {
                        ovector = pcre2_get_ovector_pointer(match_data);
                        match_count = pcre2_get_ovector_count(match_data);

                        i = ret - 1;
                        if (ovector[i * 2] == -1 || ovector[i * 2 + 1] == -1)
                        {
                                log_error("Bug: match pattern #%d of %d with invalid offsets [%d, %d)",
                                                  i, match_count, ovector[i * 2], ovector[i * 2 + 1]);
                                ret = -2;
                        }
                        else
                        {
                                log_debug("Debug: match pattern #%d of %d at offsets [%d, %d]",
                                                  i, match_count, ovector[i * 2], ovector[i * 2 + 1] - ovector[i * 2]);
                                memset(str + ovector[i * 2], c_mask, ovector[i * 2 + 1] - ovector[i * 2]);
                                total_match_count++;
                                startoffset = ovector[i * 2 + 1];
                        }
                }
        }

        pcre2_match_data_free(match_data);

        return ret;
}
1	/* SPDX-License-Identifier: GPL-3.0-or-later */
2	/*
3	* bwf
4	* - bad words filter
5	*
6	* Copyright (C) 2004-2026 Leaflet <leaflet@leafok.com>
7	*/
8
9	#ifdef HAVE_CONFIG_H
10	#include "config.h"
11	#endif
12
13	#define PCRE2_CODE_UNIT_WIDTH 8
14
15	#include "bwf.h"
16	#include "log.h"
17	#include <errno.h>
18	#include <pcre2.h>
19	#include <stdio.h>
20	#include <string.h>
21
22	enum _bwf_constant_t
23	{
24	BWF_max_pattern_len = 64,
25	BWF_max_pattern_cnt = 1000,
26	};
27
28	static char bwf_pattern_str[(BWF_max_pattern_len + 1) * BWF_max_pattern_cnt];
29	static pcre2_code *bwf_code = NULL;
30
31	int bwf_load(const char *filename)
32	{
33	FILE *fp;
34	char line[BWF_max_pattern_len + 1];
35	size_t len_line;
36	char *p = bwf_pattern_str;
37	int line_id = 0;
38
39	if (filename == NULL)
40	{
41	log_error("NULL pointer error");
42	return -1;
43	}
44
45	if ((fp = fopen(filename, "r")) == NULL)
46	{
47	log_error("fopen(%s) error: %d", filename, errno);
48	return -2;
49	}
50
51	while (fgets(line, sizeof(line), fp) != NULL)
52	{
53	len_line = strnlen(line, sizeof(line) - 1);
54	if (!feof(fp) && line[len_line - 1] != '\n')
55	{
56	log_error("Data line %d (len=%d) is truncated", line_id, len_line);
57	bwf_pattern_str[0] = '\0';
58	return -3;
59	}
60
61	while (len_line > 0 && (line[len_line - 1] == '\n' \|\| line[len_line - 1] == '\r'))
62	{
63	line[len_line - 1] = '\0';
64	len_line--;
65	}
66
67	if (len_line == 0)
68	{
69	continue;
70	}
71
72	if (p > bwf_pattern_str)
73	{
74	*p++ = '\|';
75	}
76
77	if (len_line + 2 > sizeof(bwf_pattern_str) - 1 - (size_t)(p - bwf_pattern_str))
78	{
79	log_error("Data in %s exceed length limit %d", filename, sizeof(bwf_pattern_str) - 1);
80	bwf_pattern_str[0] = '\0';
81	return -3;
82	}
83
84	*p++ = '(';
85	p = mempcpy(p, line, strnlen(line, sizeof(bwf_pattern_str) - 1 - (size_t)(p - bwf_pattern_str)));
86	*p++ = ')';
87	line_id++;
88	}
89
90	*p = '\0';
91
92	fclose(fp);
93
94	log_debug("Debug: bwf_pattern_str: %s", bwf_pattern_str);
95
96	return 0;
97	}
98
99	int bwf_compile(void)
100	{
101	int errorcode;
102	PCRE2_SIZE erroroffset;
103
104	bwf_cleanup();
105
106	bwf_code = pcre2_compile((PCRE2_SPTR)bwf_pattern_str, PCRE2_ZERO_TERMINATED, PCRE2_CASELESS, &errorcode, &erroroffset, NULL);
107	if (bwf_code == NULL)
108	{
109	log_error("pcre2_compile() error: %d", errorcode);
110	return -1;
111	}
112
113	return 0;
114	}
115
116	void bwf_cleanup(void)
117	{
118	if (bwf_code != NULL)
119	{
120	pcre2_code_free(bwf_code);
121	bwf_code = NULL;
122	}
123	}
124
125	int check_badwords(char *str, char c_mask)
126	{
127	pcre2_match_data *match_data;
128	PCRE2_SIZE startoffset = 0;
129	PCRE2_SIZE *ovector;
130	uint32_t match_count;
131	int ret;
132	int i;
133	int total_match_count = 0;
134
135	if (bwf_code == NULL)
136	{
137	log_error("BWF not loaded");
138	return -1;
139	}
140
141	match_data = pcre2_match_data_create_from_pattern(bwf_code, NULL);
142
143	while (1)
144	{
145	ret = pcre2_match(bwf_code, (PCRE2_SPTR)str, PCRE2_ZERO_TERMINATED, startoffset, 0, match_data, NULL);
146	if (ret == PCRE2_ERROR_NOMATCH)
147	{
148	ret = total_match_count;
149	break;
150	}
151	else if (ret < 0)
152	{
153	log_error("pcre2_match() error: %d", ret);
154	}
155	else if (ret == 0)
156	{
157	log_error("Vector of offsets is too small");
158	}
159	else // ret >= 1
160	{
161	ovector = pcre2_get_ovector_pointer(match_data);
162	match_count = pcre2_get_ovector_count(match_data);
163
164	i = ret - 1;
165	if (ovector[i * 2] == -1 \|\| ovector[i * 2 + 1] == -1)
166	{
167	log_error("Bug: match pattern #%d of %d with invalid offsets [%d, %d)",
168	i, match_count, ovector[i * 2], ovector[i * 2 + 1]);
169	ret = -2;
170	}
171	else
172	{
173	log_debug("Debug: match pattern #%d of %d at offsets [%d, %d]",
174	i, match_count, ovector[i * 2], ovector[i * 2 + 1] - ovector[i * 2]);
175	memset(str + ovector[i * 2], c_mask, ovector[i * 2 + 1] - ovector[i * 2]);
176	total_match_count++;
177	startoffset = ovector[i * 2 + 1];
178	}
179	}
180	}
181
182	pcre2_match_data_free(match_data);
183
184	return ret;
185	}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1