From 6205f36ee17d54e9e43d495ba929ed7708c98027 Mon Sep 17 00:00:00 2001 From: Vsevolod Stakhov Date: Mon, 1 Oct 2012 22:08:36 +0400 Subject: [PATCH] * Add dynamic configuration dumping. * Add labels support to the statfiles (would be used for meta-classification) * Rewrite exim spam.c patch to work with both rspamd and SA by using 'variant=rspamd' option in spam_server line. --- contrib/exim/patch-exim-src_spam.c.diff | 612 ++++++++++++++++++++++-- src/cfg_file.h | 3 + src/cfg_utils.c | 4 + src/cfg_xml.c | 14 + src/dynamic_cfg.c | 152 ++++++ src/dynamic_cfg.h | 7 + src/lua/lua_classifier.c | 43 +- 7 files changed, 793 insertions(+), 42 deletions(-) diff --git a/contrib/exim/patch-exim-src_spam.c.diff b/contrib/exim/patch-exim-src_spam.c.diff index 7bae65741..09fe93c0d 100644 --- a/contrib/exim/patch-exim-src_spam.c.diff +++ b/contrib/exim/patch-exim-src_spam.c.diff @@ -1,73 +1,493 @@ ---- src/spam.c.orig 2011-01-20 19:29:51.179597017 +0300 -+++ src/spam.c 2011-02-21 21:17:15.051230555 +0300 -@@ -21,6 +21,9 @@ +diff --git a/src/OS/os.h-Linux b/src/OS/os.h-Linux +index 3fead17..03fea75 100644 +--- a/src/OS/os.h-Linux ++++ b/src/OS/os.h-Linux +@@ -20,7 +20,7 @@ performance on outgoing mail a bit. Note: With older glibc versions + this setting will conflict with the _FILE_OFFSET_BITS=64 setting + defined as part of the Linux CFLAGS. */ + +-/* #define HAVE_LINUX_SENDFILE */ ++#define HAVE_LINUX_SENDFILE + + #define F_FREESP O_TRUNC + typedef struct flock flock_t; +diff --git a/src/src/expand.c b/src/src/expand.c +index 7803862..888226f 100644 +--- a/src/src/expand.c ++++ b/src/src/expand.c +@@ -608,6 +608,7 @@ static var_entry var_table[] = { + { "sn8", vtype_filter_int, &filter_sn[8] }, + { "sn9", vtype_filter_int, &filter_sn[9] }, + #ifdef WITH_CONTENT_SCAN ++ { "spam_action", vtype_stringptr, &spam_action }, + { "spam_bar", vtype_stringptr, &spam_bar }, + { "spam_report", vtype_stringptr, &spam_report }, + { "spam_score", vtype_stringptr, &spam_score }, +diff --git a/src/src/globals.c b/src/src/globals.c +index bcbe12d..6e0d3a4 100644 +--- a/src/src/globals.c ++++ b/src/src/globals.c +@@ -1169,6 +1169,7 @@ BOOL smtp_use_size = FALSE; + uschar *spamd_address = US"127.0.0.1 783"; + uschar *spam_bar = NULL; + uschar *spam_report = NULL; ++uschar *spam_action = NULL; + uschar *spam_score = NULL; + uschar *spam_score_int = NULL; + #endif +diff --git a/src/src/globals.h b/src/src/globals.h +index 16caa41..f26a037 100644 +--- a/src/src/globals.h ++++ b/src/src/globals.h +@@ -744,6 +744,7 @@ extern BOOL smtp_use_size; /* Global for passed connections */ + extern uschar *spamd_address; /* address for the spamassassin daemon */ + extern uschar *spam_bar; /* the spam "bar" (textual representation of spam_score) */ + extern uschar *spam_report; /* the spamd report (multiline) */ ++extern uschar *spam_action; /* the spamd action */ + extern uschar *spam_score; /* the spam score (float) */ + extern uschar *spam_score_int; /* spam_score * 10 (int) */ + #endif +diff --git a/src/src/spam.c b/src/src/spam.c +index 63395f2..d284618 100644 +--- a/src/src/spam.c ++++ b/src/src/spam.c +@@ -14,12 +14,20 @@ + uschar spam_score_buffer[16]; + uschar spam_score_int_buffer[16]; + uschar spam_bar_buffer[128]; ++uschar spam_action_buffer[32]; + uschar spam_report_buffer[32600]; + uschar prev_user_name[128] = ""; int spam_ok = 0; int spam_rc = 0; + uschar *prev_spamd_address_work = NULL; +/* push formatted line into vector */ -+static int push_line(struct iovec *iov, int i, const char *fmt, ...); ++static int spam_push_line(struct iovec *iov, int i, const char *fmt, ...); ++/* write io vector to the socket */ ++static int spam_write_vector(int sock, size_t size, struct iovec *iov, time_t now); ++/* poll socket to obtain write readiness */ ++static int spam_poll_socket (int sock, time_t start); + int spam(uschar **listptr) { int sep = 0; uschar *list = *listptr; -@@ -211,14 +214,26 @@ +@@ -29,10 +37,11 @@ int spam(uschar **listptr) { + FILE *mbox_file; + int spamd_sock = -1; + uschar spamd_buffer[32600]; +- int i, j, offset, result; ++ int i, j, offset, result, is_rspamd; + uschar spamd_version[8]; ++ uschar spamd_short_result[8]; + uschar spamd_score_char; +- double spamd_threshold, spamd_score; ++ double spamd_threshold, spamd_score, spamd_reject_score; + int spamd_report_offset; + uschar *p,*q; + int override = 0; +@@ -126,8 +135,15 @@ int spam(uschar **listptr) { + spamd_address_container *this_spamd = + (spamd_address_container *)store_get(sizeof(spamd_address_container)); + ++ /* Check for spamd variant */ ++ if( Ustrstr(address, "variant=rspamd") != NULL ) { ++ this_spamd->is_rspamd = 1; ++ } ++ else { ++ this_spamd->is_rspamd = 0; ++ } + /* grok spamd address and port */ +- if( sscanf(CS address, "%s %u", this_spamd->tcp_addr, &(this_spamd->tcp_port)) != 2 ) { ++ if( sscanf(CS address, "%s %hu", this_spamd->tcp_addr, &(this_spamd->tcp_port)) != 2 ) { + log_write(0, LOG_MAIN, + "spam acl condition: warning - invalid spamd address: '%s'", address); + continue; +@@ -171,6 +187,7 @@ int spam(uschar **listptr) { + spamd_address_vector[current_server]->tcp_port, + 5 ) > -1) { + /* connection OK */ ++ is_rspamd = spamd_address_vector[current_server]->is_rspamd; + break; + }; + +@@ -207,12 +224,28 @@ int spam(uschar **listptr) { + } + + server.sun_family = AF_UNIX; +- Ustrcpy(server.sun_path, spamd_address_work); ++ p = Ustrstr(spamd_address_work, "variant=rspamd"); ++ if( p != NULL ) { ++ is_rspamd = TRUE; ++ /* strip spaces */ ++ p --; ++ while (p > spamd_address_work && isspace (*p)) { ++ p --; ++ } ++ Ustrncpy(server.sun_path, spamd_address_work, p - spamd_address_work + 1); ++ /* zero terminate */ ++ server.sun_path[p - spamd_address_work + 1] = 0; ++ } ++ else { ++ is_rspamd = FALSE; ++ Ustrcpy(server.sun_path, spamd_address_work); ++ } ++ + + if (connect(spamd_sock, (struct sockaddr *) &server, sizeof(struct sockaddr_un)) < 0) { + log_write(0, LOG_MAIN|LOG_PANIC, + "malware acl condition: spamd: unable to connect to UNIX socket %s (%s)", +- spamd_address_work, strerror(errno) ); ++ server.sun_path, strerror(errno) ); + (void)fclose(mbox_file); + (void)close(spamd_sock); + return DEFER; +@@ -228,22 +261,67 @@ int spam(uschar **listptr) { + return DEFER; } ++ (void)fcntl(spamd_sock, F_SETFL, O_NONBLOCK); /* now we are connected to spamd on spamd_sock */ - (void)string_format(spamd_buffer, - sizeof(spamd_buffer), - "REPORT SPAMC/1.2\r\nUser: %s\r\nContent-length: %ld\r\n\r\n", - user_name, - mbox_size); -+ int r, request_p = 0; -+ const char *helo; -+ struct iovec request_v[64]; -+ -+ r = 0; -+ r += push_line(request_v, request_p++, "REPORT SPAMC/1.2\r\n"); -+ r += push_line(request_v, request_p++, "Content-length: %lu\r\n", mbox_size); -+ r += push_line(request_v, request_p++, "Queue-Id: %s\r\n", message_id); -+ r += push_line(request_v, request_p++, "From: <%s>\r\n", sender_address); -+ r += push_line(request_v, request_p++, "Recipient-Number: %d\r\n", recipients_count); -+ for (i = 0; i < recipients_count; i ++) -+ r += push_line(request_v, request_p++, "Rcpt: <%s>\r\n", recipients_list[i].address); -+ if ((helo = expand_string(US"$sender_helo_name")) != NULL && *helo != '\0') -+ r += push_line(request_v, request_p++, "Helo: %s\r\n", helo); -+ if (sender_host_address != NULL) -+ r += push_line(request_v, request_p++, "IP: %s\r\n", sender_host_address); -+ r += push_line(request_v, request_p++, "\r\n"); - - /* send our request */ +- +- /* send our request */ - if (send(spamd_sock, spamd_buffer, Ustrlen(spamd_buffer), 0) < 0) { -+ if (writev(spamd_sock, request_v, request_p) < 0) { - (void)close(spamd_sock); - log_write(0, LOG_MAIN|LOG_PANIC, - "spam acl condition: spamd send failed: %s", strerror(errno)); -@@ -329,7 +344,7 @@ +- (void)close(spamd_sock); +- log_write(0, LOG_MAIN|LOG_PANIC, +- "spam acl condition: spamd send failed: %s", strerror(errno)); +- (void)fclose(mbox_file); +- (void)close(spamd_sock); +- return DEFER; +- }; ++ if (is_rspamd) { ++ /* rspamd variant */ ++ int r, request_p = 0; ++ const char *helo; ++ struct iovec *request_v; ++ ++ request_v = store_get(sizeof(struct iovec) * (8 + recipients_count)); ++ if (request_v == NULL) { ++ (void)close(spamd_sock); ++ log_write(0, LOG_MAIN|LOG_PANIC, ++ "spam acl condition: store_get failed: %s", strerror(errno)); ++ (void)fclose(mbox_file); ++ (void)close(spamd_sock); ++ return DEFER; ++ } ++ r = 0; ++ r += spam_push_line(request_v, request_p++, "CHECK RSPAMC/1.3\r\n"); ++ r += spam_push_line(request_v, request_p++, "Content-length: %lu\r\n", mbox_size); ++ r += spam_push_line(request_v, request_p++, "Queue-Id: %s\r\n", message_id); ++ r += spam_push_line(request_v, request_p++, "From: <%s>\r\n", sender_address); ++ r += spam_push_line(request_v, request_p++, "Recipient-Number: %d\r\n", recipients_count); ++ /* copy all recipients as well */ ++ for (i = 0; i < recipients_count; i ++) ++ r += spam_push_line(request_v, request_p++, "Rcpt: <%s>\r\n", recipients_list[i].address); ++ if ((helo = expand_string(US"$sender_helo_name")) != NULL && *helo != '\0') ++ r += spam_push_line(request_v, request_p++, "Helo: %s\r\n", helo); ++ if (sender_host_address != NULL) ++ r += spam_push_line(request_v, request_p++, "IP: %s\r\n", sender_host_address); ++ r += spam_push_line(request_v, request_p++, "\r\n"); ++ if (spam_write_vector (spamd_sock, request_p, request_v, start) < 0) { ++ (void)close(spamd_sock); ++ log_write(0, LOG_MAIN|LOG_PANIC, ++ "spam acl condition: spamd (rspamd) send failed: %s", strerror(errno)); ++ (void)fclose(mbox_file); ++ (void)close(spamd_sock); ++ return DEFER; ++ } ++ } ++ else { ++ /* spamassassin variant */ ++ struct iovec req_iov; ++ (void)string_format(spamd_buffer, ++ sizeof(spamd_buffer), ++ "REPORT SPAMC/1.2\r\nUser: %s\r\nContent-length: %ld\r\n\r\n", ++ user_name, ++ mbox_size); ++ /* send our request */ ++ req_iov.iov_len = Ustrlen(spamd_buffer); ++ req_iov.iov_base = spamd_buffer; ++ if (spam_write_vector (spamd_sock, 1, &req_iov, start) < 0) { ++ (void)close(spamd_sock); ++ log_write(0, LOG_MAIN|LOG_PANIC, ++ "spam acl condition: spamd send failed: %s", strerror(errno)); ++ (void)fclose(mbox_file); ++ (void)close(spamd_sock); ++ return DEFER; ++ }; ++ } ++ + + /* now send the file */ + /* spamd sometimes accepts conections but doesn't read data off +@@ -255,41 +333,53 @@ int spam(uschar **listptr) { + * Note: poll() is not supported in OSX 10.2 and is reported to be + * broken in more recent versions (up to 10.4). + */ +-#ifndef NO_POLL_H +- pollfd.fd = spamd_sock; +- pollfd.events = POLLOUT; +-#endif +- (void)fcntl(spamd_sock, F_SETFL, O_NONBLOCK); ++#ifdef HAVE_LINUX_SENDFILE ++ ssize_t copied = 0; ++ int mbox_fd; ++ off_t off = 0, size; ++ struct stat st; ++ ++ mbox_fd = fileno(mbox_file); ++ if( fstat(mbox_fd, &st) == -1 ) { ++ log_write(0, LOG_MAIN|LOG_PANIC, ++ "spam acl condition: %s on scan file", strerror(errno)); ++ (void)close(spamd_sock); ++ (void)fclose(mbox_file); ++ return DEFER; ++ } ++ size = st.st_size; ++ for (;;) { ++ if (spam_poll_socket(spamd_sock, start) == -1) { ++ (void)close(spamd_sock); ++ (void)fclose(mbox_file); ++ return DEFER; ++ } ++ copied = sendfile(spamd_sock, mbox_fd, &offset, (size - offset)); ++ if (copied < 0) { ++ if (errno == EINTR) ++ continue; ++ ++ log_write(0, LOG_MAIN|LOG_PANIC, ++ "spam acl condition: %s on spamd socket", strerror(errno)); ++ (void)close(spamd_sock); ++ (void)fclose(mbox_file); ++ return DEFER; ++ } ++ else { ++ size -= copied; ++ if (size == 0) { ++ /* the whole file has been sent */ ++ break; ++ } ++ } ++ } ++#else + do { + read = fread(spamd_buffer,1,sizeof(spamd_buffer),mbox_file); + if (read > 0) { + offset = 0; + again: +-#ifndef NO_POLL_H +- result = poll(&pollfd, 1, 1000); +- +-/* Patch posted by Erik ? for OS X and applied by PH */ +-#else +- select_tv.tv_sec = 1; +- select_tv.tv_usec = 0; +- FD_ZERO(&select_fd); +- FD_SET(spamd_sock, &select_fd); +- result = select(spamd_sock+1, NULL, &select_fd, NULL, &select_tv); +-#endif +-/* End Erik's patch */ +- +- if (result == -1 && errno == EINTR) +- goto again; +- else if (result < 1) { +- if (result == -1) +- log_write(0, LOG_MAIN|LOG_PANIC, +- "spam acl condition: %s on spamd socket", strerror(errno)); +- else { +- if (time(NULL) - start < SPAMD_TIMEOUT) +- goto again; +- log_write(0, LOG_MAIN|LOG_PANIC, +- "spam acl condition: timed out writing spamd socket"); +- } ++ if (spam_poll_socket(spamd_sock, start) == -1) { + (void)close(spamd_sock); + (void)fclose(mbox_file); + return DEFER; +@@ -318,6 +408,7 @@ again: + (void)fclose(mbox_file); + return DEFER; + } ++#endif /* HAVE_LINUX_SENDFILE */ + + (void)fclose(mbox_file); + +@@ -346,60 +437,103 @@ again: + /* reading done */ (void)close(spamd_sock); - /* dig in the spamd output and put the report in a multiline header, if requested */ +- /* dig in the spamd output and put the report in a multiline header, if requested */ - if( sscanf(CS spamd_buffer,"SPAMD/%7s 0 EX_OK\r\nContent-length: %*u\r\n\r\n%lf/%lf\r\n%n", -+ if( sscanf(CS spamd_buffer,"SPAMD/%7s 0 EX_OK\r\nSpam: %*s ; %lf / %lf\r\nContent-length: %*u\r\n\r\n%n", - spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3 ) { +- spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3 ) { ++ if (!is_rspamd) { ++ /* dig in the spamd output and put the report in a multiline header, if requested */ ++ if( sscanf(CS spamd_buffer,"SPAMD/%7s 0 EX_OK\r\nContent-length: %*u\r\n\r\n%lf/%lf\r\n%n", ++ spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3 ) { + +- /* try to fall back to pre-2.50 spamd output */ +- if( sscanf(CS spamd_buffer,"SPAMD/%7s 0 EX_OK\r\nSpam: %*s ; %lf / %lf\r\n\r\n%n", +- spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3 ) { +- log_write(0, LOG_MAIN|LOG_PANIC, +- "spam acl condition: cannot parse spamd output"); +- return DEFER; ++ /* try to fall back to pre-2.50 spamd output */ ++ if( sscanf(CS spamd_buffer,"SPAMD/%7s 0 EX_OK\r\nSpam: %*s ; %lf / %lf\r\n\r\n%n", ++ spamd_version,&spamd_score,&spamd_threshold,&spamd_report_offset) != 3 ) { ++ log_write(0, LOG_MAIN|LOG_PANIC, ++ "spam acl condition: cannot parse spamd output"); ++ return DEFER; ++ }; + }; +- }; - /* try to fall back to pre-2.50 spamd output */ -@@ -420,4 +435,31 @@ +- /* Create report. Since this is a multiline string, +- we must hack it into shape first */ +- p = &spamd_buffer[spamd_report_offset]; +- q = spam_report_buffer; +- while (*p != '\0') { +- /* skip \r */ +- if (*p == '\r') { +- p++; +- continue; +- }; +- *q = *p; +- q++; +- if (*p == '\n') { +- /* add an extra space after the newline to ensure +- that it is treated as a header continuation line */ +- *q = ' '; +- q++; ++ /* Create report. Since this is a multiline string, ++ we must hack it into shape first */ ++ p = &spamd_buffer[spamd_report_offset]; ++ q = spam_report_buffer; ++ while (*p != '\0') { ++ /* skip \r */ ++ if (*p == '\r') { ++ p++; ++ continue; ++ }; ++ *q = *p; ++ q++; ++ if (*p == '\n') { ++ /* add an extra space after the newline to ensure ++ that it is treated as a header continuation line */ ++ *q = ' '; ++ q++; ++ }; ++ p++; + }; +- p++; +- }; +- /* NULL-terminate */ +- *q = '\0'; +- q--; +- /* cut off trailing leftovers */ +- while (*q <= ' ') { ++ /* NULL-terminate */ + *q = '\0'; + q--; +- }; ++ /* cut off trailing leftovers */ ++ while (*q <= ' ') { ++ *q = '\0'; ++ q--; ++ }; ++ if( spamd_score >= spamd_threshold ) { ++ Ustrcpy(spam_action_buffer, "reject"); ++ } ++ else { ++ Ustrcpy(spam_action_buffer, "no action"); ++ } ++ } ++ else { ++ /* rspamd variant of reply */ ++ int r; ++ if( (r = sscanf(CS spamd_buffer,"RSPAMD/%7s 0 EX_OK\r\nMetric: default; %7s %lf / %lf / %lf\r\n%n", ++ spamd_version,spamd_short_result,&spamd_score,&spamd_threshold,&spamd_reject_score,&spamd_report_offset)) != 5 ) { ++ log_write(0, LOG_MAIN|LOG_PANIC, ++ "spam acl condition: cannot parse spamd output: %d", r); ++ return DEFER; ++ }; ++ /* now parse action */ ++ p = &spamd_buffer[spamd_report_offset]; ++ ++ if( Ustrncmp(p, "Action: ", sizeof("Action: ") - 1) == 0 ) { ++ p += sizeof("Action: ") - 1; ++ q = &spam_action_buffer[0]; ++ while (*p && *p != '\r' && (q - spam_action_buffer) < sizeof(spam_action_buffer) - 1) { ++ *q++ = *p++; ++ } ++ *q = '\0'; ++ } ++ /* make a simple report */ ++ if( spamd_score >= spamd_threshold ) { ++ p = "likely spam"; ++ } ++ else if ( Ustrcmp (spam_action_buffer, "no action") == 0 ) { ++ p = "unlikely spam"; ++ } ++ else { ++ p = "probably spam"; ++ } ++ string_format(spam_report_buffer, sizeof(spam_report_buffer), "This message is %s.", p); ++ } ++ ++ /* common spamd actions */ + spam_report = spam_report_buffer; ++ spam_action = spam_action_buffer; + + /* create spam bar */ + spamd_score_char = spamd_score > 0 ? '+' : '-'; + j = abs((int)(spamd_score)); + i = 0; + if( j != 0 ) { +- while((i < j) && (i <= MAX_SPAM_BAR_CHARS)) +- spam_bar_buffer[i++] = spamd_score_char; ++ while((i < j) && (i <= MAX_SPAM_BAR_CHARS)) ++ spam_bar_buffer[i++] = spamd_score_char; + } + else{ +- spam_bar_buffer[0] = '/'; +- i = 1; ++ spam_bar_buffer[0] = '/'; ++ i = 1; + } + spam_bar_buffer[i] = '\0'; + spam_bar = spam_bar_buffer; +@@ -415,12 +549,12 @@ again: + + /* compare threshold against score */ + if (spamd_score >= spamd_threshold) { +- /* spam as determined by user's threshold */ +- spam_rc = OK; ++ /* spam as determined by user's threshold */ ++ spam_rc = OK; + } + else { +- /* not spam */ +- spam_rc = FAIL; ++ /* not spam */ ++ spam_rc = FAIL; + }; + + /* remember expanded spamd_address if needed */ +@@ -440,4 +574,122 @@ again: }; } +static int -+push_line(struct iovec *iov, const int i, const char *fmt, ...) ++spam_push_line(struct iovec *iov, const int i, const char *fmt, ...) +{ + va_list ap; + size_t len; + char buf[512]; + -+ if (i >= 64) { -+ log_write(0, LOG_MAIN, "rspam: %s: index out of bounds", __FUNCTION__); -+ return (-1); -+ } -+ + va_start(ap, fmt); + len = vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); @@ -76,11 +496,121 @@ + iov[i].iov_len = len; + + if (len >= sizeof(buf)) { -+ log_write(0, LOG_MAIN, "rspam: %s: error, string was longer than %d", __FUNCTION__, sizeof(buf)); ++ log_write(0, LOG_MAIN, "rspam: error, string was longer than %d", (int)sizeof(buf)); + return (-1); + } + + return 0; +} + ++static int ++spam_write_vector(int sock, size_t size, struct iovec *iov, time_t start) ++{ ++ int r, i; ++ ++ for (;;) { ++ if (spam_poll_socket(sock, start) == -1) { ++ return -1; ++ } ++ r = writev(sock, iov, size); ++ if (r == -1) { ++ if (errno == EINTR) ++ continue; ++ ++ log_write(0, LOG_MAIN|LOG_PANIC, ++ "spam acl condition: %s on spamd socket", strerror(errno)); ++ return -1; ++ } ++ else { ++ /* check for partial writev */ ++ for (i = 0; i < size; i ++) { ++ if (r >= iov[i].iov_len) { ++ r -= iov[i].iov_len; ++ } ++ else { ++ /* partial iov write */ ++ iov[i].iov_base += r; ++ break; ++ } ++ if (r == 0) ++ break; ++ } ++ ++ if (i == size - 1 && r == 0) { ++ /* we have written everything */ ++ break; ++ } ++ else { ++ /* move iov to the last unreaded element */ ++ iov = &iov[i]; ++ size -= i; ++ } ++ } ++ } ++ ++ return 0; ++ ++} ++ ++static int ++spam_poll_socket (int sock, time_t start) ++{ ++#ifndef NO_POLL_H ++ struct pollfd pollfd; ++#else /* Patch posted by Erik ? for OS X */ ++ struct timeval select_tv; /* and applied by PH */ ++ fd_set select_fd; ++#endif ++ int r; ++ ++#ifndef NO_POLL_H ++ pollfd.fd = sock; ++ pollfd.events = POLLOUT; ++#endif ++ for (;;) { ++#ifndef NO_POLL_H ++ r = poll(&pollfd, 1, 1000); ++ ++/* Patch posted by Erik ? for OS X and applied by PH */ ++#else ++ select_tv.tv_sec = 1; ++ select_tv.tv_usec = 0; ++ FD_ZERO(&select_fd); ++ FD_SET(sock, &select_fd); ++ r = select(sock+1, NULL, &select_fd, NULL, &select_tv); ++#endif ++/* End Erik's patch */ ++ ++ if (r == -1 && errno == EINTR) ++ continue; ++ else if (r < 1) { ++ if (r == -1) ++ log_write(0, LOG_MAIN|LOG_PANIC, ++ "spam acl condition: %s on spamd socket", strerror(errno)); ++ else { ++ if (time(NULL) - start < SPAMD_TIMEOUT) ++ continue; ++ ++ log_write(0, LOG_MAIN|LOG_PANIC, ++ "spam acl condition: timed out writing spamd socket"); ++ } ++ } ++ return r; ++ } ++} ++ + #endif +diff --git a/src/src/spam.h b/src/src/spam.h +index ba700c8..6047c59 100644 +--- a/src/src/spam.h ++++ b/src/src/spam.h +@@ -22,7 +22,8 @@ + + typedef struct spamd_address_container { + uschar tcp_addr[24]; +- unsigned int tcp_port; ++ unsigned short int tcp_port; ++ unsigned is_rspamd:1; + } spamd_address_container; + #endif diff --git a/src/cfg_file.h b/src/cfg_file.h index e2c1c7678..eaad2ff22 100644 --- a/src/cfg_file.h +++ b/src/cfg_file.h @@ -182,6 +182,7 @@ typedef double (*statfile_normalize_func)(struct config_file *cfg, long double s struct statfile { gchar *symbol; /**< symbol of statfile */ gchar *path; /**< filesystem pattern (with %r or %f) */ + gchar *label; /**< label of this statfile */ gsize size; /**< size of statfile */ GList *sections; /**< list of sections in statfile */ struct statfile_autolearn_params *autolearn; /**< autolearn params */ @@ -198,6 +199,7 @@ struct statfile { */ struct classifier_config { GList *statfiles; /**< statfiles list */ + GHashTable *labels; /**< statfiles with labels */ gchar *metric; /**< metric of this classifier */ struct classifier *classifier; /**< classifier interface */ struct tokenizer *tokenizer; /**< tokenizer used for classifier */ @@ -315,6 +317,7 @@ struct config_file { GList *pre_filters; /**< list of pre-processing lua filters */ GList *post_filters; /**< list of post-processing lua filters */ gchar *dynamic_conf; /**< path to dynamic configuration */ + GList *current_dynamic_conf; /**< currently loaded dynamic configuration */ GHashTable* domain_settings; /**< settings per-domains */ GHashTable* user_settings; /**< settings per-user */ gchar* domain_settings_str; /**< string representation of settings */ diff --git a/src/cfg_utils.c b/src/cfg_utils.c index d554ae7fb..440fb65e6 100644 --- a/src/cfg_utils.c +++ b/src/cfg_utils.c @@ -826,6 +826,10 @@ check_classifier_conf (struct config_file *cfg, struct classifier_config *c) c->opts = g_hash_table_new (g_str_hash, g_str_equal); memory_pool_add_destructor (cfg->cfg_pool, (pool_destruct_func) g_hash_table_destroy, c->opts); } + if (c->labels == NULL) { + c->labels = g_hash_table_new (g_str_hash, g_str_equal); + memory_pool_add_destructor (cfg->cfg_pool, (pool_destruct_func) g_hash_table_destroy, c->labels); + } return c; } diff --git a/src/cfg_xml.c b/src/cfg_xml.c index e47ead1c8..bcec06c1d 100644 --- a/src/cfg_xml.c +++ b/src/cfg_xml.c @@ -483,6 +483,12 @@ static struct xml_parser_rule grammar[] = { G_STRUCT_OFFSET (struct statfile, path), NULL }, + { + "label", + xml_handle_string, + G_STRUCT_OFFSET (struct statfile, label), + NULL + }, { "size", xml_handle_size, @@ -1955,6 +1961,14 @@ rspamd_xml_end_element (GMarkupParseContext *context, const gchar *element_name, ccf->statfiles = g_list_prepend (ccf->statfiles, st); ud->cfg->statfiles = g_list_prepend (ud->cfg->statfiles, st); g_hash_table_insert (ud->cfg->classifiers_symbols, st->symbol, ccf); + if (st->label) { + if (g_hash_table_lookup (ccf->labels, st->label)) { + msg_warn ("duplicate statfile label %s with symbol %s, ignoring", st->label, st->symbol); + } + else { + g_hash_table_insert (ccf->labels, st->label, st); + } + } ud->section_pointer = ccf; ud->parent_pointer = NULL; ud->state = XML_READ_CLASSIFIER; diff --git a/src/dynamic_cfg.c b/src/dynamic_cfg.c index 4f4167887..17d634721 100644 --- a/src/dynamic_cfg.c +++ b/src/dynamic_cfg.c @@ -233,6 +233,7 @@ json_config_fin_cb (memory_pool_t * pool, struct map_cb_data *data) return; } + jb->cfg->current_dynamic_conf = NULL; dynamic_cfg_free (jb->config_metrics); jb->config_metrics = NULL; @@ -301,6 +302,8 @@ json_config_fin_cb (memory_pool_t * pool, struct map_cb_data *data) */ apply_dynamic_conf (jb->config_metrics, jb->cfg); + jb->cfg->current_dynamic_conf = jb->config_metrics; + json_decref (js); } @@ -339,3 +342,152 @@ init_dynamic_config (struct config_file *cfg) } } +static gboolean +dump_dynamic_list (gint fd, GList *rules) +{ + GList *cur, *cur_elt; + struct dynamic_cfg_metric *metric; + struct dynamic_cfg_symbol *sym; + struct dynamic_cfg_action *act; + FILE *f; + + /* Open buffered stream for the descriptor */ + if ((f = fdopen (fd, "a+")) == NULL) { + msg_err ("fdopen failed: %s", strerror (errno)); + return FALSE; + } + + + if (rules) { + fprintf (f, "[\n"); + cur = rules; + while (cur) { + metric = cur->data; + fprintf (f, "{\n\"metric\": \"%s\"\n", metric->name); + if (metric->symbols) { + fprintf (f, " \"symbols\": [\n"); + cur_elt = metric->symbols; + while (cur_elt) { + sym = cur_elt->data; + cur_elt = g_list_next (cur_elt); + if (cur_elt) { + fprintf (f, " {\"name\": \"%s\",\n\"value\": %.2f},\n", sym->name, sym->value); + } + else { + fprintf (f, " {\"name\": \"%s\",\n\"value\": %.2f}\n", sym->name, sym->value); + } + } + if (metric->actions) { + fprintf (f, " ],\n"); + } + else { + fprintf (f, " ]\n"); + } + } + + if (metric->actions) { + cur_elt = metric->actions; + fprintf (f, " \"actions\": [\n"); + while (cur_elt) { + act = cur_elt->data; + cur_elt = g_list_next (cur_elt); + if (cur_elt) { + fprintf (f, " {\"name\": \"%s\",\n\"value\": %.2f},\n", str_action_metric (act->action), act->value); + } + else { + fprintf (f, " {\"name\": \"%s\",\n\"value\": %.2f}\n", str_action_metric (act->action), act->value); + } + } + fprintf (f, " ]\n"); + } + cur = g_list_next (cur); + if (cur) { + fprintf (f, "},\n"); + } + else { + fprintf (f, "}\n]\n"); + } + } + } + fclose (f); + + return TRUE; +} + +/** + * Dump dynamic configuration to the disk + * @param cfg + * @return + */ +gboolean +dump_dynamic_config (struct config_file *cfg) +{ + struct stat st; + gchar *dir, pathbuf[PATH_MAX]; + gint fd; + + if (cfg->dynamic_conf == NULL || cfg->current_dynamic_conf == NULL) { + /* No dynamic conf has been specified, so do not try to dump it */ + return FALSE; + } + + if (stat (cfg->dynamic_conf, &st) == -1) { + msg_warn ("%s is unavailable: %s", cfg->dynamic_conf, strerror (errno)); + return FALSE; + } + if (access (cfg->dynamic_conf, W_OK | R_OK) == -1) { + msg_warn ("%s is inaccessible: %s", cfg->dynamic_conf, strerror (errno)); + return FALSE; + } + + dir = g_path_get_dirname (cfg->dynamic_conf); + if (dir == NULL) { + /* Inaccessible path */ + if (dir != NULL) { + g_free (dir); + } + msg_err ("invalid file: %s", cfg->dynamic_conf); + return FALSE; + } + + rspamd_snprintf (pathbuf, sizeof (pathbuf), "%s%crconf-XXXXXX", dir, G_DIR_SEPARATOR); +#ifdef HAVE_MKSTEMP + /* Umask is set before */ + fd = mkstemp (pathbuf); +#else + fd = g_mkstemp_full (pathbuf, O_RDWR, S_IWUSR | S_IRUSR); +#endif + if (fd == -1) { + msg_err ("mkstemp error: %s", strerror (errno)); + + return FALSE; + } + + if (!dump_dynamic_list (fd, cfg->current_dynamic_conf)) { + close (fd); + unlink (pathbuf); + return FALSE; + } + + if (unlink (cfg->dynamic_conf) == -1) { + msg_err ("unlink error: %s", strerror (errno)); + close (fd); + unlink (pathbuf); + return FALSE; + } + + /* Rename old config */ + if (rename (pathbuf, cfg->dynamic_conf) == -1) { + msg_err ("unlink error: %s", strerror (errno)); + close (fd); + unlink (pathbuf); + return FALSE; + } + /* Set permissions */ + if (chmod (cfg->dynamic_conf, st.st_mode) == -1) { + msg_warn ("chmod failed: %s", strerror (errno)); + } + + close (fd); + return TRUE; +} diff --git a/src/dynamic_cfg.h b/src/dynamic_cfg.h index edf026e53..494a48835 100644 --- a/src/dynamic_cfg.h +++ b/src/dynamic_cfg.h @@ -34,5 +34,12 @@ */ void init_dynamic_config (struct config_file *cfg); +/** + * Dump dynamic configuration to the disk + * @param cfg + * @return + */ +gboolean dump_dynamic_config (struct config_file *cfg); + #endif /* DYNAMIC_CFG_H_ */ diff --git a/src/lua/lua_classifier.c b/src/lua/lua_classifier.c index d4a8edb87..c6eb2cf18 100644 --- a/src/lua/lua_classifier.c +++ b/src/lua/lua_classifier.c @@ -31,17 +31,20 @@ LUA_FUNCTION_DEF (classifier, register_pre_callback); LUA_FUNCTION_DEF (classifier, register_post_callback); LUA_FUNCTION_DEF (classifier, get_statfiles); +LUA_FUNCTION_DEF (classifier, get_statfile_by_label); static const struct luaL_reg classifierlib_m[] = { LUA_INTERFACE_DEF (classifier, register_pre_callback), LUA_INTERFACE_DEF (classifier, register_post_callback), LUA_INTERFACE_DEF (classifier, get_statfiles), + LUA_INTERFACE_DEF (classifier, get_statfile_by_label), {"__tostring", lua_class_tostring}, {NULL, NULL} }; LUA_FUNCTION_DEF (statfile, get_symbol); +LUA_FUNCTION_DEF (statfile, get_label); LUA_FUNCTION_DEF (statfile, get_path); LUA_FUNCTION_DEF (statfile, get_size); LUA_FUNCTION_DEF (statfile, is_spam); @@ -49,6 +52,7 @@ LUA_FUNCTION_DEF (statfile, get_param); static const struct luaL_reg statfilelib_m[] = { LUA_INTERFACE_DEF (statfile, get_symbol), + LUA_INTERFACE_DEF (statfile, get_label), LUA_INTERFACE_DEF (statfile, get_path), LUA_INTERFACE_DEF (statfile, get_size), LUA_INTERFACE_DEF (statfile, is_spam), @@ -236,7 +240,7 @@ lua_classifier_register_post_callback (lua_State *L) return 0; } -/* Return table of statfiles indexed by theirs name */ +/* Return table of statfiles indexed by name */ static gint lua_classifier_get_statfiles (lua_State *L) { @@ -267,6 +271,28 @@ lua_classifier_get_statfiles (lua_State *L) return 1; } +/* Get statfile with specified label */ +static gint +lua_classifier_get_statfile_by_label (lua_State *L) +{ + struct classifier_config *ccf = lua_check_classifier (L); + struct statfile *st, **pst; + const gchar *label; + + label = luaL_checkstring (L, 2); + if (ccf && label) { + st = g_hash_table_lookup (ccf->labels, label); + if (st) { + pst = lua_newuserdata (L, sizeof (struct statfile *)); + lua_setclass (L, "rspamd{statfile}", -1); + *pst = st; + return 1; + } + } + lua_pushnil (L); + return 1; +} + /* Statfile functions */ static gint lua_statfile_get_symbol (lua_State *L) @@ -283,6 +309,21 @@ lua_statfile_get_symbol (lua_State *L) return 1; } +static gint +lua_statfile_get_label (lua_State *L) +{ + struct statfile *st = lua_check_statfile (L); + + if (st != NULL && st->label != NULL) { + lua_pushstring (L, st->label); + } + else { + lua_pushnil (L); + } + + return 1; +} + static gint lua_statfile_get_path (lua_State *L) { -- 2.39.5