Mercurial > dnsbl
annotate src/dnsbl.cpp @ 59:510a511ad554
Add resolver processes to allow better performance on busy machines
author | carl |
---|---|
date | Mon, 03 Jan 2005 18:35:50 -0800 |
parents | 7bb8bbf79285 |
children | 390ed250c5d2 |
rev | line source |
---|---|
0 | 1 /* |
2 | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
3 Copyright (c) 2004, 2005 Carl Byington - 510 Software Group, released |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
4 under the GPL version 2 or any later version at your choice available at |
0 | 5 http://www.fsf.org/licenses/gpl.txt |
6 | |
7 Based on a sample milter Copyright (c) 2000-2003 Sendmail, Inc. and its | |
8 suppliers. Inspired by the DCC by Rhyolite Software | |
9 | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
10 -r port The port used to talk to our internal dns resolver processes |
0 | 11 -p port The port through which the MTA will connect to this milter. |
12 -t sec The timeout value. | |
9 | 13 -c Check the config, and print a copy to stdout. Don't start the |
4 | 14 milter or do anything with the socket. |
16 | 15 -d Add debug syslog entries |
16 | |
0 | 17 |
13 | 18 TODO: |
19 1) Add config for max_recipients for each mail domain. Recipients in | |
20 excess of that limit will be rejected, and the entire data will be | |
21 rejected if it is sent. | |
22 | |
23 2) Add config for poison addresses. If any recipient is poison, all | |
24 recipients are rejected even if they would be whitelisted, and the | |
25 data is rejected if sent. | |
26 | |
34 | 27 3) Add option to only allow one recipient if the return path is empty. |
28 | |
53
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
29 4) Check if the envelope from domain name primary MX points 127.0.0.0/8 |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
30 |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
31 5) Add option for using smtp connections to verify addresses from backup |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
32 mx machines. This allows the backup mx to learn the valid addresses |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
33 on the primary machine. |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
34 |
0 | 35 */ |
36 | |
37 | |
38 // from sendmail sample | |
39 #include <sys/types.h> | |
40 #include <sys/stat.h> | |
41 #include <errno.h> | |
42 #include <sysexits.h> | |
43 #include <unistd.h> | |
44 | |
45 // needed for socket io | |
46 #include <sys/ioctl.h> | |
47 #include <net/if.h> | |
48 #include <arpa/inet.h> | |
49 #include <netinet/in.h> | |
50 #include <netinet/tcp.h> | |
51 #include <netdb.h> | |
52 #include <sys/socket.h> | |
42 | 53 #include <sys/un.h> |
0 | 54 |
55 // needed for thread | |
56 #include <pthread.h> | |
57 | |
58 // needed for std c++ collections | |
59 #include <set> | |
60 #include <map> | |
61 #include <list> | |
62 | |
63 // for the dns resolver | |
64 #include <netinet/in.h> | |
65 #include <arpa/nameser.h> | |
66 #include <resolv.h> | |
67 | |
68 // misc stuff needed here | |
69 #include <ctype.h> | |
70 #include <fstream> | |
71 #include <syslog.h> | |
42 | 72 #include <pwd.h> |
0 | 73 |
8 | 74 static char* dnsbl_version="$Id$"; |
0 | 75 |
8 | 76 #define DEFAULT "default" |
77 #define WHITE "white" | |
78 #define BLACK "black" | |
79 #define OK "ok" | |
80 #define MANY "many" | |
81 | |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
82 enum status {oksofar, // not rejected yet |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
83 white, // whitelisted by envelope from |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
84 black, // blacklisted by envelope from or to |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
85 reject, // rejected by a dns list |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
86 reject_tag, // too many bad html tags |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
87 reject_host}; // too many hosts/urls in body |
1 | 88 |
0 | 89 using namespace std; |
90 | |
91 extern "C" { | |
92 #include "libmilter/mfapi.h" | |
93 sfsistat mlfi_connect(SMFICTX *ctx, char *hostname, _SOCK_ADDR *hostaddr); | |
94 sfsistat mlfi_envfrom(SMFICTX *ctx, char **argv); | |
95 sfsistat mlfi_envrcpt(SMFICTX *ctx, char **argv); | |
8 | 96 sfsistat mlfi_body(SMFICTX *ctx, u_char *data, size_t len); |
97 sfsistat mlfi_eom(SMFICTX *ctx); | |
98 sfsistat mlfi_abort(SMFICTX *ctx); | |
0 | 99 sfsistat mlfi_close(SMFICTX *ctx); |
100 } | |
101 | |
102 struct ltstr { | |
103 bool operator()(char* s1, char* s2) const { | |
104 return strcmp(s1, s2) < 0; | |
105 } | |
106 }; | |
107 | |
108 struct DNSBL { | |
109 char *suffix; // blacklist suffix like blackholes.five-ten-sg.com | |
110 char *message; // error message with one or two %s operators for the ip address replacement | |
111 DNSBL(char *s, char *m); | |
112 }; | |
113 DNSBL::DNSBL(char *s, char *m) { | |
114 suffix = s; | |
115 message = m; | |
116 } | |
117 | |
118 typedef DNSBL * DNSBLP; | |
119 typedef list<DNSBLP> DNSBLL; | |
120 typedef DNSBLL * DNSBLLP; | |
121 typedef map<char *, char *, ltstr> string_map; | |
122 typedef map<char *, string_map *, ltstr> from_map; | |
123 typedef map<char *, DNSBLP, ltstr> dnsblp_map; | |
124 typedef map<char *, DNSBLLP, ltstr> dnsbllp_map; | |
125 typedef set<char *, ltstr> string_set; | |
44 | 126 typedef set<int> int_set; |
0 | 127 typedef list<char *> string_list; |
53
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
128 typedef map<char *, int, ltstr> ns_mapper; |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
129 |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
130 struct ns_map { |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
131 // all the strings are owned by the keys/values in the ns_host string map |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
132 string_map ns_host; // nameserver name -> host name that uses this name server |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
133 ns_mapper ns_ip; // nameserver name -> ip address of the name server |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
134 }; |
0 | 135 |
136 struct CONFIG { | |
137 // the only mutable stuff once it has been loaded from the config file | |
138 int reference_count; // protected by the global config_mutex | |
139 // all the rest is constant after loading from the config file | |
29
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
140 int generation; |
0 | 141 time_t load_time; |
142 string_list config_files; | |
143 dnsblp_map dnsbls; | |
144 dnsbllp_map dnsblls; | |
145 from_map env_from; | |
146 string_map env_to_dnsbll; // map recipient to a named dnsbll | |
147 string_map env_to_chkfrom; // map recipient to a named from map | |
8 | 148 char * content_suffix; // for sbl url body filtering |
9 | 149 char * content_message; // "" |
57 | 150 string_set content_host_ignore;// hosts to ignore for content sbl checking |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
151 char * host_limit_message; // error message for excessive host names |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
152 int host_limit; // limit on host names |
44 | 153 bool host_random; // pick a random selection of host names rather than error for excessive hosts |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
154 char * tag_limit_message; // error message for excessive bad html tags |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
155 int tag_limit; // limit on bad html tags |
24 | 156 string_set html_tags; // set of valid html tags |
28 | 157 string_set tlds; // set of valid tld components |
0 | 158 CONFIG(); |
159 ~CONFIG(); | |
160 }; | |
161 CONFIG::CONFIG() { | |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
162 reference_count = 0; |
29
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
163 generation = 0; |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
164 load_time = 0; |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
165 content_suffix = NULL; |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
166 content_message = NULL; |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
167 host_limit_message = NULL; |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
168 host_limit = 0; |
44 | 169 host_random = false; |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
170 tag_limit_message = NULL; |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
171 tag_limit = 0; |
0 | 172 } |
173 CONFIG::~CONFIG() { | |
174 for (dnsblp_map::iterator i=dnsbls.begin(); i!=dnsbls.end(); i++) { | |
175 DNSBLP d = (*i).second; | |
24 | 176 // delete the underlying DNSBL objects. |
0 | 177 delete d; |
178 } | |
179 for (dnsbllp_map::iterator i=dnsblls.begin(); i!=dnsblls.end(); i++) { | |
180 DNSBLLP d = (*i).second; | |
24 | 181 // *d is a list of pointers to DNSBL objects, but |
182 // the underlying objects have already been deleted above. | |
0 | 183 delete d; |
184 } | |
185 for (from_map::iterator i=env_from.begin(); i!=env_from.end(); i++) { | |
186 string_map *d = (*i).second; | |
187 delete d; | |
188 } | |
189 } | |
190 | |
16 | 191 static bool debug_syslog = false; |
18 | 192 static bool loader_run = true; // used to stop the config loader thread |
0 | 193 static string_set all_strings; // owns all the strings, only modified by the config loader thread |
194 static CONFIG * config = NULL; // protected by the config_mutex | |
29
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
195 static int generation = 0; // protected by the config_mutex |
0 | 196 |
197 static pthread_mutex_t config_mutex; | |
198 static pthread_mutex_t syslog_mutex; | |
199 static pthread_mutex_t resolve_mutex; | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
200 static pthread_mutex_t fd_pool_mutex; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
201 static std::set<int> fd_pool; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
202 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
203 static int NULL_SOCKET = -1; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
204 static int resolver_port = 0; // global port number to talk to the dns resolver process |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
205 static int resolver_socket = NULL_SOCKET; // socket used to listen for resolver requests |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
206 static time_t ERROR_SOCKET_TIME = 60; // number of seconds between attempts to open the spam filter socket |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
207 static time_t last_error_time; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
208 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
209 #ifdef NS_PACKETSZ |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
210 // packed structure to allow a single socket write to dump the |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
211 // length and the following answer. The packing attribute is gcc specific. |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
212 struct glommer { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
213 int length; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
214 u_char answer[NS_PACKETSZ]; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
215 } __attribute__ ((packed)); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
216 #endif |
0 | 217 |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
218 struct mlfiPriv; |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
219 |
0 | 220 |
221 //////////////////////////////////////////////// | |
34 | 222 // helper to discard the strings and objects held by an ns_map |
223 // | |
224 static void discard(ns_map &s); | |
225 static void discard(ns_map &s) { | |
53
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
226 for (string_map::iterator i=s.ns_host.begin(); i!=s.ns_host.end(); i++) { |
34 | 227 char *x = (*i).first; |
53
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
228 char *y = (*i).second; |
34 | 229 free(x); |
53
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
230 free(y); |
34 | 231 } |
53
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
232 s.ns_ip.clear(); |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
233 s.ns_host.clear(); |
34 | 234 } |
235 | |
236 //////////////////////////////////////////////// | |
237 // helper to register a string in an ns_map | |
238 // | |
53
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
239 static void register_string(ns_map &s, char *name, char *refer); |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
240 static void register_string(ns_map &s, char *name, char *refer) { |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
241 string_map::iterator i = s.ns_host.find(name); |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
242 if (i != s.ns_host.end()) return; |
34 | 243 char *x = strdup(name); |
53
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
244 char *y = strdup(refer); |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
245 s.ns_ip[x] = 0; |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
246 s.ns_host[x] = y; |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
247 |
34 | 248 } |
249 | |
250 //////////////////////////////////////////////// | |
8 | 251 // helper to discard the strings held by a string_set |
0 | 252 // |
9 | 253 static void discard(string_set &s); |
254 static void discard(string_set &s) { | |
8 | 255 for (string_set::iterator i=s.begin(); i!=s.end(); i++) { |
256 free(*i); | |
257 } | |
9 | 258 s.clear(); |
8 | 259 } |
0 | 260 |
12 | 261 //////////////////////////////////////////////// |
262 // helper to register a string in a string set | |
263 // | |
264 static char* register_string(string_set &s, char *name); | |
265 static char* register_string(string_set &s, char *name) { | |
266 string_set::iterator i = s.find(name); | |
267 if (i != s.end()) return *i; | |
268 char *x = strdup(name); | |
269 s.insert(x); | |
270 return x; | |
271 } | |
272 | |
16 | 273 //////////////////////////////////////////////// |
274 // syslog a message | |
275 // | |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
276 static void my_syslog(mlfiPriv *priv, char *text); |
16 | 277 |
278 | |
12 | 279 // include the content scanner |
280 #include "scanner.cpp" | |
281 | |
282 | |
0 | 283 //////////////////////////////////////////////// |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
284 // disconnect the fd from the dns resolver process |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
285 // |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
286 void my_disconnect(int sock); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
287 void my_disconnect(int sock) |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
288 { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
289 if (sock != NULL_SOCKET) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
290 shutdown(sock, SHUT_RDWR); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
291 close(sock); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
292 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
293 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
294 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
295 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
296 //////////////////////////////////////////////// |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
297 // return fd connected to the dns resolver process |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
298 // |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
299 int my_connect(); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
300 int my_connect() |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
301 { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
302 // if we have had recent errors, don't even try to open the socket |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
303 time_t now = time(NULL); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
304 if ((now - last_error_time) < ERROR_SOCKET_TIME) return NULL_SOCKET; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
305 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
306 // nothing recent, maybe this time it will work |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
307 int sock = NULL_SOCKET; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
308 hostent *host = gethostbyname("localhost"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
309 if (host) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
310 sockaddr_in server; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
311 server.sin_family = host->h_addrtype; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
312 server.sin_port = htons(resolver_port); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
313 memcpy(&server.sin_addr, host->h_addr_list[0], host->h_length); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
314 sock = socket(PF_INET, SOCK_STREAM, 0); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
315 if (sock != NULL_SOCKET) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
316 bool rc = (connect(sock, (sockaddr *)&server, sizeof(server)) == 0); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
317 if (!rc) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
318 int er = errno; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
319 my_disconnect(sock); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
320 sock = NULL_SOCKET; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
321 last_error_time = now; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
322 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
323 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
324 else last_error_time = now; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
325 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
326 return sock; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
327 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
328 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
329 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
330 //////////////////////////////////////////////// |
0 | 331 // mail filter private data, held for us by sendmail |
332 // | |
333 struct mlfiPriv | |
334 { | |
8 | 335 // connection specific data |
336 CONFIG *pc; // global context with our maps | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
337 int fd; // to talk to dns resolvers process |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
338 bool err; // did we get any errors on the resolver socket? |
8 | 339 int ip; // ip4 address of the smtp client |
340 map<DNSBLP, status> checked; // status from those lists | |
341 // message specific data | |
0 | 342 char *mailaddr; // envelope from value |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
343 char *queueid; // sendmail queue id |
0 | 344 bool authenticated; // client authenticated? if so, suppress all dnsbl checks |
8 | 345 bool have_whites; // have at least one whitelisted recipient? need to accept content and remove all non-whitelisted recipients if it fails |
346 bool only_whites; // every recipient is whitelisted? | |
24 | 347 string_set non_whites; // remember the non-whitelisted recipients so we can remove them if need be |
348 recorder *memory; // memory for the content scanner | |
8 | 349 url_scanner *scanner; // object to handle body scanning |
0 | 350 mlfiPriv(); |
351 ~mlfiPriv(); | |
8 | 352 void reset(bool final = false); // for a new message |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
353 void get_fd(); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
354 void return_fd(); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
355 int my_read(char *buf, int len); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
356 int my_write(char *buf, int len); |
0 | 357 }; |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
358 |
0 | 359 mlfiPriv::mlfiPriv() { |
360 pthread_mutex_lock(&config_mutex); | |
361 pc = config; | |
362 pc->reference_count++; | |
363 pthread_mutex_unlock(&config_mutex); | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
364 get_fd(); |
8 | 365 ip = 0; |
366 mailaddr = NULL; | |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
367 queueid = NULL; |
8 | 368 authenticated = false; |
369 have_whites = false; | |
370 only_whites = true; | |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
371 memory = new recorder(this, &pc->html_tags, &pc->tlds); |
24 | 372 scanner = new url_scanner(memory); |
0 | 373 } |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
374 |
0 | 375 mlfiPriv::~mlfiPriv() { |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
376 return_fd(); |
0 | 377 pthread_mutex_lock(&config_mutex); |
378 pc->reference_count--; | |
379 pthread_mutex_unlock(&config_mutex); | |
8 | 380 reset(true); |
381 } | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
382 |
8 | 383 void mlfiPriv::reset(bool final) { |
0 | 384 if (mailaddr) free(mailaddr); |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
385 if (queueid) free(queueid); |
24 | 386 discard(non_whites); |
387 delete memory; | |
8 | 388 delete scanner; |
389 if (!final) { | |
390 mailaddr = NULL; | |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
391 queueid = NULL; |
8 | 392 authenticated = false; |
393 have_whites = false; | |
394 only_whites = true; | |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
395 memory = new recorder(this, &pc->html_tags, &pc->tlds); |
24 | 396 scanner = new url_scanner(memory); |
8 | 397 } |
0 | 398 } |
399 | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
400 void mlfiPriv::get_fd() |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
401 { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
402 err = true; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
403 fd = NULL_SOCKET; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
404 int result = pthread_mutex_lock(&fd_pool_mutex); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
405 if (!result) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
406 std::set<int>::iterator i; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
407 i = fd_pool.begin(); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
408 if (i != fd_pool.end()) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
409 // have at least one fd in the pool |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
410 err = false; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
411 fd = *i; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
412 fd_pool.erase(fd); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
413 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
414 else { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
415 // pool is empty, get a new fd |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
416 fd = my_connect(); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
417 err = (fd == NULL_SOCKET); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
418 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
419 pthread_mutex_unlock(&fd_pool_mutex); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
420 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
421 else { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
422 // cannot lock the pool, just get a new fd |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
423 fd = my_connect(); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
424 err = (fd == NULL_SOCKET); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
425 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
426 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
427 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
428 void mlfiPriv::return_fd() |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
429 { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
430 if (err) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
431 // this fd got a socket error, so close it, rather than returning it to the pool |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
432 my_disconnect(fd); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
433 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
434 else { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
435 int result = pthread_mutex_lock(&fd_pool_mutex); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
436 if (!result) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
437 // return the fd to the pool |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
438 fd_pool.insert(fd); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
439 pthread_mutex_unlock(&fd_pool_mutex); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
440 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
441 else { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
442 // could not lock the pool, so just close the fd |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
443 my_disconnect(fd); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
444 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
445 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
446 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
447 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
448 int mlfiPriv::my_write(char *buf, int len) |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
449 { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
450 if (err) return 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
451 int rs = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
452 while (len) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
453 int ws = write(fd, buf, len); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
454 if (ws > 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
455 rs += ws; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
456 len -= ws; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
457 buf += ws; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
458 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
459 else { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
460 // peer closed the socket! |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
461 rs = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
462 err = true; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
463 break; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
464 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
465 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
466 return rs; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
467 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
468 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
469 int mlfiPriv::my_read(char *buf, int len) |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
470 { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
471 if (err) return 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
472 int rs = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
473 while (len > 1) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
474 int ws = read(fd, buf, len); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
475 if (ws > 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
476 rs += ws; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
477 len -= ws; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
478 buf += ws; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
479 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
480 else { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
481 // peer closed the socket! |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
482 rs = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
483 err = true; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
484 break; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
485 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
486 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
487 return rs; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
488 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
489 |
0 | 490 #define MLFIPRIV ((struct mlfiPriv *) smfi_getpriv(ctx)) |
491 | |
492 | |
493 //////////////////////////////////////////////// | |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
494 // syslog a message |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
495 // |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
496 static void my_syslog(mlfiPriv *priv, char *text) { |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
497 char buf[1000]; |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
498 if (priv) { |
42 | 499 snprintf(buf, sizeof(buf), "%s: %s", priv->queueid, text); |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
500 text = buf; |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
501 } |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
502 pthread_mutex_lock(&syslog_mutex); |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
503 openlog("dnsbl", LOG_PID, LOG_MAIL); |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
504 syslog(LOG_NOTICE, "%s", text); |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
505 closelog(); |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
506 pthread_mutex_unlock(&syslog_mutex); |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
507 } |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
508 |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
509 static void my_syslog(char *text); |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
510 static void my_syslog(char *text) { |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
511 my_syslog(NULL, text); |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
512 } |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
513 |
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
514 //////////////////////////////////////////////// |
0 | 515 // register a global string |
516 // | |
517 static char* register_string(char *name); | |
518 static char* register_string(char *name) { | |
12 | 519 return register_string(all_strings, name); |
0 | 520 } |
521 | |
522 | |
523 static char* next_token(char *delim); | |
524 static char* next_token(char *delim) { | |
525 char *name = strtok(NULL, delim); | |
526 if (!name) return name; | |
527 return register_string(name); | |
528 } | |
529 | |
530 | |
531 //////////////////////////////////////////////// | |
532 // lookup an email address in the env_from or env_to maps | |
533 // | |
534 static char* lookup1(char *email, string_map map); | |
535 static char* lookup1(char *email, string_map map) { | |
536 string_map::iterator i = map.find(email); | |
537 if (i != map.end()) return (*i).second; | |
538 char *x = strchr(email, '@'); | |
539 if (!x) return DEFAULT; | |
540 x++; | |
541 i = map.find(x); | |
542 if (i != map.end()) return (*i).second; | |
543 return DEFAULT; | |
544 } | |
545 | |
546 | |
547 //////////////////////////////////////////////// | |
548 // lookup an email address in the env_from or env_to maps | |
549 // this email address is passed in from sendmail, and will | |
550 // always be enclosed in <>. It may have mixed case, just | |
551 // as the mail client sent it. | |
552 // | |
553 static char* lookup(char* email, string_map map); | |
554 static char* lookup(char* email, string_map map) { | |
555 int n = strlen(email)-2; | |
556 if (n < 1) return DEFAULT; // malformed | |
557 char *key = strdup(email+1); | |
558 key[n] = '\0'; | |
559 for (int i=0; i<n; i++) key[i] = tolower(key[i]); | |
560 char *rc = lookup1(key, map); | |
561 free(key); | |
562 return rc; | |
563 } | |
564 | |
565 | |
566 //////////////////////////////////////////////// | |
567 // find the dnsbl with a specific name | |
568 // | |
569 static DNSBLP find_dnsbl(CONFIG &dc, char *name); | |
570 static DNSBLP find_dnsbl(CONFIG &dc, char *name) { | |
571 dnsblp_map::iterator i = dc.dnsbls.find(name); | |
572 if (i == dc.dnsbls.end()) return NULL; | |
573 return (*i).second; | |
574 } | |
575 | |
576 | |
577 //////////////////////////////////////////////// | |
578 // find the dnsbll with a specific name | |
579 // | |
580 static DNSBLLP find_dnsbll(CONFIG &dc, char *name); | |
581 static DNSBLLP find_dnsbll(CONFIG &dc, char *name) { | |
582 dnsbllp_map::iterator i = dc.dnsblls.find(name); | |
583 if (i == dc.dnsblls.end()) return NULL; | |
584 return (*i).second; | |
585 } | |
586 | |
587 | |
588 //////////////////////////////////////////////// | |
589 // find the envfrom map with a specific name | |
590 // | |
591 static string_map* find_from_map(CONFIG &dc, char *name); | |
592 static string_map* find_from_map(CONFIG &dc, char *name) { | |
593 from_map::iterator i = dc.env_from.find(name); | |
594 if (i == dc.env_from.end()) return NULL; | |
595 return (*i).second; | |
596 } | |
597 | |
598 | |
599 static string_map& really_find_from_map(CONFIG &dc, char *name); | |
600 static string_map& really_find_from_map(CONFIG &dc, char *name) { | |
601 string_map *sm = find_from_map(dc, name); | |
602 if (!sm) { | |
603 sm = new string_map; | |
604 dc.env_from[name] = sm; | |
605 } | |
606 return *sm; | |
607 } | |
608 | |
609 | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
610 |
0 | 611 //////////////////////////////////////////////// |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
612 // read a resolver request from the socket, process it, and |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
613 // write the result back to the socket. |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
614 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
615 #ifdef NS_PACKETSZ |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
616 static void process_resolver_requests(int socket); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
617 static void process_resolver_requests(int socket) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
618 #ifdef NS_MAXDNAME |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
619 char question[NS_MAXDNAME]; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
620 #else |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
621 char question[1000]; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
622 #endif |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
623 glommer glom; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
624 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
625 int maxq = sizeof(question); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
626 while (true) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
627 // read a question |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
628 int rs = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
629 while (true) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
630 int ns = read(socket, question+rs, maxq-rs); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
631 if (ns > 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
632 rs += ns; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
633 if (question[rs-1] == '\0') { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
634 // last byte read was the null terminator, we are done |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
635 break; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
636 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
637 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
638 else { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
639 // peer closed the socket |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
640 //my_syslog("child worker process, peer closed socket while reading question"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
641 shutdown(socket, SHUT_RDWR); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
642 close(socket); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
643 return; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
644 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
645 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
646 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
647 // find the answer |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
648 //char text[1000]; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
649 //snprintf(text, sizeof(text), "child worker process has a question %s", question); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
650 //my_syslog(text); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
651 glom.length = res_search(question, ns_c_in, ns_t_a, glom.answer, sizeof(glom.answer)); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
652 if (glom.length < 0) glom.length = 0; // represent all errors as zero length answers |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
653 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
654 // write the answer |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
655 char *buf = (char *)&glom; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
656 int len = glom.length + sizeof(glom.length); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
657 //snprintf(text, sizeof(text), "child worker process writing answer length %d for total %d", glom.length, len); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
658 //my_syslog(text); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
659 int ws = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
660 while (len > ws) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
661 int ns = write(socket, buf+ws, len-ws); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
662 if (ns > 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
663 ws += ns; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
664 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
665 else { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
666 // peer closed the socket! |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
667 //my_syslog("child worker process, peer closed socket while writing answer"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
668 shutdown(socket, SHUT_RDWR); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
669 close(socket); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
670 return; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
671 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
672 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
673 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
674 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
675 #endif |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
676 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
677 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
678 //////////////////////////////////////////////// |
8 | 679 // ask a dns question and get an A record answer - we don't try |
680 // very hard, just using the default resolver retry settings. | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
681 // If we cannot get an answer, we just accept the mail. |
8 | 682 // |
0 | 683 // |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
684 static int dns_interface(mlfiPriv &priv, char *question, bool maybe_ip, ns_map *nameservers); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
685 static int dns_interface(mlfiPriv &priv, char *question, bool maybe_ip, ns_map *nameservers) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
686 int ret_address = 0; |
16 | 687 #ifdef NS_PACKETSZ |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
688 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
689 // this part can be done without locking the resolver mutex. Each |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
690 // milter thread is talking over its own socket to a separate resolver |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
691 // process, which does the actual dns resolution. |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
692 if (priv.err) return 0; // cannot ask more questions on this socket. |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
693 priv.my_write(question, strlen(question)+1); // write the question including the null terminator |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
694 glommer glom; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
695 char *buf = (char *)&glom; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
696 priv.my_read(buf, sizeof(glom.length)); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
697 buf += sizeof(glom.length); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
698 //char text[1000]; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
699 //snprintf(text, sizeof(text), "milter thread wrote question %s and has answer length %d", question, glom.length); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
700 //my_syslog(text); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
701 if ((glom.length < 0) || (glom.length > sizeof(glom.answer))) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
702 priv.err = true; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
703 return 0; // cannot process overlarge answers |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
704 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
705 priv.my_read(buf, glom.length); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
706 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
707 // now we need to lock the resolver mutex to keep the milter threads from |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
708 // stepping on each other while parsing the dns answer. |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
709 pthread_mutex_lock(&resolve_mutex); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
710 if (glom.length > 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
711 // parse the answer |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
712 ns_msg handle; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
713 ns_rr rr; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
714 if (ns_initparse(glom.answer, glom.length, &handle) == 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
715 // look for ns names |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
716 if (nameservers) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
717 ns_map &ns = *nameservers; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
718 int rrnum = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
719 while (ns_parserr(&handle, ns_s_ns, rrnum++, &rr) == 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
720 if (ns_rr_type(rr) == ns_t_ns) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
721 char nam[NS_MAXDNAME+1]; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
722 char *n = nam; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
723 const u_char *p = ns_rr_rdata(rr); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
724 while (((n-nam) < NS_MAXDNAME) && ((p-glom.answer) < glom.length) && *p) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
725 size_t s = *(p++); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
726 if (s > 191) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
727 // compression pointer |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
728 s = (s-192)*256 + *(p++); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
729 if (s >= glom.length) break; // pointer outside bounds of answer |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
730 p = glom.answer + s; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
731 s = *(p++); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
732 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
733 if (s > 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
734 if ((n-nam) >= (NS_MAXDNAME-s)) break; // destination would overflow name buffer |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
735 if ((p-glom.answer) >= (glom.length-s)) break; // source outside bounds of answer |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
736 memcpy(n, p, s); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
737 n += s; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
738 p += s; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
739 *(n++) = '.'; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
740 } |
34 | 741 } |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
742 if (n-nam) n--; // remove trailing . |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
743 *n = '\0'; // null terminate it |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
744 register_string(ns, nam, question); // ns host to lookup later |
34 | 745 } |
746 } | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
747 rrnum = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
748 while (ns_parserr(&handle, ns_s_ar, rrnum++, &rr) == 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
749 if (ns_rr_type(rr) == ns_t_a) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
750 char* nam = (char*)ns_rr_name(rr); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
751 ns_mapper::iterator i = ns.ns_ip.find(nam); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
752 if (i != ns.ns_ip.end()) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
753 // we want this ip address |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
754 int address; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
755 memcpy(&address, ns_rr_rdata(rr), sizeof(address)); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
756 ns.ns_ip[nam] = address; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
757 } |
34 | 758 } |
759 } | |
760 } | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
761 int rrnum = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
762 while (ns_parserr(&handle, ns_s_an, rrnum++, &rr) == 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
763 if (ns_rr_type(rr) == ns_t_a) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
764 int address; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
765 memcpy(&address, ns_rr_rdata(rr), sizeof(address)); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
766 ret_address = address; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
767 } |
23
06de5ab6a232
add url decoding stage, allow http:/ single / in yahoo redirector, allow ip address hostnames
carl
parents:
22
diff
changeset
|
768 } |
06de5ab6a232
add url decoding stage, allow http:/ single / in yahoo redirector, allow ip address hostnames
carl
parents:
22
diff
changeset
|
769 } |
06de5ab6a232
add url decoding stage, allow http:/ single / in yahoo redirector, allow ip address hostnames
carl
parents:
22
diff
changeset
|
770 } |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
771 if (maybe_ip && !ret_address) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
772 // might be a bare ip address |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
773 in_addr ip; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
774 if (inet_aton(question, &ip)) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
775 ret_address = ip.s_addr; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
776 } |
8 | 777 } |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
778 pthread_mutex_unlock(&resolve_mutex); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
779 return ret_address; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
780 |
16 | 781 #else |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
782 // systems without the resolver interface |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
783 pthread_mutex_lock(&resolve_mutex); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
784 struct hostent *host = gethostbyname(question); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
785 if (host && (host->h_addrtype == AF_INET)) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
786 memcpy(&ret_address, host->h_addr, sizeof(ret_address)); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
787 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
788 pthread_mutex_unlock(&resolve_mutex); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
789 return ret_address; |
16 | 790 #endif |
8 | 791 } |
792 | |
793 | |
794 //////////////////////////////////////////////// | |
795 // check a single dnsbl | |
796 // | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
797 static status check_single(mlfiPriv &priv, int ip, char *suffix); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
798 static status check_single(mlfiPriv &priv, int ip, char *suffix) { |
0 | 799 // make a dns question |
800 const u_char *src = (const u_char *)&ip; | |
801 if (src[0] == 127) return oksofar; // don't do dns lookups on localhost | |
16 | 802 #ifdef NS_MAXDNAME |
0 | 803 char question[NS_MAXDNAME]; |
16 | 804 #else |
805 char question[1000]; | |
806 #endif | |
8 | 807 snprintf(question, sizeof(question), "%u.%u.%u.%u.%s.", src[3], src[2], src[1], src[0], suffix); |
808 // ask the question, if we get an A record it implies a blacklisted ip address | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
809 return (dns_interface(priv, question, false, NULL)) ? reject : oksofar; |
8 | 810 } |
811 | |
812 | |
813 //////////////////////////////////////////////// | |
814 // check a single dnsbl | |
815 // | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
816 static status check_single(mlfiPriv &priv, int ip, DNSBL &bl); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
817 static status check_single(mlfiPriv &priv, int ip, DNSBL &bl) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
818 return check_single(priv, ip, bl.suffix); |
0 | 819 } |
820 | |
821 | |
822 //////////////////////////////////////////////// | |
823 // check the dnsbls specified for this recipient | |
824 // | |
825 static status check_dnsbl(mlfiPriv &priv, DNSBLLP dnsbllp, DNSBLP &rejectlist); | |
826 static status check_dnsbl(mlfiPriv &priv, DNSBLLP dnsbllp, DNSBLP &rejectlist) { | |
827 if (priv.authenticated) return oksofar; | |
828 if (!dnsbllp) return oksofar; | |
829 DNSBLL &dnsbll = *dnsbllp; | |
830 for (DNSBLL::iterator i=dnsbll.begin(); i!=dnsbll.end(); i++) { | |
831 DNSBLP dp = *i; // non null by construction | |
832 status st; | |
833 map<DNSBLP, status>::iterator f = priv.checked.find(dp); | |
834 if (f == priv.checked.end()) { | |
835 // have not checked this list yet | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
836 st = check_single(priv, priv.ip, *dp); |
0 | 837 rejectlist = dp; |
838 priv.checked[dp] = st; | |
839 } | |
840 else { | |
841 st = (*f).second; | |
842 rejectlist = (*f).first; | |
843 } | |
844 if (st == reject) return st; | |
845 } | |
846 return oksofar; | |
847 } | |
848 | |
849 | |
850 //////////////////////////////////////////////// | |
55
44babba1a9b9
updates for 3.6, better documentation on removing content filtering, missing some files in cvs
carl
parents:
53
diff
changeset
|
851 // check the hosts from the body against the content dnsbl |
8 | 852 // |
16 | 853 static status check_hosts(mlfiPriv &priv, char *&host, int &ip); |
854 static status check_hosts(mlfiPriv &priv, char *&host, int &ip) { | |
55
44babba1a9b9
updates for 3.6, better documentation on removing content filtering, missing some files in cvs
carl
parents:
53
diff
changeset
|
855 CONFIG &dc = *priv.pc; |
8 | 856 int count = 0; |
34 | 857 ns_map nameservers; |
44 | 858 bool ran = priv.pc->host_random; |
859 int lim = priv.pc->host_limit; // we should not look at more than this many hosts | |
860 int cnt = priv.memory->hosts.size(); // number of hosts we could look at | |
861 int_set ips; // remove duplicate ip addresses | |
24 | 862 for (string_set::iterator i=priv.memory->hosts.begin(); i!=priv.memory->hosts.end(); i++) { |
44 | 863 host = *i; // a reference into priv.memory->hosts, which will live until this smtp transaction is closed |
58 | 864 |
865 // don't bother looking up hosts on the ignore list | |
57 | 866 string_set::iterator j = priv.pc->content_host_ignore.find(host); |
58 | 867 if (j != priv.pc->content_host_ignore.end()) continue; |
868 | |
869 // try to only look at lim/cnt fraction of the available cnt host names in random mode | |
44 | 870 if ((cnt > lim) && (lim > 0) && ran) { |
871 int r = rand() % cnt; | |
872 if (r >= lim) { | |
873 char buf[1000]; | |
874 snprintf(buf, sizeof(buf), "host %s skipped", host); | |
875 my_syslog(&priv, buf); | |
876 continue; | |
877 } | |
878 } | |
8 | 879 count++; |
44 | 880 if ((count > lim) && (lim > 0) && (!ran)) { |
34 | 881 discard(nameservers); |
882 return reject_host; | |
883 } | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
884 ip = dns_interface(priv, host, true, &nameservers); |
16 | 885 if (debug_syslog) { |
44 | 886 char buf[1000]; |
29
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
887 if (ip) { |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
888 char adr[sizeof "255.255.255.255"]; |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
889 adr[0] = '\0'; |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
890 inet_ntop(AF_INET, (const u_char *)&ip, adr, sizeof(adr)); |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
891 snprintf(buf, sizeof(buf), "host %s found at %s", host, adr); |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
892 } |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
893 else { |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
894 snprintf(buf, sizeof(buf), "host %s not found", host); |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
895 } |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
896 my_syslog(&priv, buf); |
16 | 897 } |
8 | 898 if (ip) { |
44 | 899 int_set::iterator i = ips.find(ip); |
900 if (i == ips.end()) { | |
901 ips.insert(ip); | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
902 status st = check_single(priv, ip, dc.content_suffix); |
44 | 903 if (st == reject) { |
904 discard(nameservers); | |
905 return st; | |
906 } | |
34 | 907 } |
8 | 908 } |
909 } | |
34 | 910 lim *= 4; // allow average of 3 ns per host name |
53
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
911 for (ns_mapper::iterator i=nameservers.ns_ip.begin(); i!=nameservers.ns_ip.end(); i++) { |
34 | 912 count++; |
913 if ((count > lim) && (lim > 0)) { | |
44 | 914 if (ran) continue; // don't complain |
34 | 915 discard(nameservers); |
916 return reject_host; | |
917 } | |
36 | 918 host = (*i).first; // a transient reference that needs to be replaced before we return it |
34 | 919 ip = (*i).second; |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
920 if (!ip) ip = dns_interface(priv, host, false, NULL); |
34 | 921 if (debug_syslog) { |
922 char buf[200]; | |
923 if (ip) { | |
924 char adr[sizeof "255.255.255.255"]; | |
925 adr[0] = '\0'; | |
926 inet_ntop(AF_INET, (const u_char *)&ip, adr, sizeof(adr)); | |
927 snprintf(buf, sizeof(buf), "ns %s found at %s", host, adr); | |
928 } | |
929 else { | |
930 snprintf(buf, sizeof(buf), "ns %s not found", host); | |
931 } | |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
932 my_syslog(&priv, buf); |
34 | 933 } |
934 if (ip) { | |
44 | 935 int_set::iterator i = ips.find(ip); |
936 if (i == ips.end()) { | |
937 ips.insert(ip); | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
938 status st = check_single(priv, ip, dc.content_suffix); |
44 | 939 if (st == reject) { |
53
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
940 string_map::iterator j = nameservers.ns_host.find(host); |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
941 if (j != nameservers.ns_host.end()) { |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
942 char *refer = (*j).second; |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
943 char buf[1000]; |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
944 snprintf(buf, sizeof(buf), "%s with nameserver %s", refer, host); |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
945 host = register_string(priv.memory->hosts, buf); // put a copy into priv.memory->hosts, and return that reference |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
946 } |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
947 else { |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
948 host = register_string(priv.memory->hosts, host); // put a copy into priv.memory->hosts, and return that reference |
c2371bb6cf84
3.5 - better error message when rejecting based on ns records on the sbl
carl
parents:
48
diff
changeset
|
949 } |
44 | 950 discard(nameservers); |
951 return st; | |
952 } | |
34 | 953 } |
954 } | |
955 } | |
956 discard(nameservers); | |
24 | 957 host = NULL; |
26 | 958 int bin = priv.memory->binary_tags; |
24 | 959 int bad = priv.memory->bad_html_tags; |
34 | 960 lim = priv.pc->tag_limit; |
41
d95af8129dfa
updates for 3.2, changing file layout, add queueid to messages
carl
parents:
40
diff
changeset
|
961 if (3*bin > bad) return oksofar; // probably .zip or .tar.gz with random content |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
962 if ((bad > lim) && (lim > 0)) return reject_tag; |
9 | 963 return oksofar; |
8 | 964 } |
965 | |
966 | |
967 //////////////////////////////////////////////// | |
0 | 968 // start of sendmail milter interfaces |
969 // | |
970 sfsistat mlfi_connect(SMFICTX *ctx, char *hostname, _SOCK_ADDR *hostaddr) | |
971 { | |
972 // allocate some private memory | |
973 mlfiPriv *priv = new mlfiPriv; | |
974 if (hostaddr->sa_family == AF_INET) { | |
975 priv->ip = ((struct sockaddr_in *)hostaddr)->sin_addr.s_addr; | |
976 } | |
977 | |
978 // save the private data | |
979 smfi_setpriv(ctx, (void*)priv); | |
980 | |
981 // continue processing | |
982 return SMFIS_CONTINUE; | |
983 } | |
984 | |
985 sfsistat mlfi_envfrom(SMFICTX *ctx, char **from) | |
986 { | |
987 mlfiPriv &priv = *MLFIPRIV; | |
988 priv.mailaddr = strdup(from[0]); | |
989 priv.authenticated = (smfi_getsymval(ctx, "{auth_authen}") != NULL); | |
990 return SMFIS_CONTINUE; | |
991 } | |
992 | |
993 sfsistat mlfi_envrcpt(SMFICTX *ctx, char **rcpt) | |
994 { | |
995 DNSBLP rejectlist = NULL; // list that caused the reject | |
996 status st = oksofar; | |
997 mlfiPriv &priv = *MLFIPRIV; | |
998 CONFIG &dc = *priv.pc; | |
42 | 999 if (!priv.queueid) priv.queueid = strdup(smfi_getsymval(ctx, "i")); |
0 | 1000 char *rcptaddr = rcpt[0]; |
1001 char *dnsname = lookup(rcptaddr, dc.env_to_dnsbll); | |
1002 char *fromname = lookup(rcptaddr, dc.env_to_chkfrom); | |
1003 if ((strcmp(dnsname, BLACK) == 0) || | |
1004 (strcmp(fromname, BLACK) == 0)) { | |
1005 st = black; // two options to blacklist this recipient | |
1006 } | |
1007 else if (strcmp(fromname, WHITE) == 0) { | |
1008 st = white; | |
1009 } | |
1010 else { | |
1011 // check an env_from map | |
1012 string_map *sm = find_from_map(dc, fromname); | |
1013 if (sm != NULL) { | |
1014 fromname = lookup(priv.mailaddr, *sm); // returns default if name not in map | |
1015 if (strcmp(fromname, BLACK) == 0) { | |
1016 st = black; // blacklist this envelope from value | |
1017 } | |
1018 if (strcmp(fromname, WHITE) == 0) { | |
1019 st = white; // blacklist this envelope from value | |
1020 } | |
1021 } | |
1022 } | |
1023 if ((st == oksofar) && (strcmp(dnsname, WHITE) != 0)) { | |
1024 // check dns lists | |
1025 st = check_dnsbl(priv, find_dnsbll(dc, dnsname), rejectlist); | |
1026 } | |
1027 | |
1028 if (st == reject) { | |
1029 // reject the recipient based on some dnsbl | |
1030 char adr[sizeof "255.255.255.255"]; | |
1031 adr[0] = '\0'; | |
8 | 1032 inet_ntop(AF_INET, (const u_char *)&priv.ip, adr, sizeof(adr)); |
0 | 1033 char buf[2000]; |
1034 snprintf(buf, sizeof(buf), rejectlist->message, adr, adr); | |
1035 smfi_setreply(ctx, "550", "5.7.1", buf); | |
1036 return SMFIS_REJECT; | |
1037 } | |
1038 else if (st == black) { | |
1039 // reject the recipient based on blacklisting either from or to | |
1040 smfi_setreply(ctx, "550", "5.7.1", "no such user"); | |
1041 return SMFIS_REJECT; | |
1042 } | |
1043 else { | |
1044 // accept the recipient | |
8 | 1045 if (st == oksofar) { |
1046 // but remember the non-whites | |
12 | 1047 register_string(priv.non_whites, rcptaddr); |
8 | 1048 priv.only_whites = false; |
1049 } | |
1050 if (st == white) { | |
1051 priv.have_whites = true; | |
1052 } | |
0 | 1053 return SMFIS_CONTINUE; |
1054 } | |
1055 } | |
1056 | |
8 | 1057 sfsistat mlfi_body(SMFICTX *ctx, u_char *data, size_t len) |
0 | 1058 { |
1059 mlfiPriv &priv = *MLFIPRIV; | |
55
44babba1a9b9
updates for 3.6, better documentation on removing content filtering, missing some files in cvs
carl
parents:
53
diff
changeset
|
1060 if (priv.authenticated) return SMFIS_CONTINUE; |
44babba1a9b9
updates for 3.6, better documentation on removing content filtering, missing some files in cvs
carl
parents:
53
diff
changeset
|
1061 if (priv.only_whites) return SMFIS_CONTINUE; |
44babba1a9b9
updates for 3.6, better documentation on removing content filtering, missing some files in cvs
carl
parents:
53
diff
changeset
|
1062 if (!priv.pc->content_suffix) return SMFIS_CONTINUE; |
8 | 1063 priv.scanner->scan(data, len); |
11 | 1064 return SMFIS_CONTINUE; |
8 | 1065 } |
1066 | |
1067 sfsistat mlfi_eom(SMFICTX *ctx) | |
1068 { | |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1069 sfsistat rc; |
8 | 1070 mlfiPriv &priv = *MLFIPRIV; |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1071 char *host = NULL; |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1072 int ip; |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1073 status st; |
8 | 1074 // process end of message |
55
44babba1a9b9
updates for 3.6, better documentation on removing content filtering, missing some files in cvs
carl
parents:
53
diff
changeset
|
1075 if (priv.authenticated || |
44babba1a9b9
updates for 3.6, better documentation on removing content filtering, missing some files in cvs
carl
parents:
53
diff
changeset
|
1076 priv.only_whites || |
44babba1a9b9
updates for 3.6, better documentation on removing content filtering, missing some files in cvs
carl
parents:
53
diff
changeset
|
1077 (!priv.pc->content_suffix) || |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1078 ((st=check_hosts(priv, host, ip)) == oksofar)) rc = SMFIS_CONTINUE; |
8 | 1079 else { |
1080 if (!priv.have_whites) { | |
1081 // can reject the entire message | |
1082 char buf[2000]; | |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1083 if (st == reject_tag) { |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1084 // rejected due to excessive bad html tags |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1085 snprintf(buf, sizeof(buf), priv.pc->tag_limit_message); |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1086 } |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1087 else if (st == reject_host) { |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1088 // rejected due to excessive unique host/urls |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1089 snprintf(buf, sizeof(buf), priv.pc->host_limit_message); |
24 | 1090 } |
1091 else { | |
1092 char adr[sizeof "255.255.255.255"]; | |
1093 adr[0] = '\0'; | |
1094 inet_ntop(AF_INET, (const u_char *)&ip, adr, sizeof(adr)); | |
1095 snprintf(buf, sizeof(buf), priv.pc->content_message, host, adr); | |
1096 } | |
8 | 1097 smfi_setreply(ctx, "550", "5.7.1", buf); |
1098 rc = SMFIS_REJECT; | |
1099 } | |
1100 else { | |
1101 // need to accept it but remove the recipients that don't want it | |
1102 for (string_set::iterator i=priv.non_whites.begin(); i!=priv.non_whites.end(); i++) { | |
1103 char *rcpt = *i; | |
1104 smfi_delrcpt(ctx, rcpt); | |
1105 } | |
1106 rc = SMFIS_CONTINUE; | |
1107 } | |
0 | 1108 } |
8 | 1109 // reset for a new message on the same connection |
1110 mlfi_abort(ctx); | |
1111 return rc; | |
1112 } | |
1113 | |
1114 sfsistat mlfi_abort(SMFICTX *ctx) | |
1115 { | |
1116 mlfiPriv &priv = *MLFIPRIV; | |
1117 priv.reset(); | |
0 | 1118 return SMFIS_CONTINUE; |
1119 } | |
1120 | |
1121 sfsistat mlfi_close(SMFICTX *ctx) | |
1122 { | |
1123 mlfiPriv *priv = MLFIPRIV; | |
1124 if (!priv) return SMFIS_CONTINUE; | |
1125 delete priv; | |
1126 smfi_setpriv(ctx, NULL); | |
1127 return SMFIS_CONTINUE; | |
1128 } | |
1129 | |
1130 struct smfiDesc smfilter = | |
1131 { | |
1132 "DNSBL", // filter name | |
1133 SMFI_VERSION, // version code -- do not change | |
1134 SMFIF_DELRCPT, // flags | |
1135 mlfi_connect, // connection info filter | |
1136 NULL, // SMTP HELO command filter | |
1137 mlfi_envfrom, // envelope sender filter | |
1138 mlfi_envrcpt, // envelope recipient filter | |
1139 NULL, // header filter | |
1140 NULL, // end of header | |
8 | 1141 mlfi_body, // body block filter |
1142 mlfi_eom, // end of message | |
1143 mlfi_abort, // message aborted | |
0 | 1144 mlfi_close, // connection cleanup |
1145 }; | |
1146 | |
1147 | |
1148 static void dumpit(char *name, string_map map); | |
1149 static void dumpit(char *name, string_map map) { | |
9 | 1150 fprintf(stdout, "\n"); |
0 | 1151 for (string_map::iterator i=map.begin(); i!=map.end(); i++) { |
9 | 1152 fprintf(stdout, "%s %s->%s\n", name, (*i).first, (*i).second); |
0 | 1153 } |
1154 } | |
1155 | |
1156 | |
1157 static void dumpit(from_map map); | |
1158 static void dumpit(from_map map) { | |
1159 for (from_map::iterator i=map.begin(); i!=map.end(); i++) { | |
3 | 1160 char buf[2000]; |
1161 snprintf(buf, sizeof(buf), "envelope from map for %s", (*i).first); | |
0 | 1162 string_map *sm = (*i).second; |
3 | 1163 dumpit(buf, *sm); |
0 | 1164 } |
1165 } | |
1166 | |
1167 | |
3 | 1168 static void dumpit(CONFIG &dc); |
1169 static void dumpit(CONFIG &dc) { | |
5 | 1170 dumpit(dc.env_from); |
1171 dumpit("envelope to (dnsbl list)", dc.env_to_dnsbll); | |
1172 dumpit("envelope to (from map)", dc.env_to_chkfrom); | |
9 | 1173 fprintf(stdout, "\ndnsbls\n"); |
0 | 1174 for (dnsblp_map::iterator i=dc.dnsbls.begin(); i!=dc.dnsbls.end(); i++) { |
9 | 1175 fprintf(stdout, "%s %s %s\n", (*i).first, (*i).second->suffix, (*i).second->message); |
0 | 1176 } |
9 | 1177 fprintf(stdout, "\ndnsbl_lists\n"); |
0 | 1178 for (dnsbllp_map::iterator i=dc.dnsblls.begin(); i!=dc.dnsblls.end(); i++) { |
1179 char *name = (*i).first; | |
1180 DNSBLL &dl = *((*i).second); | |
9 | 1181 fprintf(stdout, "%s", name); |
0 | 1182 for (DNSBLL::iterator j=dl.begin(); j!=dl.end(); j++) { |
1183 DNSBL &d = **j; | |
9 | 1184 fprintf(stdout, " %s", d.suffix); |
0 | 1185 } |
9 | 1186 fprintf(stdout, "\n"); |
0 | 1187 } |
9 | 1188 if (dc.content_suffix) { |
1189 fprintf(stdout, "\ncontent filtering enabled with %s %s\n", dc.content_suffix, dc.content_message); | |
1190 } | |
57 | 1191 for (string_set::iterator i=dc.content_host_ignore.begin(); i!=dc.content_host_ignore.end(); i++) { |
1192 fprintf(stdout, "ignore %s\n", (*i)); | |
1193 } | |
46 | 1194 if (dc.host_limit && !dc.host_random) { |
1195 fprintf(stdout, "\ncontent filtering for host names hard limit %d %s\n", dc.host_limit, dc.host_limit_message); | |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1196 } |
46 | 1197 if (dc.host_limit && dc.host_random) { |
1198 fprintf(stdout, "\ncontent filtering for host names soft limit %d\n", dc.host_limit); | |
44 | 1199 } |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1200 if (dc.tag_limit) { |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1201 fprintf(stdout, "\ncontent filtering for excessive html tags enabled with limit %d %s\n", dc.tag_limit, dc.tag_limit_message); |
24 | 1202 } |
9 | 1203 fprintf(stdout, "\nfiles\n"); |
3 | 1204 for (string_list::iterator i=dc.config_files.begin(); i!=dc.config_files.end(); i++) { |
1205 char *f = *i; | |
9 | 1206 fprintf(stdout, "config includes %s\n", f); |
3 | 1207 } |
1208 } | |
1209 | |
1210 | |
1211 //////////////////////////////////////////////// | |
1212 // check for redundant or recursive include files | |
1213 // | |
1214 static bool ok_to_include(CONFIG &dc, char *fn); | |
1215 static bool ok_to_include(CONFIG &dc, char *fn) { | |
1216 if (!fn) return false; | |
1217 bool ok = true; | |
1218 for (string_list::iterator i=dc.config_files.begin(); i!=dc.config_files.end(); i++) { | |
1219 char *f = *i; | |
1220 if (strcmp(f, fn) == 0) { | |
1221 my_syslog("redundant or recursive include file detected"); | |
1222 ok = false; | |
1223 break; | |
1224 } | |
1225 } | |
1226 return ok; | |
0 | 1227 } |
1228 | |
1229 | |
1230 //////////////////////////////////////////////// | |
1231 // load a single config file | |
1232 // | |
3 | 1233 static void load_conf_dcc(CONFIG &dc, char *name, char *fn); |
1234 static void load_conf_dcc(CONFIG &dc, char *name, char *fn) { | |
1235 ifstream is(fn); | |
40 | 1236 if (is.fail()) { |
1237 char buf[1000]; | |
1238 snprintf(buf, sizeof(buf), "include file %s not found", fn); | |
1239 my_syslog(buf); | |
1240 return; | |
1241 } | |
39 | 1242 dc.config_files.push_back(fn); |
1243 const int LINE_SIZE = 2000; | |
3 | 1244 char line[LINE_SIZE]; |
39 | 1245 char *list = BLACK; |
3 | 1246 char *delim = " \t"; |
1247 int curline = 0; | |
1248 while (!is.eof()) { | |
1249 is.getline(line, LINE_SIZE); | |
1250 curline++; | |
1251 int n = strlen(line); | |
1252 if (!n) continue; | |
1253 for (int i=0; i<n; i++) line[i] = tolower(line[i]); | |
1254 if (line[0] == '#') continue; | |
1255 char *head = line; | |
1256 if (strspn(line, delim) == 0) { | |
1257 // have a leading ok/many tag to fetch | |
1258 char *cmd = strtok(line, delim); | |
1259 if (strcmp(cmd, MANY) == 0) list = BLACK; | |
1260 else if (strcmp(cmd, OK) == 0) list = WHITE; | |
1261 head = cmd + strlen(cmd) + 1; | |
1262 } | |
1263 char *cmd = strtok(head, delim); | |
1264 if (!cmd) continue; | |
1265 if (strcmp(cmd, "env_from") == 0) { | |
1266 char *from = next_token(delim); | |
1267 if (from) { | |
1268 string_map &fm = really_find_from_map(dc, name); | |
1269 fm[from] = list; | |
1270 } | |
1271 } | |
1272 else if (strcmp(cmd, "env_to") == 0) { | |
1273 char *to = next_token(delim); | |
1274 if (to) { | |
1275 dc.env_to_dnsbll[to] = list; | |
1276 dc.env_to_chkfrom[to] = list; | |
1277 } | |
1278 } | |
1279 else if (strcmp(cmd, "substitute") == 0) { | |
1280 char *tag = next_token(delim); | |
1281 if (tag && (strcmp(tag, "mail_host") == 0)) { | |
1282 char *from = next_token(delim); | |
1283 if (from) { | |
1284 string_map &fm = really_find_from_map(dc, name); | |
1285 fm[from] = list; | |
1286 } | |
1287 } | |
1288 } | |
1289 else if (strcmp(cmd, "include") == 0) { | |
1290 char *fn = next_token(delim); | |
1291 if (ok_to_include(dc, fn)) { | |
1292 load_conf_dcc(dc, name, fn); | |
1293 } | |
1294 } | |
1295 | |
1296 } | |
1297 is.close(); | |
1298 } | |
1299 | |
1300 | |
0 | 1301 static void load_conf(CONFIG &dc, char *fn); |
1302 static void load_conf(CONFIG &dc, char *fn) { | |
39 | 1303 ifstream is(fn); |
40 | 1304 if (is.fail()) { |
1305 char buf[1000]; | |
1306 snprintf(buf, sizeof(buf), "include file %s not found", fn); | |
1307 my_syslog(buf); | |
1308 return; | |
1309 } | |
0 | 1310 dc.config_files.push_back(fn); |
1311 map<char*, int, ltstr> commands; | |
57 | 1312 enum {dummy, tld, content, ignore, hostlimit, hostslimit, htmllimit, htmltag, dnsbl, dnsbll, envfrom, envto, include, includedcc}; |
46 | 1313 commands["tld" ] = tld; |
1314 commands["content" ] = content; | |
57 | 1315 commands["ignore" ] = ignore; |
46 | 1316 commands["host_limit" ] = hostlimit; |
1317 commands["host_soft_limit"] = hostslimit; | |
1318 commands["html_limit" ] = htmllimit; | |
1319 commands["html_tag" ] = htmltag; | |
1320 commands["dnsbl" ] = dnsbl; | |
1321 commands["dnsbl_list" ] = dnsbll; | |
1322 commands["env_from" ] = envfrom; | |
1323 commands["env_to" ] = envto; | |
1324 commands["include" ] = include; | |
1325 commands["include_dcc" ] = includedcc; | |
0 | 1326 const int LINE_SIZE = 2000; |
1327 char line[LINE_SIZE]; | |
1328 char orig[LINE_SIZE]; | |
1329 char *delim = " \t"; | |
1330 int curline = 0; | |
1331 while (!is.eof()) { | |
1332 is.getline(line, LINE_SIZE); | |
1333 snprintf(orig, sizeof(orig), "%s", line); | |
1334 curline++; | |
1335 int n = strlen(line); | |
1336 for (int i=0; i<n; i++) line[i] = tolower(line[i]); | |
1337 char *cmd = strtok(line, delim); | |
1338 if (cmd && (cmd[0] != '#') && (cmd[0] != '\0')) { | |
1339 // have a decent command | |
1340 bool processed = false; | |
1341 switch (commands[cmd]) { | |
28 | 1342 case tld: { |
29
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1343 char *tld = next_token(delim); |
28 | 1344 if (!tld) break; // no tld value |
29
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1345 dc.tlds.insert(tld); |
28 | 1346 processed = true; |
1347 } break; | |
1348 | |
8 | 1349 case content: { |
1350 char *suff = strtok(NULL, delim); | |
24 | 1351 if (!suff) break; // no dns suffix |
8 | 1352 char *msg = suff + strlen(suff); |
1353 if ((msg - line) >= strlen(orig)) break; // line ended with the dns suffix | |
1354 msg = strchr(msg+1, '\''); | |
1355 if (!msg) break; // no reply message template | |
1356 msg++; // move over the leading ' | |
1357 if ((msg - line) >= strlen(orig)) break; // line ended with the leading quote | |
1358 char *last = strchr(msg, '\''); | |
1359 if (!last) break; // no trailing quote | |
1360 *last = '\0'; // make it a null terminator | |
1361 dc.content_suffix = register_string(suff); | |
1362 dc.content_message = register_string(msg); | |
1363 processed = true; | |
1364 } break; | |
1365 | |
57 | 1366 case ignore: { |
1367 char *host = next_token(delim); | |
1368 if (!host) break; | |
1369 dc.content_host_ignore.insert(host); | |
1370 processed = true; | |
1371 } break; | |
1372 | |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1373 case hostlimit: { |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1374 char *limit = strtok(NULL, delim); |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1375 if (!limit) break; // no integer limit |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1376 char *msg = limit + strlen(limit); |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1377 if ((msg - line) >= strlen(orig)) break; // line ended with the limit |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1378 msg = strchr(msg+1, '\''); |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1379 if (!msg) break; // no reply message template |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1380 msg++; // move over the leading ' |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1381 if ((msg - line) >= strlen(orig)) break; // line ended with the leading quote |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1382 char *last = strchr(msg, '\''); |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1383 if (!last) break; // no trailing quote |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1384 *last = '\0'; // make it a null terminator |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1385 dc.host_limit = atoi(limit); |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1386 dc.host_limit_message = register_string(msg); |
46 | 1387 dc.host_random = false; |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1388 processed = true; |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1389 } break; |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1390 |
46 | 1391 case hostslimit: { |
1392 char *limit = next_token(delim); | |
1393 if (!limit) break; // no integer limit | |
1394 dc.host_limit = atoi(limit); | |
44 | 1395 dc.host_random = true; |
1396 processed = true; | |
1397 } break; | |
1398 | |
24 | 1399 case htmllimit: { |
1400 char *limit = strtok(NULL, delim); | |
1401 if (!limit) break; // no integer limit | |
1402 char *msg = limit + strlen(limit); | |
1403 if ((msg - line) >= strlen(orig)) break; // line ended with the limit | |
1404 msg = strchr(msg+1, '\''); | |
1405 if (!msg) break; // no reply message template | |
1406 msg++; // move over the leading ' | |
1407 if ((msg - line) >= strlen(orig)) break; // line ended with the leading quote | |
1408 char *last = strchr(msg, '\''); | |
1409 if (!last) break; // no trailing quote | |
1410 *last = '\0'; // make it a null terminator | |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1411 dc.tag_limit = atoi(limit); |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1412 dc.tag_limit_message = register_string(msg); |
24 | 1413 processed = true; |
1414 } break; | |
1415 | |
1416 case htmltag: { | |
1417 char *tag = next_token(delim); | |
1418 if (!tag) break; // no html tag value | |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1419 dc.html_tags.insert(tag); // base version |
26 | 1420 char buf[200]; |
1421 snprintf(buf, sizeof(buf), "/%s", tag); | |
27
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1422 dc.html_tags.insert(register_string(buf)); // leading / |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1423 snprintf(buf, sizeof(buf), "%s/", tag); |
43a4f6b3e668
add configurable host name limit and bad html tag limits.
carl
parents:
26
diff
changeset
|
1424 dc.html_tags.insert(register_string(buf)); // trailing / |
24 | 1425 processed = true; |
1426 } break; | |
1427 | |
0 | 1428 case dnsbl: { |
1429 // have a new dnsbl to use | |
1430 char *name = next_token(delim); | |
1431 if (!name) break; // no name name | |
1432 if (find_dnsbl(dc, name)) break; // duplicate entry | |
1433 char *suff = strtok(NULL, delim); | |
1434 if (!suff) break; // no dns suffic | |
1435 char *msg = suff + strlen(suff); | |
1436 if ((msg - line) >= strlen(orig)) break; // line ended with the dns suffix | |
1437 msg = strchr(msg+1, '\''); | |
1438 if (!msg) break; // no reply message template | |
1439 msg++; // move over the leading ' | |
1440 if ((msg - line) >= strlen(orig)) break; // line ended with the leading quote | |
1441 char *last = strchr(msg, '\''); | |
1442 if (!last) break; // no trailing quote | |
1443 *last = '\0'; // make it a null terminator | |
1444 dc.dnsbls[name] = new DNSBL(register_string(suff), register_string(msg)); | |
1445 processed = true; | |
1446 } break; | |
1447 | |
1448 case dnsbll: { | |
1449 // define a new combination of dnsbls | |
1450 char *name = next_token(delim); | |
1451 if (!name) break; | |
1452 if (find_dnsbll(dc, name)) break; // duplicate entry | |
1453 char *list = next_token(delim); | |
1454 if (!list || (*list == '\0') || (*list == '#')) break; | |
1455 DNSBLLP d = new DNSBLL; | |
1456 DNSBLP p = find_dnsbl(dc, list); | |
1457 if (p) d->push_back(p); | |
1458 while (true) { | |
1459 list = next_token(delim); | |
1460 if (!list || (*list == '\0') || (*list == '#')) break; | |
1461 DNSBLP p = find_dnsbl(dc, list); | |
1462 if (p) d->push_back(p); | |
1463 } | |
1464 dc.dnsblls[name] = d; | |
1465 processed = true; | |
1466 } break; | |
1467 | |
1468 case envfrom: { | |
1469 // add an entry into the named string_map | |
1470 char *name = next_token(delim); | |
1471 if (!name) break; | |
1472 char *from = next_token(delim); | |
1473 if (!from) break; | |
1474 char *list = next_token(delim); | |
1475 if (!list) break; | |
1476 if ((strcmp(list, WHITE) == 0) || | |
1477 (strcmp(list, BLACK) == 0)) { | |
1478 string_map &fm = really_find_from_map(dc, name); | |
1479 fm[from] = list; | |
1480 processed = true; | |
1481 } | |
1482 else { | |
1483 // list may be the name of a previously defined from_map | |
1484 string_map *m = find_from_map(dc, list); | |
1485 if (m && (strcmp(list,name) != 0)) { | |
1486 string_map &pm = *m; | |
1487 string_map &fm = really_find_from_map(dc, name); | |
1488 fm.insert(pm.begin(), pm.end()); | |
1489 processed = true; | |
1490 } | |
1491 } | |
1492 } break; | |
1493 | |
1494 case envto: { | |
1495 // define the dnsbl_list and env_from maps to use for this recipient | |
1496 char *to = next_token(delim); | |
1497 if (!to) break; | |
1498 char *list = next_token(delim); | |
1499 if (!list) break; | |
1500 char *from = next_token(delim); | |
1501 if (!from) break; | |
1502 dc.env_to_dnsbll[to] = list; | |
1503 dc.env_to_chkfrom[to] = from; | |
1504 processed = true; | |
1505 } break; | |
1506 | |
1507 case include: { | |
1508 char *fn = next_token(delim); | |
3 | 1509 if (ok_to_include(dc, fn)) { |
1510 load_conf(dc, fn); | |
1511 processed = true; | |
1512 } | |
1513 } break; | |
1514 | |
1515 case includedcc: { | |
1516 char *name = next_token(delim); | |
1517 if (!name) break; | |
1518 char *fn = next_token(delim); | |
1519 if (ok_to_include(dc, fn)) { | |
1520 load_conf_dcc(dc, name, fn); | |
1521 processed = true; | |
0 | 1522 } |
1523 } break; | |
1524 | |
1525 default: { | |
1526 } break; | |
1527 } | |
1528 if (!processed) { | |
1529 pthread_mutex_lock(&syslog_mutex); | |
1530 openlog("dnsbl", LOG_PID, LOG_MAIL); | |
1531 syslog(LOG_ERR, "ignoring file %s line %d : %s\n", fn, curline, orig); | |
1532 closelog(); | |
1533 pthread_mutex_unlock(&syslog_mutex); | |
1534 } | |
1535 } | |
1536 } | |
1537 is.close(); | |
1538 } | |
1539 | |
1540 | |
1541 //////////////////////////////////////////////// | |
1542 // reload the config | |
1543 // | |
1544 static CONFIG* new_conf(); | |
1545 static CONFIG* new_conf() { | |
1546 CONFIG *newc = new CONFIG; | |
29
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1547 pthread_mutex_lock(&config_mutex); |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1548 newc->generation = generation++; |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1549 pthread_mutex_unlock(&config_mutex); |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1550 char buf[200]; |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1551 snprintf(buf, sizeof(buf), "loading configuration generation %d", newc->generation); |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1552 my_syslog(buf); |
0 | 1553 load_conf(*newc, "dnsbl.conf"); |
1554 newc->load_time = time(NULL); | |
1555 return newc; | |
1556 } | |
1557 | |
1558 | |
1559 //////////////////////////////////////////////// | |
1560 // thread to watch the old config files for changes | |
1561 // and reload when needed. we also cleanup old | |
1562 // configs whose reference count has gone to zero. | |
1563 // | |
1564 static void* config_loader(void *arg); | |
1565 static void* config_loader(void *arg) { | |
1566 typedef set<CONFIG *> configp_set; | |
1567 configp_set old_configs; | |
18 | 1568 while (loader_run) { |
0 | 1569 sleep(180); // look for modifications every 3 minutes |
18 | 1570 if (!loader_run) break; |
0 | 1571 CONFIG &dc = *config; |
1572 time_t then = dc.load_time; | |
1573 struct stat st; | |
1574 bool reload = false; | |
1575 for (string_list::iterator i=dc.config_files.begin(); i!=dc.config_files.end(); i++) { | |
1576 char *fn = *i; | |
1577 if (stat(fn, &st)) reload = true; // file disappeared | |
1578 else if (st.st_mtime > then) reload = true; // file modified | |
1579 if (reload) break; | |
1580 } | |
1581 if (reload) { | |
1582 CONFIG *newc = new_conf(); | |
1583 // replace the global config pointer | |
1584 pthread_mutex_lock(&config_mutex); | |
1585 CONFIG *old = config; | |
1586 config = newc; | |
1587 pthread_mutex_unlock(&config_mutex); | |
1588 if (old) old_configs.insert(old); | |
1589 } | |
1590 // now look for old configs with zero ref counts | |
1591 for (configp_set::iterator i=old_configs.begin(); i!=old_configs.end(); ) { | |
1592 CONFIG *old = *i; | |
1593 if (!old->reference_count) { | |
29
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1594 char buf[200]; |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1595 snprintf(buf, sizeof(buf), "freeing memory for old configuration generation %d", old->generation); |
4dfdf33f1db0
add syslog msg freeing memory, use bare tld names without leading period
carl
parents:
28
diff
changeset
|
1596 my_syslog(buf); |
0 | 1597 delete old; // destructor does all the work |
1598 old_configs.erase(i++); | |
1599 } | |
1600 else i++; | |
1601 } | |
1602 } | |
18 | 1603 return NULL; |
0 | 1604 } |
1605 | |
1606 | |
1607 static void usage(char *prog); | |
1608 static void usage(char *prog) | |
1609 { | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1610 fprintf(stderr, "Usage: %s [-d] [-c] -r port -p sm-sock-addr [-t timeout]\n", prog); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1611 fprintf(stderr, "where port is for the connection to our own dns resolver processes\n"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1612 fprintf(stderr, "where sm-sock-addr is for the connection to sendmail\n"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1613 fprintf(stderr, " and should be one of\n"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1614 fprintf(stderr, " inet:port@ip-address\n"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1615 fprintf(stderr, " local:local-domain-socket-file-name\n"); |
9 | 1616 fprintf(stderr, "-c will load and dump the config to stdout\n"); |
16 | 1617 fprintf(stderr, "-d will add some syslog debug messages\n"); |
0 | 1618 } |
1619 | |
1620 | |
42 | 1621 |
1622 static void setup_socket(char *sock); | |
1623 static void setup_socket(char *sock) { | |
1624 unlink(sock); | |
43 | 1625 // sockaddr_un addr; |
1626 // memset(&addr, '\0', sizeof addr); | |
1627 // addr.sun_family = AF_UNIX; | |
1628 // strncpy(addr.sun_path, sock, sizeof(addr.sun_path)-1); | |
1629 // int s = socket(AF_UNIX, SOCK_STREAM, 0); | |
1630 // bind(s, (sockaddr*)&addr, sizeof(addr)); | |
1631 // close(s); | |
42 | 1632 } |
1633 | |
1634 | |
0 | 1635 int main(int argc, char**argv) |
1636 { | |
3 | 1637 bool check = false; |
1638 bool setconn = false; | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1639 bool setreso = false; |
0 | 1640 int c; |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1641 const char *args = "r:p:t:hcd"; |
0 | 1642 extern char *optarg; |
1643 | |
1644 // Process command line options | |
1645 while ((c = getopt(argc, argv, args)) != -1) { | |
1646 switch (c) { | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1647 case 'r': |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1648 if (optarg == NULL || *optarg == '\0') { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1649 fprintf(stderr, "Illegal resolver socket: %s\n", optarg); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1650 exit(EX_USAGE); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1651 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1652 resolver_port = atoi(optarg); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1653 setreso = true; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1654 break; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1655 |
0 | 1656 case 'p': |
1657 if (optarg == NULL || *optarg == '\0') { | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1658 fprintf(stderr, "Illegal sendmail socket: %s\n", optarg); |
0 | 1659 exit(EX_USAGE); |
1660 } | |
1661 if (smfi_setconn(optarg) == MI_FAILURE) { | |
1662 fprintf(stderr, "smfi_setconn failed\n"); | |
1663 exit(EX_SOFTWARE); | |
1664 } | |
42 | 1665 if (strncasecmp(optarg, "unix:", 5) == 0) setup_socket(optarg + 5); |
1666 else if (strncasecmp(optarg, "local:", 6) == 0) setup_socket(optarg + 6); | |
3 | 1667 setconn = true; |
0 | 1668 break; |
1669 | |
1670 case 't': | |
1671 if (optarg == NULL || *optarg == '\0') { | |
1672 fprintf(stderr, "Illegal timeout: %s\n", optarg); | |
1673 exit(EX_USAGE); | |
1674 } | |
1675 if (smfi_settimeout(atoi(optarg)) == MI_FAILURE) { | |
1676 fprintf(stderr, "smfi_settimeout failed\n"); | |
1677 exit(EX_SOFTWARE); | |
1678 } | |
1679 break; | |
1680 | |
3 | 1681 case 'c': |
1682 check = true; | |
1683 break; | |
1684 | |
16 | 1685 case 'd': |
1686 debug_syslog = true; | |
1687 break; | |
1688 | |
0 | 1689 case 'h': |
1690 default: | |
1691 usage(argv[0]); | |
1692 exit(EX_USAGE); | |
1693 } | |
1694 } | |
5 | 1695 |
1696 if (check) { | |
1697 CONFIG &dc = *new_conf(); | |
1698 dumpit(dc); | |
1699 return 0; | |
1700 } | |
1701 | |
0 | 1702 if (!setconn) { |
1703 fprintf(stderr, "%s: Missing required -p argument\n", argv[0]); | |
1704 usage(argv[0]); | |
1705 exit(EX_USAGE); | |
1706 } | |
5 | 1707 |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1708 if (!setreso) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1709 fprintf(stderr, "%s: Missing required -r argument\n", argv[0]); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1710 usage(argv[0]); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1711 exit(EX_USAGE); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1712 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1713 |
0 | 1714 if (smfi_register(smfilter) == MI_FAILURE) { |
1715 fprintf(stderr, "smfi_register failed\n"); | |
1716 exit(EX_UNAVAILABLE); | |
1717 } | |
1718 | |
1719 // switch to background mode | |
1720 if (daemon(1,0) < 0) { | |
1721 fprintf(stderr, "daemon() call failed\n"); | |
1722 exit(EX_UNAVAILABLE); | |
1723 } | |
1724 | |
1725 // write the pid | |
1726 const char *pidpath = "/var/run/dnsbl.pid"; | |
1727 unlink(pidpath); | |
1728 FILE *f = fopen(pidpath, "w"); | |
1729 if (f) { | |
22 | 1730 #ifdef linux |
1731 // from a comment in the DCC source code: | |
1732 // Linux threads are broken. Signals given the | |
1733 // original process are delivered to only the | |
1734 // thread that happens to have that PID. The | |
1735 // sendmail libmilter thread that needs to hear | |
1736 // SIGINT and other signals does not, and that breaks | |
1737 // scripts that need to stop milters. | |
1738 // However, signaling the process group works. | |
0 | 1739 fprintf(f, "-%d\n", (u_int)getpgrp()); |
22 | 1740 #else |
1741 fprintf(f, "%d\n", (u_int)getpid()); | |
1742 #endif | |
0 | 1743 fclose(f); |
1744 } | |
1745 | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1746 // initialize the thread sync objects |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1747 pthread_mutex_init(&config_mutex, 0); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1748 pthread_mutex_init(&syslog_mutex, 0); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1749 pthread_mutex_init(&resolve_mutex, 0); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1750 pthread_mutex_init(&fd_pool_mutex, 0); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1751 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1752 #ifdef NS_PACKETSZ |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1753 // fork off the resolver listener process |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1754 pid_t child = fork(); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1755 if (child < 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1756 my_syslog("failed to create resolver listener process"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1757 exit(0); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1758 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1759 if (child == 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1760 // we are the child - dns resolver listener process |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1761 resolver_socket = socket(PF_INET, SOCK_STREAM, 0); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1762 if (resolver_socket < 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1763 my_syslog("child failed to create resolver socket"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1764 exit(0); // failed |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1765 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1766 sockaddr_in server; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1767 server.sin_family = AF_INET; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1768 server.sin_port = htons(resolver_port); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1769 server.sin_addr.s_addr = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1770 // set the socket options |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1771 int reuse_addr = 1; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1772 linger linger_opt; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1773 linger_opt.l_onoff = 0; // off |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1774 linger_opt.l_linger = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1775 setsockopt(resolver_socket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&reuse_addr), sizeof(reuse_addr)); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1776 setsockopt(resolver_socket, SOL_SOCKET, SO_LINGER, reinterpret_cast<char*>(&linger_opt), sizeof(linger_opt)); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1777 ///// set nonblocking mode |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1778 ///int dummy = 0; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1779 ///int flags = fcntl(resolver_socket, F_GETFL, dummy); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1780 ///if (flags >= 0) fcntl(resolver_socket, F_SETFL, flags | O_NONBLOCK); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1781 //try to bind the address to the socket. |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1782 if (bind(resolver_socket, (sockaddr *)&server, sizeof(server)) < 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1783 // bind failed |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1784 shutdown(resolver_socket, SHUT_RDWR); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1785 close(resolver_socket); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1786 my_syslog("child failed to bind resolver socket"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1787 exit(0); // failed |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1788 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1789 |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1790 //listen on the socket. |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1791 if (listen(resolver_socket, 10) < 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1792 // listen failed |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1793 shutdown(resolver_socket, SHUT_RDWR); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1794 close(resolver_socket); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1795 my_syslog("child failed to listen to the resolver socket"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1796 return -1; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1797 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1798 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1799 else { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1800 sleep(2); // allow child to get started |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1801 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1802 #endif |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1803 |
42 | 1804 // drop root privs |
1805 struct passwd *pw = getpwnam("dnsbl"); | |
1806 if (pw) { | |
48 | 1807 if (setgid(pw->pw_gid) == -1) { |
1808 my_syslog("failed to switch to group dnsbl"); | |
1809 } | |
42 | 1810 if (setuid(pw->pw_uid) == -1) { |
1811 my_syslog("failed to switch to user dnsbl"); | |
1812 } | |
1813 } | |
1814 | |
59
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1815 #ifdef NS_PACKETSZ |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1816 if (child == 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1817 while (true) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1818 sockaddr_in client; |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1819 socklen_t clientlen = sizeof(client); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1820 int s = accept(resolver_socket, (sockaddr *)&client, &clientlen); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1821 if (s > 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1822 // accept worked, it did not get cancelled before we could accept it |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1823 // fork off a process to handle this connection |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1824 int newchild = fork(); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1825 if (newchild == 0) { |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1826 // this is the worker process |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1827 my_syslog("child forked a worker process"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1828 process_resolver_requests(s); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1829 my_syslog("child terminated a worker process"); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1830 exit(0); |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1831 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1832 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1833 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1834 exit(0); // make sure we don't fall thru. |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1835 } |
510a511ad554
Add resolver processes to allow better performance on busy machines
carl
parents:
58
diff
changeset
|
1836 #endif |
48 | 1837 |
1838 // load the initial config | |
1839 config = new_conf(); | |
1840 | |
1841 // only create threads after the fork() in daemon | |
1842 pthread_t tid; | |
1843 if (pthread_create(&tid, 0, config_loader, 0)) | |
1844 my_syslog("failed to create config loader thread"); | |
1845 if (pthread_detach(tid)) | |
1846 my_syslog("failed to detach config loader thread"); | |
1847 | |
18 | 1848 time_t starting = time(NULL); |
1849 int rc = smfi_main(); | |
22 | 1850 if ((rc != MI_SUCCESS) && (time(NULL) > starting+5*60)) { |
18 | 1851 my_syslog("trying to restart after smfi_main()"); |
1852 loader_run = false; // eventually the config loader thread will terminate | |
1853 execvp(argv[0], argv); | |
1854 } | |
1855 exit((rc == MI_SUCCESS) ? 0 : EX_UNAVAILABLE); | |
0 | 1856 } |
8 | 1857 |