1 /******************************************************************************/
2 /* pfixtools: a collection of postfix related tools */
4 /* ________________________________________________________________________ */
6 /* Redistribution and use in source and binary forms, with or without */
7 /* modification, are permitted provided that the following conditions */
10 /* 1. Redistributions of source code must retain the above copyright */
11 /* notice, this list of conditions and the following disclaimer. */
12 /* 2. Redistributions in binary form must reproduce the above copyright */
13 /* notice, this list of conditions and the following disclaimer in the */
14 /* documentation and/or other materials provided with the distribution. */
15 /* 3. The names of its contributors may not be used to endorse or promote */
16 /* products derived from this software without specific prior written */
19 /* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND */
20 /* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE */
21 /* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
22 /* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS */
23 /* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR */
24 /* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF */
25 /* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS */
26 /* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN */
27 /* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) */
28 /* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF */
29 /* THE POSSIBILITY OF SUCH DAMAGE. */
30 /******************************************************************************/
33 * Copyright © 2008 Florent Bruneau
39 #include "resources.h"
41 #define config_param_register(Param)
43 /* Filter to execute on "CONNECT"
45 config_param_register("client_filter");
47 /* Filter to execute on "MAIL FROM"
49 config_param_register("sender_filter");
51 /* Filter to execute on "RCPT TO"
53 config_param_register("recipient_filter");
55 /* Filter to execute on "DATA"
57 config_param_register("data_filter");
59 /* Filter to execute on "END-OF-DATA"
61 config_param_register("end_of_data_filter");
63 /* Filter to execute on "ETRN"
65 config_param_register("etrn_filter");
67 /* Filter to execute on "HELO"
69 config_param_register("helo_filter");
70 config_param_register("ehlo_filter");
72 /* Filter to execute on "VRFY"
74 config_param_register("verify_filter");
77 /* Where to bind the server.
79 config_param_register("port");
82 /* Format of the log message.
83 * The message exact format is $log: "reply"
85 config_param_register("log_format");
88 static config_t *global_config = NULL;
90 static inline config_t *config_new(void)
92 config_t *config = p_new(config_t, 1);
93 global_config = config;
97 static void config_close(config_t *config)
99 for (int i = 0 ; i < SMTP_count ; ++i) {
100 config->entry_points[i] = -1;
102 array_deep_wipe(config->filters, filter_wipe);
103 array_deep_wipe(config->params, filter_params_wipe);
104 p_delete(&config->log_format);
107 void config_delete(config_t **config)
110 config_close(*config);
112 global_config = NULL;
116 static void config_exit()
119 config_delete(&global_config);
122 module_exit(config_exit);
125 static bool config_parse(config_t *config)
132 bool in_section = false;
133 bool end_of_section = false;
137 int key_len, value_len;
139 if (!file_map_open(&map, config->filename, false)) {
143 filter_init(&filter);
146 #define READ_LOG(Lev, Fmt, ...) \
147 __log(LOG_ ## Lev, "config file %s:%d:%d: " Fmt, config->filename, \
148 line + 1, (int)(p - linep + 1), ##__VA_ARGS__)
149 #define READ_ERROR(Fmt, ...) \
151 READ_LOG(ERR, Fmt, ##__VA_ARGS__); \
154 #define ADD_IN_BUFFER(Buffer, Len, Char) \
156 if ((Len) >= BUFSIZ - 1) { \
157 READ_ERROR("unreasonnable long line"); \
159 (Buffer)[(Len)++] = (Char); \
160 (Buffer)[(Len)] = '\0'; \
168 if (++p >= map.end) { \
169 if (!end_of_section) { \
180 bool in_comment = false; \
181 while (in_comment || isspace(*p) || *p == '#') { \
183 in_comment = false; \
184 } else if (*p == '#') { \
190 #define READ_TOKEN(Name, Buffer, Len) \
193 (Buffer)[0] = '\0'; \
194 if (!isalpha(*p)) { \
195 READ_ERROR("invalid %s, unexpected character '%c'", Name, *p); \
198 ADD_IN_BUFFER(Buffer, Len, *p); \
200 } while (isalnum(*p) || *p == '_'); \
202 #define READ_STRING(Name, Buffer, Len, Ignore) \
205 (Buffer)[0] = '\0'; \
207 bool escaped = false; \
208 while (*p == '"') { \
212 READ_ERROR("string must not contain EOL"); \
213 } else if (escaped) { \
214 ADD_IN_BUFFER(Buffer, Len, *p); \
216 } else if (*p == '\\') { \
218 } else if (*p == '"') { \
222 ADD_IN_BUFFER(Buffer, Len, *p); \
229 READ_ERROR("%s must end with a ';'", Name); \
232 bool escaped = false; \
233 while (*p != ';' && isascii(*p) && (isprint(*p) || isspace(*p))) { \
235 if (*p == '\r' || *p == '\n') { \
238 ADD_IN_BUFFER(Buffer, Len, '\\'); \
244 } else if (*p == '\r' || *p == '\n') { \
245 READ_ERROR("%s must not contain EOL", Name); \
247 ADD_IN_BUFFER(Buffer, Len, *p); \
252 ADD_IN_BUFFER(Buffer, Len, '\\'); \
254 while ((Len) > 0 && isspace((Buffer)[(Len) - 1])) { \
255 (Buffer)[--(Len)] = '\0'; \
258 end_of_section = Ignore; \
268 value[0] = key[0] = '\0';
269 value_len = key_len = 0;
271 in_section = end_of_section = false;
274 READ_TOKEN("section name", key, key_len);
279 goto read_param_value;
284 READ_ERROR("invalid character '%c', expected '=' or '{'", *p);
289 READ_STRING("parameter value", value, value_len, true);
291 filter_param_t param;
292 param.type = param_tokenize(key, key_len);
293 if (param.type != ATK_UNKNOWN) {
294 param.value = p_dupstr(value, value_len);
295 param.value_len = value_len;
296 array_add(config->params, param);
298 READ_LOG(INFO, "unknown parameter %.*s", key_len, key);
304 filter_set_name(&filter, key, key_len);
307 READ_TOKEN("filter parameter name", key, key_len);
310 READ_ERROR("invalid character '%c', expected '='", *p);
314 READ_STRING("filter parameter value", value, value_len, false);
316 if (strcmp(key, "type") == 0) {
317 if (!filter_set_type(&filter, value, value_len)) {
318 READ_ERROR("unknow filter type (%s) for filter %s",
321 } else if (key_len > 3 && strncmp(key, "on_", 3) == 0) {
322 if (!filter_add_hook(&filter, key + 3, key_len - 3,
324 READ_ERROR("hook %s not supported by filter %s",
325 key + 3, filter.name);
328 /* filter_add_param failure mean unknown type or unsupported type.
329 * this are non-fatal errors.
331 (void)filter_add_param(&filter, key, key_len, value, value_len);
334 end_of_section = true;
336 array_add(config->filters, filter);
337 filter_init(&filter);
341 file_map_close(&map);
345 err("Unexpected end of file");
349 filter_wipe(&filter);
351 file_map_close(&map);
355 static bool config_build_structure(config_t *config)
358 if (config->filters.len > 0) {
359 # define QSORT_TYPE filter_t
360 # define QSORT_BASE config->filters.data
361 # define QSORT_NELT config->filters.len
362 # define QSORT_LT(a,b) strcmp(a->name, b->name) < 0
366 foreach (filter_t *filter, config->filters) {
367 if (!filter_update_references(filter, &config->filters)) {
375 if (!filter_check_safety(&config->filters)) {
380 #define PARSE_CHECK(Expr, Fmt, ...) \
382 err(Fmt, ##__VA_ARGS__); \
385 foreach (filter_param_t *param, config->params) {
386 switch (param->type) {
387 #define CASE(Param, State) \
388 case ATK_ ## Param ## _FILTER: \
390 config->entry_points[SMTP_ ## State] \
391 = filter_find_with_name(&config->filters, param->value); \
392 PARSE_CHECK(config->entry_points[SMTP_ ## State] >= 0, \
393 "invalid filter name %s", param->value); \
395 CASE(CLIENT, CONNECT)
399 CASE(RECIPIENT, RCPT)
401 CASE(END_OF_DATA, END_OF_MESSAGE)
405 FILTER_PARAM_PARSE_INT(PORT, config->port);
406 FILTER_PARAM_PARSE_STRING(LOG_FORMAT, config->log_format, true);
410 array_deep_wipe(config->params, filter_params_wipe);
412 if (config->log_format && !query_format_check(config->log_format)) {
413 err("invalid log format: \"%s\"", config->log_format);
418 err("no entry point defined");
423 static bool config_build_filters(config_t *config)
425 foreach (filter_t *filter, config->filters) {
426 if (!filter_build(filter)) {
434 static bool config_load(config_t *config) {
435 config_close(config);
437 if (!config_parse(config)) {
438 err("Invalid configuration: cannot parse configuration file \"%s\"", config->filename);
441 if (!config_build_structure(config)) {
442 err("Invalid configuration: inconsistent filter structure");
445 if (!config_build_filters(config)) {
446 err("Invalid configuration: invalid filter");
450 resource_garbage_collect();
454 bool config_reload(config_t *config)
456 return config_load(config);
459 config_t *config_read(const char *file)
461 config_t *config = config_new();
462 config->filename = file;
463 if (!config_reload(config)) {
464 config_delete(&config);
470 bool config_check(const char *file)
472 config_t *config = config_new();
473 config->filename = file;
475 bool ret = config_parse(config) && config_build_structure(config);
477 config_delete(&config);