Mercurial > dnsbl
annotate src/context.cpp @ 318:e2dc882839f6 stable-6-0-47
better smtp verify logging
author | Carl Byington <carl@five-ten-sg.com> |
---|---|
date | Thu, 22 Sep 2016 08:43:02 -0700 |
parents | f7c5cfb76e86 |
children | e27c24c1974a |
rev | line source |
---|---|
94 | 1 /* |
2 | |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
3 Copyright (c) 2013 Carl Byington - 510 Software Group, released under |
152 | 4 the GPL version 3 or any later version at your choice available at |
5 http://www.gnu.org/licenses/gpl-3.0.txt | |
94 | 6 |
7 */ | |
8 | |
9 #include "includes.h" | |
10 | |
160 | 11 #include <arpa/inet.h> |
94 | 12 #include <net/if.h> |
160 | 13 #include <netdb.h> |
94 | 14 #include <netinet/in.h> |
15 #include <netinet/tcp.h> | |
160 | 16 #include <sys/ioctl.h> |
94 | 17 #include <sys/socket.h> |
160 | 18 #include <sys/stat.h> |
94 | 19 #include <sys/un.h> |
160 | 20 #include <unistd.h> |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
21 #include <climits> |
94 | 22 |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
23 const char *token_asterisk; |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
24 const char *token_autowhite; |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
25 const char *token_bang; |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
26 const char *token_black; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
27 const char *token_content; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
28 const char *token_context; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
29 const char *token_dccbulk; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
30 const char *token_dccfrom; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
31 const char *token_dccgrey; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
32 const char *token_dccto; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
33 const char *token_default; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
34 const char *token_dnsbl; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
35 const char *token_dnsbll; |
249 | 36 const char *token_dnswl; |
37 const char *token_dnswll; | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
38 const char *token_envfrom; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
39 const char *token_envto; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
40 const char *token_filter; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
41 const char *token_generic; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
42 const char *token_host_limit; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
43 const char *token_html_limit; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
44 const char *token_html_tags; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
45 const char *token_ignore; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
46 const char *token_include; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
47 const char *token_inherit; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
48 const char *token_lbrace; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
49 const char *token_mailhost; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
50 const char *token_many; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
51 const char *token_no; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
52 const char *token_off; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
53 const char *token_ok; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
54 const char *token_ok2; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
55 const char *token_on; |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
56 const char *token_period; |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
57 const char *token_rate; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
58 const char *token_rbrace; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
59 const char *token_require; |
268
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
60 const char *token_requirerdns; |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
61 const char *token_semi; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
62 const char *token_soft; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
63 const char *token_spamassassin; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
64 const char *token_substitute; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
65 const char *token_tld; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
66 const char *token_unknown; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
67 const char *token_uribl; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
68 const char *token_verify; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
69 const char *token_white; |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
70 const char *token_white_regex; |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
71 const char *token_yes; |
94 | 72 |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
73 const char *token_myhostname; |
96
1edd4e8d3a60
fix missing include, not all systems define HOST_NAME_MAX
carl
parents:
94
diff
changeset
|
74 #ifndef HOST_NAME_MAX |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
75 #define HOST_NAME_MAX 255 |
96
1edd4e8d3a60
fix missing include, not all systems define HOST_NAME_MAX
carl
parents:
94
diff
changeset
|
76 #endif |
94 | 77 char myhostname[HOST_NAME_MAX+1]; |
78 | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
79 pthread_mutex_t verifier_mutex; // protect the verifier map |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
80 verify_map verifiers; |
153 | 81 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
82 pthread_mutex_t whitelister_mutex; // protect the whitelisters map |
153 | 83 whitelister_map whitelisters; |
84 | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
85 string_set all_strings; // owns all the strings, only modified by the config loader thread |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
86 const int maxlen = 1000; // used for snprintf buffers |
178 | 87 const int maxsmtp_age = 60;// smtp verify sockets older than this are ancient |
153 | 88 const int maxauto_age = 600;// auto whitelister delay before flushing to file |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
89 extern int NULL_SOCKET; |
129
c5cd1261394d
ignore smtp connection attempts for 10 minutes when getting connection errors on verify hosts
carl
parents:
119
diff
changeset
|
90 const time_t ERROR_SMTP_SOCKET_TIME = 600; // number of seconds between attempts to open a socket to an smtp server |
94 | 91 |
92 | |
93 int SMTP::writer() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
94 #ifdef VERIFY_DEBUG |
316
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
95 log("writer(%d) sees buffer with '%s'", buffer); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
96 #endif |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
97 int rs = 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
98 if (!error) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
99 int len = strlen(buffer); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
100 while (rs < len) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
101 int ws = write(fd, buffer+rs, len-rs); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
102 if (ws > 0) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
103 rs += ws; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
104 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
105 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
106 // peer closed the socket! |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
107 rs = 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
108 error = true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
109 break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
110 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
111 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
112 } |
316
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
113 #ifdef VERIFY_DEBUG |
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
114 log("writer(%d) sees error %d", (int)error); |
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
115 #endif |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
116 return rs; |
94 | 117 } |
118 | |
119 | |
120 int SMTP::reader() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
121 // read some bytes terminated by lf or end of buffer. |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
122 // we may have a multi line response or part thereof in the buffer. |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
123 #ifdef VERIFY_DEBUG |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
124 log("reader(%d) sees error %d", (int)error); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
125 #endif |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
126 if (error) return 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
127 int len = maxlen-1; // room for null terminator |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
128 while (pending < len) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
129 int ws = read(fd, buffer+pending, len-pending); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
130 if (ws > 0) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
131 pending += ws; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
132 if (buffer[pending-1] == '\n') break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
133 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
134 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
135 // peer closed the socket! |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
136 pending = 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
137 error = true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
138 break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
139 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
140 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
141 buffer[pending] = '\0'; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
142 #ifdef VERIFY_DEBUG |
316
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
143 log("reader(%d) sees buffer with '%s'", buffer); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
144 #endif |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
145 return pending; |
94 | 146 } |
147 | |
148 | |
149 int SMTP::read_line() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
150 char *lf = strchr(buffer, '\n'); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
151 if (!lf) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
152 reader(); // get a lf |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
153 lf = strchr(buffer, '\n'); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
154 if (!lf) lf = buffer + pending - 1; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
155 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
156 return (lf-buffer)+1; // number of bytes in this line |
94 | 157 } |
158 | |
159 | |
97 | 160 void SMTP::flush_line(int r) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
161 if (pending > r) memmove(buffer, buffer+r, pending-r); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
162 pending -= r; |
94 | 163 } |
164 | |
165 | |
166 int SMTP::read_response() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
167 pending = 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
168 buffer[pending] = '\0'; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
169 while (true) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
170 int r = read_line(); |
316
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
171 log("verify::read_response(%d) sees line with '%s'", buffer); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
172 if (r == 0) return 0; // failed to read any bytes |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
173 if ((r > 4) && (buffer[3] == '-')) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
174 flush_line(r); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
175 continue; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
176 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
177 return atoi(buffer); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
178 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
179 return 0; |
94 | 180 } |
181 | |
182 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
183 int SMTP::cmd(const char *c) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
184 if (c) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
185 init(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
186 append(c); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
187 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
188 append("\r\n"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
189 writer(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
190 return read_response(); |
94 | 191 } |
192 | |
193 | |
194 int SMTP::helo() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
195 if (read_response() != 220) return 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
196 init(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
197 append("HELO "); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
198 append(token_myhostname); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
199 return cmd(NULL); |
94 | 200 } |
201 | |
202 | |
203 int SMTP::rset() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
204 efrom[0] = '\0'; |
316
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
205 return cmd("RSET"); |
94 | 206 } |
207 | |
208 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
209 int SMTP::from(const char *f) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
210 // the mail from address was originally passed in from sendmail enclosed in |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
211 // <>. to_lower_string() removed the <> and converted the rest to lowercase, |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
212 // except in the case of an empty return path, which was left as the two |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
213 // character string <>. |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
214 if (strncmp(efrom, f, maxlen)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
215 strncpy(efrom, f, maxlen); |
311
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
216 efrom[maxlen-1] = '\0'; // ensure null termination |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
217 init(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
218 append("MAIL FROM:<"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
219 if (*f != '<') append(f); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
220 append(">"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
221 return cmd(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
222 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
223 return 250; // pretend it worked |
94 | 224 } |
225 | |
226 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
227 int SMTP::rcpt(const char *t) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
228 init(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
229 append("RCPT TO:<"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
230 append(t); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
231 append(">"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
232 return cmd(NULL); |
94 | 233 } |
234 | |
235 | |
236 int SMTP::quit() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
237 return cmd("QUIT"); |
94 | 238 } |
239 | |
240 | |
241 void SMTP::closefd() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
242 shutdown(fd, SHUT_RDWR); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
243 close(fd); |
94 | 244 } |
245 | |
246 | |
311
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
247 void SMTP::log(const char *m, int v) { |
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
248 char buf[maxlen]; |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
249 snprintf(buf, maxlen, m, get_fd(), v); |
311
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
250 my_syslog(queueid, buf); |
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
251 } |
94 | 252 |
253 | |
311
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
254 void SMTP::log(const char *m, const char *v) { |
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
255 char buf[maxlen]; |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
256 snprintf(buf, maxlen, m, get_fd(), v); |
311
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
257 my_syslog(queueid, buf); |
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
258 } |
94 | 259 |
260 | |
153 | 261 //////////////////////////////////////////////// |
262 // smtp verifier so backup mx machines can see the valid users | |
263 // | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
264 VERIFY::VERIFY(const char *h) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
265 host = h; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
266 last_err = 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
267 pthread_mutex_init(&mutex, 0); |
94 | 268 } |
269 | |
270 | |
271 void VERIFY::closer() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
272 bool ok = true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
273 while (ok) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
274 SMTP *conn = NULL; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
275 pthread_mutex_lock(&mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
276 if (connections.empty()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
277 ok = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
278 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
279 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
280 conn = connections.front(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
281 time_t now = time(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
282 if ((now - conn->get_stamp()) > maxsmtp_age) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
283 // this connection is ancient, remove it |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
284 connections.pop_front(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
285 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
286 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
287 ok = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
288 conn = NULL; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
289 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
290 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
291 pthread_mutex_unlock(&mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
292 // avoid doing this work inside the mutex lock |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
293 if (conn) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
294 #ifdef VERIFY_DEBUG |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
295 conn->log("closer(%d) closes ancient socket %s", ""); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
296 #endif |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
297 delete conn; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
298 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
299 } |
94 | 300 } |
301 | |
302 | |
311
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
303 SMTP* VERIFY::get_connection(const char *queueid) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
304 SMTP *conn = NULL; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
305 pthread_mutex_lock(&mutex); |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
306 while (!connections.empty()) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
307 conn = connections.front(); |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
308 time_t now = time(NULL); |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
309 if ((now - conn->get_stamp()) > maxsmtp_age) { |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
310 // this connection is ancient, remove it |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
311 conn->log("verify::get_connection(%d) closes ancient socket %s", ""); |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
312 connections.pop_front(); |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
313 delete conn; |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
314 conn = NULL; |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
315 } |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
316 else { |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
317 conn->set_id(queueid); |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
318 connections.pop_front(); |
318
e2dc882839f6
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
316
diff
changeset
|
319 conn->log("verify::get_connection(%d) from cache %s", ""); |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
320 break; |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
321 } |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
322 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
323 pthread_mutex_unlock(&mutex); |
316
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
324 if (conn) { |
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
325 int rc = conn->rset(); |
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
326 conn->log("verify::getconnection(%d) rset sees %d", rc); |
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
327 if (rc == 250) return conn; |
318
e2dc882839f6
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
316
diff
changeset
|
328 delete conn; |
e2dc882839f6
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
316
diff
changeset
|
329 // old connection from cache was unusable, fall thru and make a new one |
316
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
330 } |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
331 int sock = NULL_SOCKET; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
332 if ((time(NULL) - last_err) > ERROR_SMTP_SOCKET_TIME) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
333 // nothing recent, maybe this time it will work |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
334 hostent *h = gethostbyname(host); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
335 if (h) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
336 sockaddr_in server; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
337 server.sin_family = h->h_addrtype; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
338 server.sin_port = htons(25); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
339 memcpy(&server.sin_addr, h->h_addr_list[0], h->h_length); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
340 sock = socket(PF_INET, SOCK_STREAM, 0); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
341 if (sock != NULL_SOCKET) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
342 bool rc = (connect(sock, (sockaddr *)&server, sizeof(server)) == 0); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
343 if (!rc) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
344 shutdown(sock, SHUT_RDWR); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
345 close(sock); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
346 sock = NULL_SOCKET; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
347 last_err = time(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
348 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
349 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
350 else last_err = time(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
351 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
352 else last_err = time(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
353 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
354 if (sock != NULL_SOCKET) { |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
355 struct timeval tv; |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
356 tv.tv_sec = 15; |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
357 tv.tv_usec = 0; |
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
358 setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval)); |
316
f7c5cfb76e86
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
314
diff
changeset
|
359 setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(struct timeval)); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
360 conn = new SMTP(sock); |
311
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
361 conn->set_id(queueid); |
318
e2dc882839f6
better smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
316
diff
changeset
|
362 conn->log("get_connection(%d) new socket %s", ""); |
311
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
363 int rc = conn->helo(); |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
364 conn->log("verify::get_connection(%d) helo sees %d", rc); |
311
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
365 if (rc == 250) return conn; |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
366 delete conn; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
367 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
368 return NULL; |
94 | 369 } |
370 | |
371 | |
372 void VERIFY::put_connection(SMTP *conn) { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
373 if (conn->err()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
374 #ifdef VERIFY_DEBUG |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
375 conn->log("put_socket(%d) with error %s", ""); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
376 #endif |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
377 delete conn; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
378 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
379 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
380 #ifdef VERIFY_DEBUG |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
381 conn->log("put_socket(%d) no error %s", ""); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
382 #endif |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
383 conn->now(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
384 pthread_mutex_lock(&mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
385 connections.push_back(conn); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
386 pthread_mutex_unlock(&mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
387 } |
94 | 388 } |
389 | |
390 | |
310
802e2b779ed1
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
278
diff
changeset
|
391 bool VERIFY::ok(const char *queueid, const char *from, const char *to) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
392 if (host == token_myhostname) return true; |
311
f5547e7b3a09
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
310
diff
changeset
|
393 SMTP *conn = get_connection(queueid); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
394 if (!conn) return true; // cannot verify right now, we have socket errors |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
395 int rc; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
396 rc = conn->from(from); |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
397 conn->log("verify::ok(%d) from sees %d", rc); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
398 if (rc != 250) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
399 put_connection(conn); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
400 return (rc >= 500) ? false : true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
401 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
402 rc = conn->rcpt(to); |
314
ef5a6099cbe7
enable smtp verify logging
Carl Byington <carl@five-ten-sg.com>
parents:
311
diff
changeset
|
403 conn->log("verify::ok(%d) rcpt sees %d", rc); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
404 put_connection(conn); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
405 return (rc >= 500) ? false : true; |
94 | 406 } |
407 | |
408 | |
153 | 409 //////////////////////////////////////////////// |
410 // setup a new smtp verify host | |
411 // | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
412 VERIFYP add_verify_host(const char *host); |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
413 VERIFYP add_verify_host(const char *host) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
414 VERIFYP rc = NULL; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
415 pthread_mutex_lock(&verifier_mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
416 verify_map::iterator i = verifiers.find(host); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
417 if (i == verifiers.end()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
418 rc = new VERIFY(host); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
419 verifiers[host] = rc; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
420 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
421 else rc = (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
422 pthread_mutex_unlock(&verifier_mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
423 return rc; |
153 | 424 } |
425 | |
426 | |
427 //////////////////////////////////////////////// | |
428 // thread to check for verify hosts with old sockets that we can close | |
429 // | |
430 void* verify_closer(void *arg) { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
431 while (true) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
432 sleep(maxsmtp_age); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
433 pthread_mutex_lock(&verifier_mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
434 for (verify_map::iterator i=verifiers.begin(); i!=verifiers.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
435 VERIFYP v = (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
436 v->closer(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
437 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
438 pthread_mutex_unlock(&verifier_mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
439 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
440 return NULL; |
153 | 441 } |
442 | |
443 | |
444 //////////////////////////////////////////////// | |
445 // automatic whitelister | |
446 // | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
447 WHITELISTER::WHITELISTER(const char *f, int d) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
448 fn = f; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
449 days = d; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
450 pthread_mutex_init(&mutex, 0); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
451 need = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
452 loaded = time(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
453 merge(); |
160 | 454 } |
455 | |
456 | |
457 void WHITELISTER::merge() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
458 time_t now = time(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
459 ifstream ifs; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
460 ifs.open(fn); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
461 if (!ifs.fail()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
462 const int maxlen = 1000; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
463 char buf[maxlen]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
464 while (ifs.getline(buf, maxlen)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
465 char *p = strchr(buf, ' '); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
466 if (p) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
467 *p = '\0'; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
468 char *who = strdup(buf); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
469 time_t when = atoi(p+1); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
470 if ((when == 0) || (when > now)) when = now; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
471 autowhite_sent::iterator i = rcpts.find(who); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
472 if (i == rcpts.end()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
473 rcpts[who] = when; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
474 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
475 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
476 time_t wh = (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
477 if ((when == 1) || (when > wh)) (*i).second = when; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
478 free(who); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
479 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
480 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
481 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
482 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
483 ifs.close(); |
153 | 484 } |
485 | |
486 | |
487 void WHITELISTER::writer() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
488 pthread_mutex_lock(&mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
489 time_t limit = time(NULL) - days*86400; |
160 | 490 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
491 // check for manually modified autowhitelist file |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
492 struct stat st; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
493 if (stat(fn, &st)) need = true; // file has disappeared |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
494 else if (st.st_mtime > loaded) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
495 // file has been manually updated, merge new entries |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
496 merge(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
497 need = true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
498 } |
160 | 499 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
500 // purge old entries |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
501 for (autowhite_sent::iterator i=rcpts.begin(); i!=rcpts.end();) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
502 time_t when = (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
503 if (when < limit) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
504 const char *who = (*i).first; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
505 free((void*)who); |
195 | 506 rcpts.erase(i++); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
507 need = true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
508 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
509 else i++; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
510 } |
160 | 511 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
512 if (need) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
513 // dump the file |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
514 ofstream ofs; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
515 ofs.open(fn); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
516 if (!ofs.fail()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
517 for (autowhite_sent::iterator i=rcpts.begin(); i!=rcpts.end(); i++) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
518 const char *who = (*i).first; |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
519 int when = (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
520 if (!strchr(who, ' ')) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
521 ofs << who << " " << when << endl; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
522 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
523 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
524 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
525 ofs.close(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
526 need = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
527 loaded = time(NULL); // update load time |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
528 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
529 pthread_mutex_unlock(&mutex); |
153 | 530 } |
531 | |
532 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
533 void WHITELISTER::sent(const char *to) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
534 // we take ownership of the string |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
535 pthread_mutex_lock(&mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
536 need = true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
537 autowhite_sent::iterator i = rcpts.find(to); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
538 if (i == rcpts.end()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
539 rcpts[to] = time(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
540 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
541 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
542 (*i).second = time(NULL); |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
543 free((void*)to); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
544 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
545 pthread_mutex_unlock(&mutex); |
153 | 546 } |
547 | |
548 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
549 bool WHITELISTER::is_white(const char *from) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
550 pthread_mutex_lock(&mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
551 autowhite_sent::iterator i = rcpts.find(from); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
552 bool rc = (i != rcpts.end()); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
553 pthread_mutex_unlock(&mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
554 return rc; |
153 | 555 } |
556 | |
557 | |
558 //////////////////////////////////////////////// | |
559 // setup a new auto whitelister file | |
560 // | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
561 WHITELISTERP add_whitelister_file(const char *fn, int days); |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
562 WHITELISTERP add_whitelister_file(const char *fn, int days) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
563 WHITELISTERP rc = NULL; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
564 pthread_mutex_lock(&whitelister_mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
565 whitelister_map::iterator i = whitelisters.find(fn); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
566 if (i == whitelisters.end()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
567 rc = new WHITELISTER(fn, days); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
568 whitelisters[fn] = rc; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
569 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
570 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
571 rc = (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
572 rc->set_days(days); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
573 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
574 pthread_mutex_unlock(&whitelister_mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
575 return rc; |
153 | 576 } |
577 | |
578 | |
579 //////////////////////////////////////////////// | |
580 // thread to check for whitelister hosts with old sockets that we can close | |
581 // | |
582 void* whitelister_writer(void *arg) { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
583 while (true) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
584 sleep(maxauto_age); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
585 pthread_mutex_lock(&whitelister_mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
586 for (whitelister_map::iterator i=whitelisters.begin(); i!=whitelisters.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
587 WHITELISTERP v = (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
588 v->writer(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
589 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
590 pthread_mutex_unlock(&whitelister_mutex); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
591 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
592 return NULL; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
593 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
594 |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
595 |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
596 DELAYWHITE::DELAYWHITE(const char *loto_, WHITELISTERP w_, CONTEXTP con_) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
597 loto = loto_; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
598 w = w_; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
599 con = con_; |
153 | 600 } |
601 | |
602 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
603 DNSBL::DNSBL(const char *n, const char *s, const char *m) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
604 name = n; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
605 suffix = s; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
606 message = m; |
94 | 607 } |
608 | |
609 | |
610 bool DNSBL::operator==(const DNSBL &rhs) { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
611 return (strcmp(name, rhs.name) == 0) && |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
612 (strcmp(suffix, rhs.suffix) == 0) && |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
613 (strcmp(message, rhs.message) == 0); |
94 | 614 } |
615 | |
616 | |
249 | 617 DNSWL::DNSWL(const char *n, const char *s, const int l) { |
618 name = n; | |
619 suffix = s; | |
620 level = l; | |
621 } | |
622 | |
623 | |
624 bool DNSWL::operator==(const DNSWL &rhs) { | |
625 return (strcmp(name, rhs.name) == 0) && | |
626 (strcmp(suffix, rhs.suffix) == 0) && | |
627 (level == rhs.level); | |
628 } | |
629 | |
630 | |
94 | 631 CONFIG::CONFIG() { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
632 reference_count = 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
633 generation = 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
634 load_time = 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
635 default_context = NULL; |
94 | 636 } |
637 | |
638 | |
639 CONFIG::~CONFIG() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
640 if (debug_syslog) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
641 char buf[maxlen]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
642 snprintf(buf, sizeof(buf), "freeing memory for old configuration generation %d", generation); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
643 my_syslog(buf); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
644 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
645 for (context_list::iterator i=contexts.begin(); i!=contexts.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
646 CONTEXT *c = *i; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
647 delete c; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
648 } |
94 | 649 } |
650 | |
651 | |
652 void CONFIG::add_context(CONTEXTP con) { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
653 contexts.push_back(con); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
654 if (!default_context && !con->get_parent()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
655 // first global context |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
656 default_context = con; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
657 } |
94 | 658 } |
659 | |
660 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
661 void CONFIG::add_to(const char *to, CONTEXTP con) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
662 context_map::iterator i = env_to.find(to); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
663 if (i != env_to.end()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
664 CONTEXTP c = (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
665 if ((c != con) && (c != con->get_parent())) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
666 if (debug_syslog) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
667 char oldname[maxlen]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
668 char newname[maxlen]; |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
669 const char *oldn = c->get_full_name(oldname, maxlen); |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
670 const char *newn = con->get_full_name(newname, maxlen); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
671 char buf[maxlen*3]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
672 snprintf(buf, maxlen*3, "both %s and %s claim envelope to %s, the second one wins", oldn, newn, to); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
673 my_syslog(buf); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
674 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
675 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
676 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
677 env_to[to] = con; |
94 | 678 } |
679 | |
680 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
681 CONTEXTP CONFIG::find_context(const char *to) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
682 context_map::iterator i = env_to.find(to); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
683 if (i != env_to.end()) return (*i).second; // found user@domain key |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
684 const char *x = strchr(to, '@'); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
685 if (x) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
686 x++; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
687 i = env_to.find(x); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
688 if (i != env_to.end()) return (*i).second; // found domain key |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
689 size_t len = x - to; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
690 char user[len+1]; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
691 memcpy(user, to, len); |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
692 user[len] = '\0'; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
693 i = env_to.find(user); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
694 if (i != env_to.end()) return (*i).second; // found user@ key |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
695 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
696 return default_context; |
94 | 697 } |
698 | |
699 | |
700 void CONFIG::dump() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
701 bool spamass = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
702 if (default_context) default_context->dump(true, spamass); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
703 for (context_list::iterator i=contexts.begin(); i!=contexts.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
704 CONTEXTP c = *i; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
705 CONTEXTP p = c->get_parent(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
706 if (!p && (c != default_context)) c->dump(false, spamass); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
707 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
708 char buf[maxlen]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
709 for (context_map::iterator i=env_to.begin(); i!=env_to.end(); i++) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
710 const char *to = (*i).first; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
711 CONTEXTP con = (*i).second; |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
712 printf("// envelope to %s \t-> context %s \n", to, con->get_full_name(buf,maxlen)); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
713 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
714 if (spamass && (spamc == spamc_empty)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
715 printf("// *** warning - spamassassin filtering requested, but spamc not found by autoconf.\n"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
716 } |
94 | 717 } |
718 | |
719 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
720 CONTEXT::CONTEXT(CONTEXTP parent_, const char *name_) { |
278
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
721 parent = parent_; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
722 name = name_; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
723 verify_host = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
724 verifier = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
725 generic_regx = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
726 generic_message = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
727 white_regx = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
728 autowhite_file = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
729 whitelister = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
730 env_from_default = (parent) ? token_inherit : token_unknown; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
731 content_filtering = (parent) ? parent->content_filtering : false; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
732 content_suffix = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
733 content_message = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
734 uribl_suffix = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
735 uribl_message = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
736 host_limit = (parent) ? parent->host_limit : 0; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
737 host_limit_message = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
738 host_random = (parent) ? parent->host_random : false; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
739 tag_limit = (parent) ? parent->tag_limit : 0; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
740 tag_limit_message = NULL; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
741 spamassassin_limit = (parent) ? parent->spamassassin_limit : 0; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
742 require_match = (parent) ? parent->require_match : false; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
743 require_rdns = (parent) ? parent->require_rdns : false; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
744 dcc_greylist = (parent) ? parent->dcc_greylist : false; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
745 dcc_bulk_threshold = (parent) ? parent->dcc_bulk_threshold : 0; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
746 dnsbl_list_parsed = false; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
747 dnswl_list_parsed = false; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
748 default_rate_limit = 36000; // 10 per second |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
749 default_address_limit = 10; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
750 daily_rate_multiple = 3; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
751 daily_address_multiple = 3; |
94 | 752 } |
753 | |
754 | |
755 CONTEXT::~CONTEXT() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
756 for (dnsblp_map::iterator i=dnsbl_names.begin(); i!=dnsbl_names.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
757 DNSBLP d = (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
758 // delete the underlying DNSBL objects. |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
759 delete d; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
760 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
761 if (generic_regx) regfree(&generic_pattern); |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
762 if (white_regx) regfree(&white_pattern); |
94 | 763 } |
764 | |
765 | |
766 bool CONTEXT::is_parent(CONTEXTP p) { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
767 if (p == parent) return true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
768 if (!parent) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
769 return parent->is_parent(p); |
94 | 770 } |
771 | |
772 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
773 const char *CONTEXT::get_full_name(char *buffer, int size) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
774 if (!parent) return name; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
775 char buf[maxlen]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
776 snprintf(buffer, size, "%s.%s", parent->get_full_name(buf, maxlen), name); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
777 return buffer; |
94 | 778 } |
779 | |
780 | |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
781 bool CONTEXT::set_white(const char *regx) |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
782 { |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
783 int rc = 0; |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
784 if (white_regx) regfree(&white_pattern); |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
785 white_regx = regx; |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
786 if (white_regx) { |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
787 rc = regcomp(&white_pattern, regx, REG_NOSUB | REG_ICASE | REG_EXTENDED); |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
788 } |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
789 return rc; // true iff bad pattern |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
790 } |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
791 |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
792 |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
793 bool CONTEXT::white_match(const char *from) |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
794 { |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
795 return (from && |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
796 white_regx && |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
797 (0 == regexec(&white_pattern, from, 0, NULL, 0))); |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
798 } |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
799 |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
800 |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
801 bool CONTEXT::set_generic(const char *regx, const char *msg) |
168 | 802 { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
803 int rc = 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
804 if (generic_regx) regfree(&generic_pattern); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
805 generic_regx = regx; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
806 generic_message = msg; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
807 if (generic_regx) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
808 rc = regcomp(&generic_pattern, regx, REG_NOSUB | REG_ICASE | REG_EXTENDED); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
809 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
810 return rc; // true iff bad pattern |
168 | 811 } |
812 | |
813 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
814 const char *CONTEXT::generic_match(const char *client) |
168 | 815 { |
195 | 816 if (!client) return NULL; // allow missing _ macro, which will disable generic checking |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
817 if (parent && !generic_regx) return parent->generic_match(client); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
818 if (!generic_regx) return NULL; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
819 if (0 == regexec(&generic_pattern, client, 0, NULL, 0)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
820 return generic_message; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
821 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
822 return NULL; |
168 | 823 } |
824 | |
825 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
826 bool CONTEXT::cover_env_to(const char *to) { |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
827 const char *x = strchr(to, '@'); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
828 if (x) x++; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
829 else x = to; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
830 if (*x == '\0') return true; // always allow covering addresses with no domain name, eg abuse@ |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
831 if (!parent && env_to.empty()) return true; // empty env_to at global level covers everything |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
832 string_set::iterator i = env_to.find(x); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
833 if (i != env_to.end()) return true; // we cover the entire domain |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
834 if (x != to) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
835 i = env_to.find(to); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
836 if (i != env_to.end()) return true; // we cover the specific email address |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
837 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
838 return false; |
94 | 839 } |
840 | |
841 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
842 VERIFYP CONTEXT::find_verify(const char *to) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
843 if (verifier && (verify_host != token_myhostname) && cover_env_to(to)) |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
844 return verifier; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
845 else if (parent) |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
846 return parent->find_verify(to); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
847 else |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
848 return NULL; |
153 | 849 } |
94 | 850 |
153 | 851 |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
852 WHITELISTERP CONTEXT::find_autowhite(const char *from, const char *to) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
853 if (whitelister && cover_env_to(to) && !cover_env_to(from)) |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
854 return whitelister; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
855 else if (parent) |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
856 return parent->find_autowhite(from, to); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
857 else |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
858 return NULL; |
94 | 859 } |
860 | |
861 | |
278
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
862 int CONTEXT::find_rate_limit(const char *user) { |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
863 if (rcpt_per_hour.empty()) return default_rate_limit; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
864 rates::iterator i = rcpt_per_hour.find(user); // look for authen id, or sender user@email limiting |
259
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
865 if (i != rcpt_per_hour.end()) return (*i).second; // found authen id, or user@email limiting |
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
866 const char *f = strchr(user, '@'); |
278
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
867 if (!f) return default_rate_limit; |
259
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
868 i = rcpt_per_hour.find(f); // look for @domain limiting |
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
869 if (i != rcpt_per_hour.end()) return (*i).second; // found @domain limiting |
278
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
870 return default_rate_limit; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
871 } |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
872 |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
873 |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
874 int CONTEXT::find_address_limit(const char *user) { |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
875 if (addresses_per_hour.empty()) return default_address_limit; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
876 rates::iterator i = addresses_per_hour.find(user); // look for authen id, or sender user@email limiting |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
877 if (i != addresses_per_hour.end()) return (*i).second; // found authen id, or user@email limiting |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
878 const char *f = strchr(user, '@'); |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
879 if (!f) return default_address_limit; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
880 i = addresses_per_hour.find(f); // look for @domain limiting |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
881 if (i != addresses_per_hour.end()) return (*i).second; // found @domain limiting |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
882 return default_address_limit; |
259
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
883 } |
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
884 |
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
885 |
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
886 bool CONTEXT::is_unauthenticated_limited(const char *user) { |
278
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
887 rates::iterator i = rcpt_per_hour.find(user); // look for sender user@email limiting |
259
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
888 if (i != rcpt_per_hour.end()) return true; // found user@email limiting |
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
889 const char *f = strchr(user, '@'); |
266
582cfb9c4031
fix unauthenticated rate limit bug for empty mail from
Carl Byington <carl@five-ten-sg.com>
parents:
263
diff
changeset
|
890 if (!f) return false; |
259
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
891 i = rcpt_per_hour.find(f); // look for sender @domain limiting |
be939802c64e
add recipient rate limits by email from address or domain
Carl Byington <carl@five-ten-sg.com>
parents:
255
diff
changeset
|
892 return (i != rcpt_per_hour.end()); // found @domain limiting |
136 | 893 } |
894 | |
895 | |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
896 const char *CONTEXT::find_from(const char *from, bool update_white, const char *queueid) { |
211
4db1457cd11a
Extend auto-whitelisting when receiving mail even if the auto whitelist is specified in a parent context.
Carl Byington <carl@five-ten-sg.com>
parents:
203
diff
changeset
|
897 WHITELISTERP w = whitelister; |
4db1457cd11a
Extend auto-whitelisting when receiving mail even if the auto whitelist is specified in a parent context.
Carl Byington <carl@five-ten-sg.com>
parents:
203
diff
changeset
|
898 CONTEXTP p = parent; |
4db1457cd11a
Extend auto-whitelisting when receiving mail even if the auto whitelist is specified in a parent context.
Carl Byington <carl@five-ten-sg.com>
parents:
203
diff
changeset
|
899 while (!w && p) { |
4db1457cd11a
Extend auto-whitelisting when receiving mail even if the auto whitelist is specified in a parent context.
Carl Byington <carl@five-ten-sg.com>
parents:
203
diff
changeset
|
900 w = p->whitelister; |
4db1457cd11a
Extend auto-whitelisting when receiving mail even if the auto whitelist is specified in a parent context.
Carl Byington <carl@five-ten-sg.com>
parents:
203
diff
changeset
|
901 p = p->parent; |
4db1457cd11a
Extend auto-whitelisting when receiving mail even if the auto whitelist is specified in a parent context.
Carl Byington <carl@five-ten-sg.com>
parents:
203
diff
changeset
|
902 } |
4db1457cd11a
Extend auto-whitelisting when receiving mail even if the auto whitelist is specified in a parent context.
Carl Byington <carl@five-ten-sg.com>
parents:
203
diff
changeset
|
903 if (w && w->is_white(from)) { |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
904 if (update_white && queueid) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
905 // update senders timestamp to extend the whitelisting period |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
906 if (debug_syslog > 1) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
907 char buf[maxlen]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
908 char msg[maxlen]; |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
909 snprintf(msg, sizeof(msg), "%s: extend whitelist reply from <%s> in context %s", queueid, from, get_full_name(buf,maxlen)); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
910 my_syslog(msg); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
911 } |
211
4db1457cd11a
Extend auto-whitelisting when receiving mail even if the auto whitelist is specified in a parent context.
Carl Byington <carl@five-ten-sg.com>
parents:
203
diff
changeset
|
912 w->sent(strdup(from)); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
913 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
914 return token_white; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
915 } |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
916 const char *rc = env_from_default; |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
917 string_map::iterator i = env_from.find(from); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
918 if (i != env_from.end()) rc = (*i).second; // found user@domain key |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
919 else { |
244
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
920 const char *x = strchr(from, '@'); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
921 if (x) { |
244
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
922 char buf[200]; |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
923 x++; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
924 i = env_from.find(x); |
244
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
925 size_t n = x - from; // length of user name plus @ |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
926 if (i != env_from.end()) rc = (*i).second; // found domain key |
244
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
927 else if (n < sizeof(buf)) { |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
928 // we only test reasonably short user names, since we need |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
929 // to copy them to a buffer to avoid a dup/free cycle on every |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
930 // test here. |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
931 strncpy(buf, from, n); |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
932 buf[n] = '\0'; |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
933 i = env_from.find(buf); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
934 if (i != env_from.end()) rc = (*i).second; // found user@ key |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
935 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
936 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
937 } |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
938 if ((rc == token_inherit) || (rc == token_unknown)) { |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
939 bool ok = white_match(from); |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
940 if (ok) rc = token_white; |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
941 } |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
942 if ((rc == token_inherit) && parent) return parent->find_from(from); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
943 return (rc == token_inherit) ? token_unknown : rc; |
94 | 944 } |
945 | |
946 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
947 CONTEXTP CONTEXT::find_context(const char *from) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
948 context_map::iterator i = env_from_context.find(from); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
949 if (i != env_from_context.end()) return (*i).second; // found user@domain key |
244
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
950 const char *x = strchr(from, '@'); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
951 if (x) { |
244
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
952 char buf[200]; |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
953 x++; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
954 i = env_from_context.find(x); |
244
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
955 size_t n = x - from; // length of user name plus @ |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
956 if (i != env_from_context.end()) return (*i).second; // found domain key |
244
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
957 else if (n < sizeof(buf)) { |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
958 // we only test reasonably short user names, since we need |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
959 // to copy them to a buffer to avoid a dup/free cycle on every |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
960 // test here. |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
961 strncpy(buf, from, n); |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
962 buf[n] = '\0'; |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
963 i = env_from_context.find(buf); |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
964 if (i != env_from_context.end()) return (*i).second; // found user@ key |
ef97c7cd4a6e
const correctness fixes from new gcc, libresolv.a moved to glibc-static on newer distributions
Carl Byington <carl@five-ten-sg.com>
parents:
233
diff
changeset
|
965 } |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
966 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
967 return this; |
94 | 968 } |
969 | |
970 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
971 CONTEXTP CONTEXT::find_from_context_name(const char *name) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
972 context_map::iterator i = children.find(name); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
973 if (i != children.end()) return (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
974 return NULL; |
94 | 975 } |
976 | |
977 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
978 DNSBLP CONTEXT::find_dnsbl(const char *name) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
979 dnsblp_map::iterator i = dnsbl_names.find(name); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
980 if (i != dnsbl_names.end()) return (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
981 if (parent) return parent->find_dnsbl(name); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
982 return NULL; |
94 | 983 } |
984 | |
985 | |
249 | 986 DNSWLP CONTEXT::find_dnswl(const char *name) { |
987 dnswlp_map::iterator i = dnswl_names.find(name); | |
988 if (i != dnswl_names.end()) return (*i).second; | |
989 if (parent) return parent->find_dnswl(name); | |
990 return NULL; | |
991 } | |
992 | |
993 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
994 const char* CONTEXT::get_content_suffix() { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
995 if (!content_suffix && parent) return parent->get_content_suffix(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
996 return content_suffix; |
94 | 997 } |
998 | |
999 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1000 const char* CONTEXT::get_uribl_suffix() { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1001 if (!uribl_suffix && parent) return parent->get_uribl_suffix(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1002 return uribl_suffix; |
119 | 1003 } |
1004 | |
1005 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1006 const char* CONTEXT::get_content_message() { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1007 if (!content_message && parent) return parent->get_content_message(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1008 return content_message; |
94 | 1009 } |
1010 | |
1011 | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1012 const char* CONTEXT::get_uribl_message() { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1013 if (!uribl_message && parent) return parent->get_uribl_message(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1014 return uribl_message; |
119 | 1015 } |
1016 | |
1017 | |
94 | 1018 string_set& CONTEXT::get_content_host_ignore() { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1019 if (content_host_ignore.empty() && parent) return parent->get_content_host_ignore(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1020 return content_host_ignore; |
94 | 1021 } |
1022 | |
1023 | |
1024 string_set& CONTEXT::get_content_tlds() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1025 if (content_tlds.empty() && parent) return parent->get_content_tlds(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1026 return content_tlds; |
94 | 1027 } |
1028 | |
1029 | |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1030 string_set& CONTEXT::get_content_tldwilds() { |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1031 if (content_tldwilds.empty() && parent) return parent->get_content_tldwilds(); |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1032 return content_tldwilds; |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1033 } |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1034 |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1035 |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1036 string_set& CONTEXT::get_content_tldnots() { |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1037 if (content_tldnots.empty() && parent) return parent->get_content_tldnots(); |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1038 return content_tldnots; |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1039 } |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1040 |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1041 |
94 | 1042 string_set& CONTEXT::get_html_tags() { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1043 if (html_tags.empty() && parent) return parent->get_html_tags(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1044 return html_tags; |
94 | 1045 } |
1046 | |
1047 | |
1048 dnsblp_list& CONTEXT::get_dnsbl_list() { | |
255
d6d5c50b9278
Allow dnswl_list and dnsbl_list to be empty, to override lists specified in the ancestor contexts. Add daily recipient limits as a multiple of the hourly limits.
Carl Byington <carl@five-ten-sg.com>
parents:
249
diff
changeset
|
1049 if (!dnsbl_list_parsed && parent) return parent->get_dnsbl_list(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1050 return dnsbl_list; |
94 | 1051 } |
1052 | |
1053 | |
249 | 1054 dnswlp_list& CONTEXT::get_dnswl_list() { |
255
d6d5c50b9278
Allow dnswl_list and dnsbl_list to be empty, to override lists specified in the ancestor contexts. Add daily recipient limits as a multiple of the hourly limits.
Carl Byington <carl@five-ten-sg.com>
parents:
249
diff
changeset
|
1055 if (!dnswl_list_parsed && parent) return parent->get_dnswl_list(); |
249 | 1056 return dnswl_list; |
1057 } | |
1058 | |
1059 | |
178 | 1060 bool CONTEXT::acceptable_content(recorder &memory, int score, int bulk, string& msg) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1061 if (spamassassin_limit && (score > spamassassin_limit)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1062 char buf[maxlen]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1063 snprintf(buf, sizeof(buf), "Mail rejected - spam assassin score %d", score); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1064 msg = string(buf); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1065 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1066 } |
203
92a5c866bdfa
Verify from/to pairs even if they might be explicitly whitelisted.
Carl Byington <carl@five-ten-sg.com>
parents:
195
diff
changeset
|
1067 if (dcc_bulk_threshold && (bulk >= dcc_bulk_threshold)) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1068 char buf[maxlen]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1069 snprintf(buf, sizeof(buf), "Mail rejected - dcc score %d", bulk); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1070 msg = string(buf); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1071 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1072 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1073 if (memory.excessive_bad_tags(tag_limit)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1074 msg = string(tag_limit_message); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1075 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1076 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1077 if (!host_random && memory.excessive_hosts(host_limit)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1078 msg = string(host_limit_message); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1079 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1080 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1081 return true; |
94 | 1082 } |
1083 | |
1084 | |
167
9b129ed78d7d
actually use spamassassin result, allow build without spam assassin, only call it if some recipient needs it.
carl
parents:
164
diff
changeset
|
1085 void CONTEXT::dump(bool isdefault, bool &spamass, int level) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1086 char indent[maxlen]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1087 int i = min(maxlen-1, level*4); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1088 memset(indent, ' ', i); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1089 indent[i] = '\0'; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1090 char buf[maxlen]; |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1091 const char *fullname = get_full_name(buf,maxlen); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1092 printf("%s context %s { \t// %s\n", indent, name, fullname); |
94 | 1093 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1094 for (dnsblp_map::iterator i=dnsbl_names.begin(); i!=dnsbl_names.end(); i++) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1095 const char *n = (*i).first; |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1096 DNSBL &d = *(*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1097 printf("%s dnsbl %s %s \"%s\"; \n", indent, n, d.suffix, d.message); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1098 } |
94 | 1099 |
249 | 1100 for (dnswlp_map::iterator i=dnswl_names.begin(); i!=dnswl_names.end(); i++) { |
1101 const char *n = (*i).first; | |
1102 DNSWL &d = *(*i).second; | |
1103 printf("%s dnswl %s %s %d; \n", indent, n, d.suffix, d.level); | |
1104 } | |
1105 | |
1106 { | |
255
d6d5c50b9278
Allow dnswl_list and dnsbl_list to be empty, to override lists specified in the ancestor contexts. Add daily recipient limits as a multiple of the hourly limits.
Carl Byington <carl@five-ten-sg.com>
parents:
249
diff
changeset
|
1107 dnsblp_list dl = get_dnsbl_list(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1108 printf("%s dnsbl_list", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1109 for (dnsblp_list::iterator i=dl.begin(); i!=dl.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1110 DNSBL &d = *(*i); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1111 printf(" %s", d.name); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1112 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1113 printf("; \n"); |
268
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1114 printf("%s require_rdns %s; \n", indent, (require_rdns) ? "yes" : "no"); |
255
d6d5c50b9278
Allow dnswl_list and dnsbl_list to be empty, to override lists specified in the ancestor contexts. Add daily recipient limits as a multiple of the hourly limits.
Carl Byington <carl@five-ten-sg.com>
parents:
249
diff
changeset
|
1115 } |
249 | 1116 |
1117 { | |
255
d6d5c50b9278
Allow dnswl_list and dnsbl_list to be empty, to override lists specified in the ancestor contexts. Add daily recipient limits as a multiple of the hourly limits.
Carl Byington <carl@five-ten-sg.com>
parents:
249
diff
changeset
|
1118 dnswlp_list dl = get_dnswl_list(); |
249 | 1119 printf("%s dnswl_list", indent); |
1120 for (dnswlp_list::iterator i=dl.begin(); i!=dl.end(); i++) { | |
1121 DNSWL &d = *(*i); | |
1122 printf(" %s", d.name); | |
1123 } | |
1124 printf("; \n"); | |
255
d6d5c50b9278
Allow dnswl_list and dnsbl_list to be empty, to override lists specified in the ancestor contexts. Add daily recipient limits as a multiple of the hourly limits.
Carl Byington <carl@five-ten-sg.com>
parents:
249
diff
changeset
|
1125 } |
94 | 1126 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1127 if (content_filtering) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1128 printf("%s content on { \n", indent); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1129 if (content_suffix) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1130 printf("%s filter %s \"%s\"; \n", indent, content_suffix, content_message); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1131 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1132 if (uribl_suffix) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1133 printf("%s uribl %s \"%s\"; \n", indent, uribl_suffix, uribl_message); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1134 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1135 if (!content_host_ignore.empty()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1136 printf("%s ignore { \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1137 for (string_set::iterator i=content_host_ignore.begin(); i!=content_host_ignore.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1138 printf("%s %s; \n", indent, *i); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1139 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1140 printf("%s }; \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1141 } |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1142 if (!content_tlds.empty() || !content_tldwilds.empty() || !content_tldnots.empty()) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1143 printf("%s tld { \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1144 printf("%s ", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1145 for (string_set::iterator i=content_tlds.begin(); i!=content_tlds.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1146 printf("%s; ", *i); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1147 } |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1148 for (string_set::iterator i=content_tldwilds.begin(); i!=content_tldwilds.end(); i++) { |
274
bdcf203e3f7b
fix -c printing config
Carl Byington <carl@five-ten-sg.com>
parents:
272
diff
changeset
|
1149 printf("*.%s; ", *i); |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1150 } |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1151 for (string_set::iterator i=content_tldnots.begin(); i!=content_tldnots.end(); i++) { |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1152 printf("!%s; ", *i); |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1153 } |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1154 printf("\n%s }; \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1155 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1156 if (!html_tags.empty()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1157 printf("%s html_tags { \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1158 printf("%s ", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1159 for (string_set::iterator i=html_tags.begin(); i!=html_tags.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1160 printf("%s; ", *i); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1161 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1162 printf("\n%s }; \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1163 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1164 if (host_limit_message) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1165 printf("%s host_limit on %d \"%s\"; \n", indent, host_limit, host_limit_message); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1166 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1167 else if (host_random) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1168 printf("%s host_limit soft %d; \n", indent, host_limit); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1169 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1170 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1171 printf("%s host_limit off; \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1172 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1173 if (tag_limit_message) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1174 printf("%s html_limit on %d \"%s\"; \n", indent, tag_limit, tag_limit_message); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1175 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1176 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1177 printf("%s html_limit off; \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1178 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1179 printf("%s spamassassin %d; \n", indent, spamassassin_limit); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1180 printf("%s require_match %s; \n", indent, (require_match) ? "yes" : "no"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1181 printf("%s dcc_greylist %s; \n", indent, (dcc_greylist) ? "yes" : "no"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1182 if (dcc_bulk_threshold == 0) printf("%s dcc_bulk_threshold off; \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1183 else if (dcc_bulk_threshold >= dccbulk) printf("%s dcc_bulk_threshold many; \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1184 else printf("%s dcc_bulk_threshold %d; \n", indent, dcc_bulk_threshold); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1185 printf("%s }; \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1186 spamass |= (spamassassin_limit != 0); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1187 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1188 else { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1189 printf("%s content off {}; \n", indent); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1190 } |
94 | 1191 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1192 printf("%s env_to { \t// %s\n", indent, fullname); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1193 for (string_set::iterator i=env_to.begin(); i!=env_to.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1194 printf("%s %s; \n", indent, *i); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1195 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1196 printf("%s }; \n", indent); |
94 | 1197 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1198 if (verify_host) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1199 printf("%s verify %s; \n", indent, verify_host); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1200 } |
94 | 1201 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1202 if (generic_regx) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1203 printf("%s generic \"%s\" \n", indent, generic_regx); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1204 printf("%s \"%s\"; \n", indent, generic_message); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1205 } |
168 | 1206 |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1207 if (white_regx) { |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1208 printf("%s white_regex \"%s\"; \n", indent, white_regx); |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1209 } |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1210 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1211 if (autowhite_file && whitelister) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1212 printf("%s autowhite %d %s; \n", indent, whitelister->get_days(), autowhite_file); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1213 } |
153 | 1214 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1215 for (context_map::iterator i=children.begin(); i!=children.end(); i++) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1216 CONTEXTP c = (*i).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1217 c->dump(false, spamass, level+1); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1218 } |
94 | 1219 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1220 printf("%s env_from %s { \t// %s\n", indent, env_from_default, fullname); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1221 if (!env_from.empty()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1222 printf("%s // white/black/unknown \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1223 for (string_map::iterator i=env_from.begin(); i!=env_from.end(); i++) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1224 const char *f = (*i).first; |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1225 const char *t = (*i).second; |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1226 printf("%s %s \t%s; \n", indent, f, t); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1227 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1228 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1229 if (!env_from_context.empty()) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1230 printf("%s // child contexts \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1231 for (context_map::iterator j=env_from_context.begin(); j!=env_from_context.end(); j++) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1232 const char *f = (*j).first; |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1233 CONTEXTP t = (*j).second; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1234 printf("%s %s \t%s; \n", indent, f, t->name); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1235 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1236 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1237 printf("%s }; \n", indent); |
94 | 1238 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1239 if (isdefault) { |
278
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1240 printf("%s rate_limit %d %d %d %d { \n", indent, default_rate_limit, daily_rate_multiple, default_address_limit, daily_address_multiple); |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1241 for (rates::iterator j=rcpt_per_hour.begin(); j!=rcpt_per_hour.end(); j++) { |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1242 const char *u = (*j).first; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1243 int l = (*j).second; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1244 rates::iterator k = addresses_per_hour.find(u); |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1245 int a = (k==addresses_per_hour.end()) ? default_address_limit : (*k).second; |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1246 printf("%s \"%s\" \t%d %d; \n", indent, u, l, a); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1247 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1248 printf("%s }; \n", indent); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1249 } |
136 | 1250 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1251 printf("%s }; \n", indent); |
94 | 1252 } |
1253 | |
1254 | |
1255 //////////////////////////////////////////////// | |
1256 // helper to discard the strings held by a string_set | |
1257 // | |
1258 void discard(string_set &s) { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1259 for (string_set::iterator i=s.begin(); i!=s.end(); i++) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1260 free((void*)*i); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1261 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1262 s.clear(); |
94 | 1263 } |
1264 | |
1265 | |
1266 //////////////////////////////////////////////// | |
1267 // helper to register a string in a string set | |
1268 // | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1269 const char* register_string(string_set &s, const char *name) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1270 string_set::iterator i = s.find(name); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1271 if (i != s.end()) return *i; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1272 char *x = strdup(name); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1273 s.insert(x); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1274 return x; |
94 | 1275 } |
1276 | |
1277 | |
1278 //////////////////////////////////////////////// | |
1279 // register a global string | |
1280 // | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1281 const char* register_string(const char *name) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1282 return register_string(all_strings, name); |
94 | 1283 } |
1284 | |
1285 | |
1286 //////////////////////////////////////////////// | |
164 | 1287 // clear all global strings, helper for valgrind checking |
1288 // | |
1289 void clear_strings() { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1290 discard(all_strings); |
164 | 1291 } |
1292 | |
1293 | |
1294 //////////////////////////////////////////////// | |
94 | 1295 // |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1296 bool tsa(TOKEN &tok, const char *token); |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1297 bool tsa(TOKEN &tok, const char *token) { |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1298 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1299 if (have == token) return true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1300 tok.token_error(token, have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1301 return false; |
94 | 1302 } |
1303 | |
1304 | |
1305 //////////////////////////////////////////////// | |
1306 // | |
1307 bool parse_dnsbl(TOKEN &tok, CONFIG &dc, CONTEXT &me); | |
1308 bool parse_dnsbl(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1309 const char *name = tok.next(); |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1310 const char *suf = tok.next(); |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1311 const char *msg = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1312 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1313 DNSBLP dnsnew = new DNSBL(name, suf, msg); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1314 DNSBLP dnsold = me.find_dnsbl(name); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1315 if (dnsold && (*dnsold == *dnsnew)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1316 // duplicate redefinition, ignore it |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1317 delete dnsnew; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1318 return true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1319 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1320 me.add_dnsbl(name, dnsnew); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1321 return true; |
94 | 1322 } |
1323 | |
1324 | |
1325 //////////////////////////////////////////////// | |
1326 // | |
249 | 1327 bool parse_dnswl(TOKEN &tok, CONFIG &dc, CONTEXT &me); |
1328 bool parse_dnswl(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
1329 const char *name = tok.next(); | |
1330 const char *suf = tok.next(); | |
1331 const int lev = tok.nextint(); | |
1332 if (!tsa(tok, token_semi)) return false; | |
1333 DNSWLP dnsnew = new DNSWL(name, suf, lev); | |
1334 DNSWLP dnsold = me.find_dnswl(name); | |
1335 if (dnsold && (*dnsold == *dnsnew)) { | |
1336 // duplicate redefinition, ignore it | |
1337 delete dnsnew; | |
1338 return true; | |
1339 } | |
1340 me.add_dnswl(name, dnsnew); | |
1341 return true; | |
1342 } | |
1343 | |
1344 | |
1345 //////////////////////////////////////////////// | |
1346 // | |
94 | 1347 bool parse_dnsbll(TOKEN &tok, CONFIG &dc, CONTEXT &me); |
1348 bool parse_dnsbll(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1349 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1350 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1351 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1352 if (have == token_semi) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1353 DNSBLP dns = me.find_dnsbl(have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1354 if (dns) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1355 me.add_dnsbl(dns); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1356 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1357 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1358 tok.token_error("dnsbl name", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1359 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1360 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1361 } |
255
d6d5c50b9278
Allow dnswl_list and dnsbl_list to be empty, to override lists specified in the ancestor contexts. Add daily recipient limits as a multiple of the hourly limits.
Carl Byington <carl@five-ten-sg.com>
parents:
249
diff
changeset
|
1362 me.set_dnsbll_parsed(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1363 return true; |
94 | 1364 } |
1365 | |
1366 | |
1367 //////////////////////////////////////////////// | |
1368 // | |
249 | 1369 bool parse_dnswll(TOKEN &tok, CONFIG &dc, CONTEXT &me); |
1370 bool parse_dnswll(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
1371 while (true) { | |
1372 const char *have = tok.next(); | |
1373 if (!have) break; | |
1374 if (have == token_semi) break; | |
1375 DNSWLP dns = me.find_dnswl(have); | |
1376 if (dns) { | |
1377 me.add_dnswl(dns); | |
1378 } | |
1379 else { | |
1380 tok.token_error("dnswl name", have); | |
1381 return false; | |
1382 } | |
1383 } | |
255
d6d5c50b9278
Allow dnswl_list and dnsbl_list to be empty, to override lists specified in the ancestor contexts. Add daily recipient limits as a multiple of the hourly limits.
Carl Byington <carl@five-ten-sg.com>
parents:
249
diff
changeset
|
1384 me.set_dnswll_parsed(); |
249 | 1385 return true; |
1386 } | |
1387 | |
1388 | |
1389 //////////////////////////////////////////////// | |
1390 // | |
268
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1391 bool parse_requirerdns(TOKEN &tok, CONFIG &dc, CONTEXT &me); |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1392 bool parse_requirerdns(TOKEN &tok, CONFIG &dc, CONTEXT &me) { |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1393 const char *have = tok.next(); |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1394 if (have == token_yes) me.set_requirerdns(true); |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1395 else if (have == token_no) me.set_requirerdns(false); |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1396 else { |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1397 tok.token_error("yes/no", have); |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1398 return false; |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1399 } |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1400 if (!tsa(tok, token_semi)) return false; |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1401 return true; |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1402 } |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1403 |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1404 |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1405 //////////////////////////////////////////////// |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1406 // |
94 | 1407 bool parse_content(TOKEN &tok, CONFIG &dc, CONTEXT &me); |
1408 bool parse_content(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1409 const char *setting = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1410 if (setting == token_on) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1411 me.set_content_filtering(true); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1412 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1413 else if (setting == token_off) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1414 me.set_content_filtering(false); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1415 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1416 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1417 tok.token_error("on/off", setting); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1418 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1419 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1420 if (!tsa(tok, token_lbrace)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1421 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1422 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1423 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1424 if (have == token_filter) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1425 const char *suffix = tok.next(); |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1426 const char *messag = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1427 me.set_content_suffix(suffix); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1428 me.set_content_message(messag); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1429 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1430 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1431 else if (have == token_uribl) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1432 const char *suffix = tok.next(); |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1433 const char *messag = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1434 me.set_uribl_suffix(suffix); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1435 me.set_uribl_message(messag); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1436 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1437 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1438 else if (have == token_ignore) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1439 if (!tsa(tok, token_lbrace)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1440 while (true) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1441 if (!have) break; |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1442 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1443 if (have == token_rbrace) break; // done |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1444 me.add_ignore(have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1445 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1446 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1447 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1448 else if (have == token_tld) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1449 if (!tsa(tok, token_lbrace)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1450 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1451 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1452 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1453 if (have == token_rbrace) break; // done |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1454 if (have == token_bang) { |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1455 have = tok.next(); |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1456 if (!have) break; |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1457 if (have == token_rbrace) break; // done |
272
a99b6c1f5f67
Code cleanup, increase minimum hostname length for uribl checking
Carl Byington <carl@five-ten-sg.com>
parents:
270
diff
changeset
|
1458 me.add_tldnot(have); |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1459 } |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1460 else if (have == token_asterisk) { |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1461 have = tok.next(); |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1462 if (!have) break; |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1463 if (have == token_rbrace) break; // done |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1464 if (have == token_period) { |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1465 have = tok.next(); |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1466 if (!have) break; |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1467 if (have == token_rbrace) break; // done |
272
a99b6c1f5f67
Code cleanup, increase minimum hostname length for uribl checking
Carl Byington <carl@five-ten-sg.com>
parents:
270
diff
changeset
|
1468 me.add_tldwild(have); |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1469 } |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1470 } |
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1471 else me.add_tld(have); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1472 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1473 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1474 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1475 else if (have == token_html_tags) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1476 if (!tsa(tok, token_lbrace)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1477 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1478 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1479 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1480 if (have == token_rbrace) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1481 break; // done |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1482 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1483 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1484 me.add_tag(have); // base version |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1485 char buf[200]; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1486 snprintf(buf, sizeof(buf), "/%s", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1487 me.add_tag(register_string(buf)); // leading / |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1488 snprintf(buf, sizeof(buf), "%s/", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1489 me.add_tag(register_string(buf)); // trailing / |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1490 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1491 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1492 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1493 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1494 else if (have == token_html_limit) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1495 have = tok.next(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1496 if (have == token_on) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1497 me.set_tag_limit(tok.nextint()); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1498 me.set_tag_message(tok.next()); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1499 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1500 else if (have == token_off) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1501 me.set_tag_limit(0); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1502 me.set_tag_message(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1503 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1504 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1505 tok.token_error("on/off", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1506 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1507 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1508 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1509 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1510 else if (have == token_host_limit) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1511 have = tok.next(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1512 if (have == token_on) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1513 me.set_host_limit(tok.nextint()); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1514 me.set_host_message(tok.next()); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1515 me.set_host_random(false); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1516 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1517 else if (have == token_off) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1518 me.set_host_limit(0); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1519 me.set_host_message(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1520 me.set_host_random(false); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1521 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1522 else if (have == token_soft) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1523 me.set_host_limit(tok.nextint()); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1524 me.set_host_message(NULL); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1525 me.set_host_random(true); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1526 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1527 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1528 tok.token_error("on/off/soft", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1529 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1530 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1531 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1532 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1533 else if (have == token_spamassassin) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1534 me.set_spamassassin_limit(tok.nextint()); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1535 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1536 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1537 else if (have == token_require) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1538 have = tok.next(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1539 if (have == token_yes) me.set_require(true); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1540 else if (have == token_no) me.set_require(false); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1541 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1542 tok.token_error("yes/no", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1543 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1544 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1545 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1546 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1547 else if (have == token_dccgrey) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1548 have = tok.next(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1549 if (have == token_yes) me.set_grey(true); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1550 else if (have == token_no) me.set_grey(false); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1551 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1552 tok.token_error("yes/no", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1553 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1554 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1555 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1556 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1557 else if (have == token_dccbulk) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1558 have = tok.next(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1559 if (have == token_off) me.set_bulk(0); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1560 else if (have == token_many) me.set_bulk(dccbulk); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1561 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1562 char *e; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1563 long i = strtol(have, &e, 10); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1564 if (*e != '\0') { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1565 tok.token_error("integer", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1566 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1567 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1568 me.set_bulk((int)i); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1569 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1570 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1571 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1572 else if (have == token_rbrace) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1573 break; // done |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1574 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1575 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1576 tok.token_error("content keyword", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1577 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1578 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1579 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1580 return tsa(tok, token_semi); |
94 | 1581 } |
1582 | |
1583 | |
1584 //////////////////////////////////////////////// | |
1585 // | |
1586 bool parse_envto(TOKEN &tok, CONFIG &dc, CONTEXT &me); | |
1587 bool parse_envto(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1588 if (!tsa(tok, token_lbrace)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1589 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1590 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1591 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1592 if (have == token_rbrace) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1593 if (have == token_semi) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1594 // optional separators |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1595 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1596 else if (have == token_dccto) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1597 const char *flavor = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1598 if (!tsa(tok, token_lbrace)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1599 bool keeping = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1600 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1601 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1602 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1603 if (have == token_rbrace) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1604 if (have == flavor) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1605 keeping = true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1606 continue; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1607 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1608 else if ((have == token_ok) || (have == token_ok2) || (have == token_many)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1609 keeping = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1610 continue; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1611 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1612 if (have == token_envto) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1613 have = tok.next(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1614 if (keeping) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1615 if (me.allow_env_to(have)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1616 me.add_to(have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1617 dc.add_to(have, &me); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1618 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1619 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1620 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1621 //else if (have == token_substitute) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1622 // if (tok.next() == token_mailhost) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1623 // have = tok.next(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1624 // if (keeping) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1625 // if (me.allow_env_to(have)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1626 // me.add_to(have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1627 // dc.add_to(have, &me); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1628 // } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1629 // } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1630 // } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1631 //} |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1632 tok.skipeol(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1633 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1634 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1635 else if (me.allow_env_to(have)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1636 me.add_to(have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1637 dc.add_to(have, &me); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1638 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1639 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1640 tok.token_error("user@ or user@domain.tld or domain.tld where domain.tld allowed by parent context", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1641 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1642 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1643 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1644 return tsa(tok, token_semi); |
94 | 1645 } |
1646 | |
1647 | |
1648 //////////////////////////////////////////////// | |
1649 // | |
1650 bool parse_verify(TOKEN &tok, CONFIG &dc, CONTEXT &me); | |
1651 bool parse_verify(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1652 const char *host = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1653 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1654 me.set_verify(host); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1655 me.set_verifier(add_verify_host(host)); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1656 return true; |
153 | 1657 } |
1658 | |
1659 | |
1660 //////////////////////////////////////////////// | |
1661 // | |
168 | 1662 bool parse_generic(TOKEN &tok, CONFIG &dc, CONTEXT &me); |
1663 bool parse_generic(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1664 const char *regx = tok.next(); |
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1665 const char *msg = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1666 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1667 if (me.set_generic(regx, msg)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1668 tok.token_error("invalid regular expression %s", regx, regx); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1669 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1670 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1671 return true; |
168 | 1672 } |
1673 | |
1674 | |
1675 //////////////////////////////////////////////// | |
1676 // | |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1677 bool parse_white(TOKEN &tok, CONFIG &dc, CONTEXT &me); |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1678 bool parse_white(TOKEN &tok, CONFIG &dc, CONTEXT &me) { |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1679 const char *regx = tok.next(); |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1680 if (!tsa(tok, token_semi)) return false; |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1681 if (me.set_white(regx)) { |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1682 tok.token_error("invalid regular expression %s", regx, regx); |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1683 return false; |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1684 } |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1685 return true; |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1686 } |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1687 |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1688 |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1689 //////////////////////////////////////////////// |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1690 // |
153 | 1691 bool parse_autowhite(TOKEN &tok, CONFIG &dc, CONTEXT &me); |
1692 bool parse_autowhite(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1693 int days = tok.nextint(); |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1694 const char *fn = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1695 if (!tsa(tok, token_semi)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1696 me.set_autowhite(fn); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1697 me.set_whitelister(add_whitelister_file(fn, days)); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1698 return true; |
94 | 1699 } |
1700 | |
1701 | |
1702 //////////////////////////////////////////////// | |
1703 // | |
1704 bool parse_envfrom(TOKEN &tok, CONFIG &dc, CONTEXT &me); | |
1705 bool parse_envfrom(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1706 const char *st = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1707 if ((st == token_black) || (st == token_white) || (st == token_unknown) || (st == token_inherit)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1708 me.set_from_default(st); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1709 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1710 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1711 tok.push(st); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1712 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1713 if (!tsa(tok, token_lbrace)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1714 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1715 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1716 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1717 if (have == token_rbrace) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1718 if (have == token_semi) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1719 // optional separators |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1720 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1721 else if (have == token_dccfrom) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1722 if (!tsa(tok, token_lbrace)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1723 bool keeping = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1724 bool many = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1725 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1726 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1727 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1728 if (have == token_rbrace) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1729 if (have == token_ok) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1730 keeping = true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1731 many = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1732 continue; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1733 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1734 else if (have == token_many) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1735 keeping = true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1736 many = true; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1737 continue; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1738 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1739 else if (have == token_ok2) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1740 keeping = false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1741 continue; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1742 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1743 if (have == token_envfrom) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1744 have = tok.next(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1745 if (keeping) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1746 me.add_from(have, (many) ? token_black : token_white); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1747 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1748 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1749 else if (have == token_substitute) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1750 if (tok.next() == token_mailhost) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1751 have = tok.next(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1752 me.add_from(have, (many) ? token_black : token_white); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1753 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1754 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1755 tok.skipeol(); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1756 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1757 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1758 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1759 // may be a valid email address or domain name |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1760 const char *st = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1761 if ((st == token_white) || (st == token_black) || (st == token_unknown) || (st == token_inherit)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1762 me.add_from(have, st); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1763 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1764 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1765 CONTEXTP con = me.find_from_context_name(st); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1766 if (con) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1767 me.add_from_context(have, con); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1768 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1769 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1770 tok.token_error("white/black/unknown/inherit or child context name", st); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1771 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1772 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1773 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1774 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1775 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1776 return tsa(tok, token_semi); |
94 | 1777 } |
1778 | |
1779 | |
1780 //////////////////////////////////////////////// | |
1781 // | |
136 | 1782 bool parse_rate(TOKEN &tok, CONFIG &dc, CONTEXT &me); |
1783 bool parse_rate(TOKEN &tok, CONFIG &dc, CONTEXT &me) { | |
278
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1784 me.set_default_rate_limit(tok.nextint()); |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1785 me.set_daily_rate_multiple(tok.nextint()); |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1786 me.set_default_address_limit(tok.nextint()); |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1787 me.set_daily_address_multiple(tok.nextint()); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1788 if (!tsa(tok, token_lbrace)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1789 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1790 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1791 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1792 if (have == token_rbrace) break; |
278
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1793 me.add_rate_limit(have, tok.nextint()); |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1794 me.add_address_limit(have, tok.nextint()); |
368572c57013
add limits on unique ip addresses per hour per authenticated user
Carl Byington <carl@five-ten-sg.com>
parents:
274
diff
changeset
|
1795 if (!tsa(tok, token_semi)) return false; |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1796 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1797 return tsa(tok, token_semi); |
136 | 1798 } |
1799 | |
1800 | |
1801 //////////////////////////////////////////////// | |
1802 // | |
94 | 1803 bool parse_context(TOKEN &tok, CONFIG &dc, CONTEXTP parent); |
1804 bool parse_context(TOKEN &tok, CONFIG &dc, CONTEXTP parent) { | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1805 const char *name = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1806 if (!tsa(tok, token_lbrace)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1807 CONTEXTP con = new CONTEXT(parent, name); |
94 | 1808 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1809 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1810 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1811 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1812 if (have == token_rbrace) break; // done |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1813 if (have == token_dnsbl) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1814 if (!parse_dnsbl(tok, dc, *con)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1815 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1816 else if (have == token_dnsbll) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1817 if (!parse_dnsbll(tok, dc, *con)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1818 } |
249 | 1819 else if (have == token_dnswl) { |
1820 if (!parse_dnswl(tok, dc, *con)) return false; | |
1821 } | |
1822 else if (have == token_dnswll) { | |
1823 if (!parse_dnswll(tok, dc, *con)) return false; | |
1824 } | |
268
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1825 else if (have == token_requirerdns) { |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1826 if (!parse_requirerdns(tok, dc, *con)) return false; |
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1827 } |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1828 else if (have == token_content) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1829 if (!parse_content(tok, dc, *con)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1830 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1831 else if (have == token_envto) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1832 if (!parse_envto(tok, dc, *con)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1833 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1834 else if (have == token_verify) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1835 if (!parse_verify(tok, dc, *con)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1836 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1837 else if (have == token_generic) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1838 if (!parse_generic(tok, dc, *con)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1839 } |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1840 else if (have == token_white_regex) { |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1841 if (!parse_white(tok, dc, *con)) return false; |
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1842 } |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1843 else if (have == token_autowhite) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1844 if (!parse_autowhite(tok, dc, *con)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1845 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1846 else if (have == token_envfrom) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1847 if (!parse_envfrom(tok, dc, *con)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1848 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1849 else if (have == token_rate) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1850 if (parent || dc.default_context) tok.token_error("rate limit ignored in non default context"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1851 if (!parse_rate(tok, dc, *con)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1852 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1853 else if (have == token_context) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1854 if (!parse_context(tok, dc, con)) return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1855 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1856 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1857 tok.token_error("context keyword", have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1858 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1859 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1860 } |
94 | 1861 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1862 if (!tsa(tok, token_semi)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1863 delete con; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1864 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1865 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1866 dc.add_context(con); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1867 if (parent) parent->add_context(con); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1868 return true; |
94 | 1869 } |
1870 | |
1871 | |
1872 //////////////////////////////////////////////// | |
1873 // parse a config file | |
1874 // | |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1875 bool load_conf(CONFIG &dc, const char *fn) { |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1876 int count = 0; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1877 TOKEN tok(fn, &dc.config_files); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1878 while (true) { |
214
82886d4dd71f
Fixes to compile on Fedora 9 and for const correctness.
Carl Byington <carl@five-ten-sg.com>
parents:
211
diff
changeset
|
1879 const char *have = tok.next(); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1880 if (!have) break; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1881 if (have == token_context) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1882 if (!parse_context(tok, dc, NULL)) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1883 tok.token_error("load_conf() failed to parse context"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1884 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1885 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1886 else count++; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1887 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1888 else { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1889 tok.token_error(token_context, have); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1890 return false; |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1891 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1892 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1893 tok.token_error("load_conf() found %d contexts in %s", count, fn); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1894 return (dc.default_context) ? true : false; |
94 | 1895 } |
1896 | |
1897 | |
1898 //////////////////////////////////////////////// | |
1899 // init the tokens | |
1900 // | |
1901 void token_init() { | |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1902 token_asterisk = register_string("*"); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1903 token_autowhite = register_string("autowhite"); |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1904 token_bang = register_string("!"); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1905 token_black = register_string("black"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1906 token_content = register_string("content"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1907 token_context = register_string("context"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1908 token_dccbulk = register_string("dcc_bulk_threshold"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1909 token_dccfrom = register_string("dcc_from"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1910 token_dccgrey = register_string("dcc_greylist"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1911 token_dccto = register_string("dcc_to"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1912 token_default = register_string("default"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1913 token_dnsbl = register_string("dnsbl"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1914 token_dnsbll = register_string("dnsbl_list"); |
249 | 1915 token_dnswl = register_string("dnswl"); |
1916 token_dnswll = register_string("dnswl_list"); | |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1917 token_envfrom = register_string("env_from"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1918 token_envto = register_string("env_to"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1919 token_filter = register_string("filter"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1920 token_generic = register_string("generic"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1921 token_host_limit = register_string("host_limit"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1922 token_html_limit = register_string("html_limit"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1923 token_html_tags = register_string("html_tags"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1924 token_ignore = register_string("ignore"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1925 token_include = register_string("include"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1926 token_inherit = register_string("inherit"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1927 token_lbrace = register_string("{"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1928 token_mailhost = register_string("mail_host"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1929 token_many = register_string("many"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1930 token_no = register_string("no"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1931 token_off = register_string("off"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1932 token_ok = register_string("ok"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1933 token_ok2 = register_string("ok2"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1934 token_on = register_string("on"); |
270
f92f24950bd3
Use mozilla prefix list for tld checking, Enable surbl/uribl/dbl rhs lists
Carl Byington <carl@five-ten-sg.com>
parents:
268
diff
changeset
|
1935 token_period = register_string("."); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1936 token_rate = register_string("rate_limit"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1937 token_rbrace = register_string("}"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1938 token_require = register_string("require_match"); |
268
f941563c2a95
Add require_rdns checking
Carl Byington <carl@five-ten-sg.com>
parents:
266
diff
changeset
|
1939 token_requirerdns = register_string("require_rdns"); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1940 token_semi = register_string(";"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1941 token_soft = register_string("soft"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1942 token_spamassassin = register_string("spamassassin"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1943 token_substitute = register_string("substitute"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1944 token_tld = register_string("tld"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1945 token_unknown = register_string("unknown"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1946 token_uribl = register_string("uribl"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1947 token_verify = register_string("verify"); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1948 token_white = register_string("white"); |
233
5c3e9bf45bb5
Add whitelisting by regex expression filtering.
Carl Byington <carl@five-ten-sg.com>
parents:
214
diff
changeset
|
1949 token_white_regex = register_string("white_regex"); |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1950 token_yes = register_string("yes"); |
94 | 1951 |
192
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1952 if (gethostname(myhostname, HOST_NAME_MAX+1) != 0) { |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1953 strncpy(myhostname, "localhost", HOST_NAME_MAX+1); |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1954 } |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1955 myhostname[HOST_NAME_MAX] = '\0'; // ensure null termination |
8f4a9a37d4d9
delay autowhitelisting to avoid out of office reply bots
carl
parents:
180
diff
changeset
|
1956 token_myhostname = register_string(myhostname); |
94 | 1957 } |