|
0
|
1 /* Distributed Checksum Clearinghouse |
|
|
2 * |
|
|
3 * server |
|
|
4 * |
|
|
5 * Copyright (c) 2008 by Rhyolite Software, LLC |
|
|
6 * |
|
|
7 * This agreement is not applicable to any entity which sells anti-spam |
|
|
8 * solutions to others or provides an anti-spam solution as part of a |
|
|
9 * security solution sold to other entities, or to a private network |
|
|
10 * which employs the DCC or uses data provided by operation of the DCC |
|
|
11 * but does not provide corresponding data to other users. |
|
|
12 * |
|
|
13 * Permission to use, copy, modify, and distribute this software without |
|
|
14 * changes for any purpose with or without fee is hereby granted, provided |
|
|
15 * that the above copyright notice and this permission notice appear in all |
|
|
16 * copies and any distributed versions or copies are either unchanged |
|
|
17 * or not called anything similar to "DCC" or "Distributed Checksum |
|
|
18 * Clearinghouse". |
|
|
19 * |
|
|
20 * Parties not eligible to receive a license under this agreement can |
|
|
21 * obtain a commercial license to use DCC by contacting Rhyolite Software |
|
|
22 * at sales@rhyolite.com. |
|
|
23 * |
|
|
24 * A commercial license would be for Distributed Checksum and Reputation |
|
|
25 * Clearinghouse software. That software includes additional features. This |
|
|
26 * free license for Distributed ChecksumClearinghouse Software does not in any |
|
|
27 * way grant permision to use Distributed Checksum and Reputation Clearinghouse |
|
|
28 * software |
|
|
29 * |
|
|
30 * THE SOFTWARE IS PROVIDED "AS IS" AND RHYOLITE SOFTWARE, LLC DISCLAIMS ALL |
|
|
31 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES |
|
|
32 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL RHYOLITE SOFTWARE, LLC |
|
|
33 * BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES |
|
|
34 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, |
|
|
35 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, |
|
|
36 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
|
|
37 * SOFTWARE. |
|
|
38 * |
|
|
39 * Rhyolite Software DCC 1.3.103-1.297 $Revision$ |
|
|
40 */ |
|
|
41 |
|
|
42 #include "dccd_defs.h" |
|
|
43 #include <signal.h> /* for Linux and SunOS */ |
|
|
44 #include <sys/uio.h> |
|
|
45 #include <sys/wait.h> |
|
|
46 #include "dcc_ifaddrs.h" |
|
|
47 |
|
|
48 DCC_EMSG dcc_emsg; |
|
|
49 |
|
|
50 static const char *homedir; |
|
|
51 static char *aargs[10]; |
|
|
52 static char **aarg = &aargs[0]; |
|
|
53 static DCC_PATH dbclean_def = DCC_LIBEXECDIR"/dbclean"; |
|
|
54 static char *dbclean = dbclean_def; |
|
|
55 static pid_t dbclean_pid = -1; |
|
|
56 static char *addr_str; /* an IP address for dbclean */ |
|
|
57 static char dbclean_str[] = "dbclean"; |
|
|
58 #define MAX_DBCLEAN_FLAGS 50 |
|
|
59 static char dbclean_flags[MAX_DBCLEAN_FLAGS+1] = "-Pq"; |
|
|
60 static int dbclean_flags_len = LITZ("-Pq"); |
|
|
61 static const char *dbclean_argv[20] = {dbclean_str, dbclean_flags}; |
|
|
62 static int dbclean_argc = 2; |
|
|
63 static char dbclean_args_str[200]; |
|
|
64 static int dbclean_args_str_len; |
|
|
65 |
|
|
66 /* do not try to run dbclean too often */ |
|
|
67 time_t dbclean_limit_secs = DBCLEAN_LIMIT_SECS; |
|
|
68 static time_t dbclean_failed; |
|
|
69 |
|
|
70 static double wfix_quiet_rate = 1.0; /* max load that allows window fixing */ |
|
|
71 static double wfix_busy_rate; /* measured active rate */ |
|
|
72 static double wfix_rate_change = 0.4; /* rate reduction to this allows fix */ |
|
|
73 static DB_PTR wfix_size; |
|
|
74 static u_char wfix_size_set = 0; |
|
|
75 DBCLEAN_WFIX_STATE dbclean_wfix_state = WFIX_DELAY; |
|
|
76 static double wfix_ops; |
|
|
77 static time_t wfix_check_start; |
|
|
78 static time_t dbclean_wfix_secs; /* window fixing timer */ |
|
|
79 #define WFIX_POST_CLEAN_SECS (6*60*60) /* do not fix it soon after cleaning */ |
|
|
80 #define WFIX_PRE_CLEAN_SECS (2*60*60) /* or just before cleaning */ |
|
|
81 #define WFIX_RECHECK_SECS (15*60) /* between checks for window overflow */ |
|
|
82 #define WFIX_QUIET_SECS (5*60) /* waiting for clients to flee */ |
|
|
83 #define WFIX_MEASURE_SECS (5*60) /* counting clients */ |
|
|
84 #define WFIX_MAX_SECS (WFIX_PRE_CLEAN_SECS+WFIX_POST_CLEAN_SECS) |
|
|
85 |
|
|
86 const char *need_del_dbclean; |
|
|
87 time_t del_dbclean_next; |
|
|
88 time_t dbclean_limit; |
|
|
89 static time_t clean_fake_secs; /* timer for missing cron job */ |
|
|
90 static time_t clean_last_secs; |
|
|
91 |
|
|
92 u_long dccd_tracemask = DCC_TRACE_ON_DEF_BITS; |
|
|
93 |
|
|
94 u_char background = 1; |
|
|
95 int stopint; /* !=0 if stopping or received signal */ |
|
|
96 |
|
|
97 static time_t flods_ck_secs = FLODS_CK_SECS; |
|
|
98 |
|
|
99 const char *brand = ""; |
|
|
100 |
|
|
101 static char *my_srvr_id_str; |
|
|
102 DCC_SRVR_ID my_srvr_id; |
|
|
103 |
|
|
104 u_char use_ipv6 = 0; |
|
|
105 u_int16_t def_port; /* default port #, network byte order */ |
|
|
106 typedef struct port_list { |
|
|
107 struct port_list *fwd; |
|
|
108 u_int16_t port; /* network byte order */ |
|
|
109 } PORT_LIST; |
|
|
110 static PORT_LIST *ports; |
|
|
111 SRVR_SOC *srvr_socs; |
|
|
112 static SRVR_SOC **srvr_socs_end = &srvr_socs; |
|
|
113 int srvr_rcvbuf = 1024*1024; |
|
|
114 |
|
|
115 #ifdef USE_DBCLEAN_F |
|
|
116 static u_char db_mode = DB_OPEN_MMAP_WRITE; |
|
|
117 #else |
|
|
118 static u_char db_mode = 0; |
|
|
119 #endif |
|
|
120 |
|
|
121 int grey_embargo = DEF_GREY_EMBARGO; /* seconds to delay new traffic */ |
|
|
122 int grey_window = DEF_GREY_WINDOW; /* wait as long as this */ |
|
|
123 int grey_white = DEF_GREY_WHITE; /* remember this long */ |
|
|
124 |
|
|
125 char our_hostname[MAXHOSTNAMELEN]; |
|
|
126 DCC_SUM host_id_sum; /* advertised with our server-ID */ |
|
|
127 time_t host_id_next, host_id_last; /* when to advertise */ |
|
|
128 |
|
|
129 u_char anon_off; /* turn off anonymous access */ |
|
|
130 time_t anon_delay_us = DCC_ANON_DELAY_US_DEF; /* delay anonymous clients */ |
|
|
131 u_int anon_delay_inflate = DCC_ANON_INFLATE_OFF; |
|
|
132 |
|
|
133 u_char stop_mode; /* 0=normal 1=reboot 2=with/DB clean */ |
|
|
134 |
|
|
135 static int total_ops; |
|
|
136 static QUEUE *queue_free; |
|
|
137 static QUEUE *queue_head; |
|
|
138 |
|
|
139 /* assume or hope we can handle 500 requests/second */ |
|
|
140 int queue_max = 500*DCC_MAX_RTT_SECS; /* ultimate bound on queue size */ |
|
|
141 static int queue_max_cur; /* current upper bound */ |
|
|
142 static int queue_cur; /* current queue size */ |
|
|
143 |
|
|
144 struct timeval wake_time; /* when we awoke from select() */ |
|
|
145 struct timeval req_recv_time; /* when request arrived */ |
|
|
146 |
|
|
147 DCC_TS future; /* timestamp sanity */ |
|
|
148 |
|
|
149 |
|
|
150 static DB_NOKEEP_CKS set_new_nokeep_cks, reset_new_nokeep_cks; |
|
|
151 |
|
|
152 DCC_TGTS flod_tholds[DCC_DIM_CKS]; /* flood at or after these thresholds */ |
|
|
153 |
|
|
154 static const char *parse_rl_rate(RL_RATE *, float, const char *, const char *); |
|
|
155 static void add_dbclean_flag(char); |
|
|
156 static void add_dbclean_arg(const char *); |
|
|
157 static void check_dbclean(int); |
|
|
158 static void run_dbclean(const char *, const char *); |
|
|
159 static void sigterm(int); |
|
|
160 static void sighup(int); |
|
|
161 static void stop_children(void); |
|
|
162 static u_char get_if_changes(u_char); |
|
|
163 static SRVR_SOC *add_srvr_soc(u_char, int, const void *, u_int16_t); |
|
|
164 static int open_srvr_socs(int); |
|
|
165 static void wfix_later(time_t); |
|
|
166 static void recv_job(void) NRATTRIB; |
|
|
167 static u_char new_job(SRVR_SOC *); |
|
|
168 static void NRATTRIB dccd_quit(int, const char *, ...) PATTRIB(2,3); |
|
|
169 |
|
|
170 static void |
|
|
171 usage(const char* barg) |
|
|
172 { |
|
|
173 static const char str[] = { |
|
|
174 "usage: [-64dVbfFQ] -i server-ID [-n brand] [-h homedir]\n" |
|
|
175 " [-I [host-ID][,user]] [-a [server-addr][,server-port]]" |
|
|
176 " [-q qsize]\n" |
|
|
177 " [-G [on,][weak-body,][weak-IP,]embargo],[window],[white]]\n" |
|
|
178 " [-W [rate][,chg][,dbsize]] [-K [no-]type] [-T tracemode]\n" |
|
|
179 " [-u anon-delay[,inflate] [-C dbclean]" |
|
|
180 " [-L ltype,facility.level]\n" |
|
|
181 " [-R [RL_SUB],[RL_FREE],[RL_ALL_FREE],[RL_BUGS]]" |
|
|
182 }; |
|
|
183 static u_char complained; |
|
|
184 |
|
|
185 if (!complained) { |
|
|
186 if (barg) |
|
|
187 dcc_error_msg("unrecognized \"%s\"\nusage: %s\n..." |
|
|
188 " continuing", |
|
|
189 barg, str); |
|
|
190 else |
|
|
191 dcc_error_msg("%s\n... continuing", str); |
|
|
192 complained = 1; |
|
|
193 } |
|
|
194 } |
|
|
195 |
|
|
196 |
|
|
197 int NRATTRIB |
|
|
198 main(int argc, char **argv) |
|
|
199 { |
|
|
200 char *p; |
|
|
201 const char *rest; |
|
|
202 u_char print_version = 0; |
|
|
203 DCC_CK_TYPES type; |
|
|
204 DCC_SOCKU *sup; |
|
|
205 u_int16_t port; |
|
|
206 int new_embargo, new_window, new_white; |
|
|
207 int error, i; |
|
|
208 const char *cp; |
|
|
209 double d1, d2; |
|
|
210 u_long l; |
|
|
211 |
|
|
212 dcc_syslog_init(1, argv[0], 0); |
|
|
213 |
|
|
214 if (DCC_DIM_CKS != DCC_COMP_DIM_CKS) |
|
|
215 dcc_logbad(EX_SOFTWARE, |
|
|
216 "DCC_DIM_CKS != DCC_COMP_DIM_CKS;" |
|
|
217 " check uses of both"); |
|
|
218 |
|
|
219 /* get first bytes of our hostname to name our server-ID */ |
|
|
220 memset(our_hostname, 0, sizeof(our_hostname)); |
|
|
221 if (0 > gethostname(our_hostname, sizeof(our_hostname)-1)) |
|
|
222 dcc_logbad(EX_NOHOST, "gethostname(): %s", ERROR_STR()); |
|
|
223 our_hostname[sizeof(our_hostname)-1] = '\0'; |
|
|
224 if (our_hostname[0] == '\0') |
|
|
225 dcc_logbad(EX_NOHOST, "null hostname from gethostname()"); |
|
|
226 strncpy((char *)host_id_sum, our_hostname, sizeof(host_id_sum)); |
|
|
227 |
|
|
228 parse_rl_rate(&rl_sub_rate, 0.5, "RL_SUB", "400"); |
|
|
229 parse_rl_rate(&rl_anon_rate, RL_AVG_SECS, "RL_ANON", "50"); |
|
|
230 parse_rl_rate(&rl_all_anon_rate, 0.5, "RL_ALL_ANON", "600"); |
|
|
231 parse_rl_rate(&rl_bugs_rate, RL_AVG_SECS, "RL_BUGS", "0.1"); |
|
|
232 |
|
|
233 /* this must match DCCD_GETOPTS in cron-dccd.in */ |
|
|
234 while ((i = getopt(argc, argv, |
|
|
235 "64dVbfFQi:n:h:a:I:q:G:t:W:K:T:u:C:L:R:")) != -1) { |
|
|
236 switch (i) { |
|
|
237 case '6': |
|
|
238 #ifndef NO_IPV6 |
|
|
239 use_ipv6 = 2; |
|
|
240 #endif |
|
|
241 break; |
|
|
242 case '4': |
|
|
243 use_ipv6 = 0; |
|
|
244 break; |
|
|
245 |
|
|
246 case 'd': |
|
|
247 add_dbclean_flag('d'); |
|
|
248 ++db_debug; |
|
|
249 break; |
|
|
250 |
|
|
251 case 'V': |
|
|
252 fprintf(stderr, DCC_VERSION"\n"); |
|
|
253 print_version = 1; |
|
|
254 break; |
|
|
255 |
|
|
256 case 'b': |
|
|
257 background = 0; |
|
|
258 break; |
|
|
259 |
|
|
260 case 'f': |
|
|
261 db_mode &= ~DB_OPEN_MMAP_WRITE; |
|
|
262 add_dbclean_flag('f'); |
|
|
263 break; |
|
|
264 |
|
|
265 case 'F': |
|
|
266 db_mode |= DB_OPEN_MMAP_WRITE; |
|
|
267 add_dbclean_flag('F'); |
|
|
268 break; |
|
|
269 |
|
|
270 case 'Q': |
|
|
271 query_only = 1; |
|
|
272 break; |
|
|
273 |
|
|
274 case 'i': |
|
|
275 my_srvr_id_str = optarg; |
|
|
276 if (!dcc_get_srvr_id(dcc_emsg, &my_srvr_id, |
|
|
277 my_srvr_id_str, 0, 0, 0)) |
|
|
278 dcc_logbad(dcc_ex_code, "%s", dcc_emsg); |
|
|
279 add_dbclean_arg("-i"); |
|
|
280 add_dbclean_arg(my_srvr_id_str); |
|
|
281 break; |
|
|
282 |
|
|
283 case 'n': |
|
|
284 /* RFC 2822 says "values between 33 and 126" */ |
|
|
285 cp = optarg; |
|
|
286 while (*cp >= 33 && *cp <= 126 && *cp != ':') |
|
|
287 ++cp; |
|
|
288 if (cp == optarg |
|
|
289 || (cp - optarg) > ISZ(DCC_BRAND) |
|
|
290 || *cp != '\0') { |
|
|
291 dcc_error_msg("invalid brand name \"-n %s\"", |
|
|
292 optarg); |
|
|
293 } else { |
|
|
294 brand = optarg; |
|
|
295 } |
|
|
296 break; |
|
|
297 |
|
|
298 case 'h': |
|
|
299 homedir = optarg; |
|
|
300 /* tell dbclean "-h ." because we will already |
|
|
301 * be there and that allows our -h to be relative */ |
|
|
302 add_dbclean_arg("-h."); |
|
|
303 break; |
|
|
304 |
|
|
305 case 'I': |
|
|
306 p = strchr(optarg, ','); |
|
|
307 if (p) { |
|
|
308 *p++ = '\0'; |
|
|
309 dcc_daemon_su(p); |
|
|
310 if (*optarg == '\0') |
|
|
311 break; |
|
|
312 } |
|
|
313 if (*optarg != '\0') |
|
|
314 strncpy((char *)host_id_sum, optarg, |
|
|
315 sizeof(host_id_sum)); |
|
|
316 break; |
|
|
317 |
|
|
318 case 'a': |
|
|
319 /* postpone checking host names until we know -6 */ |
|
|
320 if (aarg > LAST(aargs)) { |
|
|
321 dcc_error_msg("too many -a args"); |
|
|
322 break; |
|
|
323 } |
|
|
324 optarg += strspn(optarg, DCC_WHITESPACE); |
|
|
325 *aarg++ = optarg; |
|
|
326 break; |
|
|
327 |
|
|
328 case 'q': |
|
|
329 l = strtoul(optarg, &p, 10); |
|
|
330 if (*p != '\0' || l < 2 || l > 1000) { |
|
|
331 dcc_error_msg("invalid queue length \"%s\"", |
|
|
332 optarg); |
|
|
333 } else { |
|
|
334 queue_max = l; |
|
|
335 } |
|
|
336 break; |
|
|
337 |
|
|
338 case 'G': |
|
|
339 grey_on = 1; |
|
|
340 dcc_syslog_init(1, argv[0], " grey"); |
|
|
341 add_dbclean_arg("-Gon"); |
|
|
342 /* handle leading "on" "weak-body", and "weak-IP" */ |
|
|
343 rest = optarg; |
|
|
344 while (*rest) { |
|
|
345 if (dcc_ck_word_comma(&rest, "weak-body") |
|
|
346 || dcc_ck_word_comma(&rest, "weak_body") |
|
|
347 || dcc_ck_word_comma(&rest, "weak")) { |
|
|
348 grey_weak_body = 1; |
|
|
349 continue; |
|
|
350 } |
|
|
351 if (dcc_ck_word_comma(&rest, "weak-IP") |
|
|
352 || dcc_ck_word_comma(&rest, "weak_IP")) { |
|
|
353 grey_weak_ip = 1; |
|
|
354 continue; |
|
|
355 } |
|
|
356 if (!dcc_ck_word_comma(&rest, "on")) |
|
|
357 break; |
|
|
358 } |
|
|
359 new_embargo = dcc_get_secs(rest, &rest, |
|
|
360 0, MAX_GREY_EMBARGO, |
|
|
361 grey_embargo); |
|
|
362 if (new_embargo < 0) { |
|
|
363 dcc_error_msg("invalid greylist embargo" |
|
|
364 " \"-G %s\"", optarg); |
|
|
365 break; |
|
|
366 } |
|
|
367 new_window = dcc_get_secs(rest, &rest, |
|
|
368 new_embargo, MAX_GREY_WINDOW, |
|
|
369 max(new_embargo,grey_window)); |
|
|
370 if (new_window < 0) { |
|
|
371 dcc_error_msg("invalid greylist wait time" |
|
|
372 " \"-G %s\"", optarg); |
|
|
373 break; |
|
|
374 } |
|
|
375 new_white = dcc_get_secs(rest, &rest, |
|
|
376 new_window, MAX_GREY_WHITE, |
|
|
377 max(new_window, grey_white)); |
|
|
378 if (new_white < 0 || *rest != '\0') { |
|
|
379 dcc_error_msg("invalid greylist whitelist time" |
|
|
380 " \"-G %s\"", optarg); |
|
|
381 break; |
|
|
382 } |
|
|
383 grey_embargo = new_embargo; |
|
|
384 grey_window = new_window; |
|
|
385 grey_white = new_white; |
|
|
386 break; |
|
|
387 |
|
|
388 case 't': /* obsolete */ |
|
|
389 break; |
|
|
390 |
|
|
391 case 'W': |
|
|
392 p = optarg; |
|
|
393 if (*p == '\0') { |
|
|
394 dcc_error_msg("unrecognized" |
|
|
395 " \"-W %s\"", optarg); |
|
|
396 break; |
|
|
397 } |
|
|
398 d1 = wfix_quiet_rate; |
|
|
399 if (*p != '\0' && *p != ',') { |
|
|
400 d1 = strtod(p, &p); |
|
|
401 if ((*p != '\0' && *p != ',') |
|
|
402 || d1 < 0.0 || d1 > 1000*1000.0) { |
|
|
403 dcc_error_msg("bad quiet rate in" |
|
|
404 " \"-W %s\"", optarg); |
|
|
405 break; |
|
|
406 } |
|
|
407 } |
|
|
408 if (*p == ',') |
|
|
409 ++p; |
|
|
410 d2 = wfix_rate_change; |
|
|
411 if (*p != '\0' && *p != ',') { |
|
|
412 d1 = strtod(p, &p); |
|
|
413 if ((*p != '\0' && *p != ',') |
|
|
414 || d1 < 0.0 || d1 > 1000*1000.0) { |
|
|
415 dcc_error_msg("bad rate change in" |
|
|
416 " \"-W %s\"", optarg); |
|
|
417 break; |
|
|
418 } |
|
|
419 } |
|
|
420 if (*p == ',') |
|
|
421 ++p; |
|
|
422 l = wfix_size/(1024*1024); |
|
|
423 if (*p != '\0') { |
|
|
424 l = strtoul(p, &p, 10); |
|
|
425 if ((*p != '\0' || l < DB_MIN_MIN_MBYTE |
|
|
426 || l > MAX_MAX_DB_MBYTE) |
|
|
427 && l != wfix_size) { |
|
|
428 dcc_error_msg("bad database size in" |
|
|
429 " \"-W %s\"", optarg); |
|
|
430 break; |
|
|
431 } |
|
|
432 } |
|
|
433 wfix_quiet_rate = d1; |
|
|
434 wfix_rate_change = d2; |
|
|
435 if (wfix_size/(1024*1024) != l) { |
|
|
436 wfix_size = ((DB_PTR)l)*(1024*1024); |
|
|
437 wfix_size_set = 1; |
|
|
438 } |
|
|
439 break; |
|
|
440 |
|
|
441 case 'K': |
|
|
442 if (!strcasecmp(optarg, "all")) { |
|
|
443 reset_new_nokeep_cks = -1; |
|
|
444 break; |
|
|
445 } |
|
|
446 if (!CLITCMP(optarg, "no-")) { |
|
|
447 optarg += LITZ("no-"); |
|
|
448 i = 0; |
|
|
449 } else { |
|
|
450 i = 1; |
|
|
451 } |
|
|
452 type = dcc_str2type_db(optarg, -1); |
|
|
453 if (type == DCC_CK_INVALID) { |
|
|
454 dcc_error_msg("bad checksum type in" |
|
|
455 " \"-K %s\"", optarg); |
|
|
456 break; |
|
|
457 } |
|
|
458 if (i) |
|
|
459 DB_SET_NOKEEP(reset_new_nokeep_cks, type); |
|
|
460 else |
|
|
461 DB_SET_NOKEEP(set_new_nokeep_cks, type); |
|
|
462 break; |
|
|
463 |
|
|
464 case 'T': |
|
|
465 if (!strcasecmp(optarg, "ADMN")) { |
|
|
466 dccd_tracemask |= DCC_TRACE_ADMN_BIT; |
|
|
467 } else if (!strcasecmp(optarg, "ANON")) { |
|
|
468 dccd_tracemask |= DCC_TRACE_ANON_BIT; |
|
|
469 } else if (!strcasecmp(optarg, "CLNT")) { |
|
|
470 dccd_tracemask |= DCC_TRACE_CLNT_BIT; |
|
|
471 } else if (!strcasecmp(optarg, "RLIM")) { |
|
|
472 dccd_tracemask |= DCC_TRACE_RLIM_BIT; |
|
|
473 } else if (!strcasecmp(optarg, "QUERY")) { |
|
|
474 dccd_tracemask |= DCC_TRACE_QUERY_BIT; |
|
|
475 } else if (!strcasecmp(optarg, "RIDC")) { |
|
|
476 dccd_tracemask |= DCC_TRACE_RIDC_BIT; |
|
|
477 } else if (!strcasecmp(optarg, "FLOOD")) { |
|
|
478 dccd_tracemask |= DCC_TRACE_FLOD_BIT; |
|
|
479 } else if (!strcasecmp(optarg, "FLOOD2")) { |
|
|
480 dccd_tracemask |= DCC_TRACE_FLOD2_BIT; |
|
|
481 } else if (!strcasecmp(optarg, "IDS")) { |
|
|
482 dccd_tracemask |= DCC_TRACE_IDS_BIT; |
|
|
483 } else if (!strcasecmp(optarg, "BL")) { |
|
|
484 dccd_tracemask |= DCC_TRACE_BL_BIT; |
|
|
485 } else if (!strcasecmp(optarg, "DB")) { |
|
|
486 dccd_tracemask |= DCC_TRACE_DB_BIT; |
|
|
487 } else if (!strcasecmp(optarg, "WLIST")) { |
|
|
488 dccd_tracemask |= DCC_TRACE_WLIST_BIT; |
|
|
489 } else { |
|
|
490 dcc_error_msg("invalid trace mode \"%s\"", |
|
|
491 optarg); |
|
|
492 } |
|
|
493 break; |
|
|
494 |
|
|
495 case 'u': |
|
|
496 i = parse_dccd_delay(dcc_emsg, &anon_delay_us, |
|
|
497 &anon_delay_inflate, optarg, |
|
|
498 0, 0); |
|
|
499 if (!i) { |
|
|
500 dcc_error_msg("%s", dcc_emsg); |
|
|
501 } else if (i == 2) { |
|
|
502 anon_off = 1; |
|
|
503 } else { |
|
|
504 anon_off = 0; |
|
|
505 } |
|
|
506 break; |
|
|
507 |
|
|
508 case 'C': |
|
|
509 if (*optarg == '\0') { |
|
|
510 dcc_error_msg("no path to dbclean \"-C %s\"", |
|
|
511 optarg); |
|
|
512 break; |
|
|
513 } |
|
|
514 /* capture the path to the dbclean program */ |
|
|
515 dbclean = optarg; |
|
|
516 /* capture any args following the program */ |
|
|
517 for (p = strpbrk(optarg, DCC_WHITESPACE); |
|
|
518 p != 0; |
|
|
519 p = strpbrk(p, DCC_WHITESPACE)) { |
|
|
520 *p++ = '\0'; |
|
|
521 p += strspn(p, DCC_WHITESPACE); |
|
|
522 if (*p == '\0') |
|
|
523 break; |
|
|
524 add_dbclean_arg(p); |
|
|
525 } |
|
|
526 break; |
|
|
527 |
|
|
528 case 'L': |
|
|
529 if (dcc_parse_log_opt(optarg)) { |
|
|
530 add_dbclean_arg("-L"); |
|
|
531 add_dbclean_arg(optarg); |
|
|
532 } |
|
|
533 break; |
|
|
534 |
|
|
535 case 'R': |
|
|
536 rest = parse_rl_rate(&rl_sub_rate, -1.0, |
|
|
537 "RL_SUB", optarg); |
|
|
538 rest = parse_rl_rate(&rl_anon_rate, -1.0, |
|
|
539 "RL_ANON", rest); |
|
|
540 rest = parse_rl_rate(&rl_all_anon_rate, -1.0, |
|
|
541 "RL_ALL_ANON", rest); |
|
|
542 rest = parse_rl_rate(&rl_bugs_rate, -1.0, |
|
|
543 "RL_BUGS", rest); |
|
|
544 break; |
|
|
545 |
|
|
546 default: |
|
|
547 usage(optopt2str(optopt)); |
|
|
548 } |
|
|
549 } |
|
|
550 argc -= optind; |
|
|
551 argv += optind; |
|
|
552 if (argc != 0) |
|
|
553 usage(argv[0]); |
|
|
554 |
|
|
555 if (my_srvr_id == DCC_ID_INVALID) { |
|
|
556 if (print_version) |
|
|
557 exit(EX_OK); |
|
|
558 dcc_logbad(EX_USAGE, "server-ID not set with -i"); |
|
|
559 } |
|
|
560 |
|
|
561 if (grey_on) { |
|
|
562 anon_off = 1; |
|
|
563 dccd_tracemask |= DCC_TRACE_IDS_BIT; |
|
|
564 } |
|
|
565 |
|
|
566 /* parse addresses after we know whether -6 was among the args */ |
|
|
567 for (aarg = &aargs[0]; aarg <= LAST(aargs) && *aarg; ++aarg) { |
|
|
568 char hostname[DCC_MAXDOMAINLEN]; |
|
|
569 |
|
|
570 addr_str = *aarg; |
|
|
571 rest = dcc_parse_nm_port(dcc_emsg, *aarg, 0, |
|
|
572 hostname, sizeof(hostname), |
|
|
573 &port, 0, 0, 0, 0); |
|
|
574 if (!rest) { |
|
|
575 dcc_error_msg("%s", dcc_emsg); |
|
|
576 continue; |
|
|
577 } |
|
|
578 rest += strspn(rest, DCC_WHITESPACE); |
|
|
579 if (*rest != '\0') |
|
|
580 dcc_error_msg("unrecognized port number in" |
|
|
581 "\"-a %s\"", *aarg); |
|
|
582 if (hostname[0] == '\0') { |
|
|
583 PORT_LIST *pport = dcc_malloc(sizeof(*pport)); |
|
|
584 pport->port = port; |
|
|
585 pport->fwd = ports; |
|
|
586 ports = pport; |
|
|
587 continue; |
|
|
588 } |
|
|
589 if (!strcmp(hostname, "@")) { |
|
|
590 ++addr_str; /* "" but not a const */ |
|
|
591 add_srvr_soc(SRVR_SOC_ADDR, AF_UNSPEC, 0, port); |
|
|
592 continue; |
|
|
593 } |
|
|
594 dcc_host_lock(); |
|
|
595 if (!dcc_get_host(hostname, use_ipv6 ? 2 : 0, &error)) { |
|
|
596 dcc_host_unlock(); |
|
|
597 dcc_error_msg("%s: %s", |
|
|
598 *aarg, DCC_HSTRERROR(error)); |
|
|
599 continue; |
|
|
600 } |
|
|
601 for (sup = dcc_hostaddrs; sup < dcc_hostaddrs_end; ++sup) { |
|
|
602 if (sup->sa.sa_family == AF_INET) |
|
|
603 add_srvr_soc(SRVR_SOC_ADDR, AF_INET, |
|
|
604 &sup->ipv4.sin_addr, port); |
|
|
605 else |
|
|
606 add_srvr_soc(SRVR_SOC_ADDR, AF_INET6, |
|
|
607 &sup->ipv6.sin6_addr, port); |
|
|
608 } |
|
|
609 dcc_host_unlock(); |
|
|
610 } |
|
|
611 if (addr_str) { |
|
|
612 /* tell dbclean about one "-a addr" */ |
|
|
613 add_dbclean_arg("-a"); |
|
|
614 add_dbclean_arg(addr_str); |
|
|
615 } |
|
|
616 |
|
|
617 dcc_clnt_unthread_init(); |
|
|
618 if (!dcc_cdhome(dcc_emsg, homedir, 0)) |
|
|
619 dcc_logbad(dcc_ex_code, "%s", dcc_emsg); |
|
|
620 |
|
|
621 i = check_load_ids(1); |
|
|
622 if (i < 0) |
|
|
623 dcc_logbad(dcc_ex_code, "%s", dcc_emsg); |
|
|
624 else if (!i) |
|
|
625 dcc_error_msg("%s", dcc_emsg); |
|
|
626 |
|
|
627 if (!def_port) |
|
|
628 def_port = DCC_GREY2PORT(grey_on); |
|
|
629 if (!srvr_socs && !ports) { |
|
|
630 ports = dcc_malloc(sizeof(*ports)); |
|
|
631 ports->fwd = 0; |
|
|
632 ports->port = def_port; |
|
|
633 } |
|
|
634 get_if_changes(db_debug != 0); |
|
|
635 |
|
|
636 /* make initial attempt to open the server UDP sockets |
|
|
637 * This also sets use_ipv6 to 0 or 1 if it is still 2 */ |
|
|
638 if (open_srvr_socs(45) <= 0) |
|
|
639 dcc_logbad(EX_OSERR, "failed to open any server sockets"); |
|
|
640 |
|
|
641 add_dbclean_flag(use_ipv6 == 0 ? '4' : '6'); |
|
|
642 |
|
|
643 if (background) { |
|
|
644 if (0 > daemon(1, 0)) |
|
|
645 dcc_logbad(EX_OSERR, "daemon(): %s", ERROR_STR()); |
|
|
646 } |
|
|
647 |
|
|
648 if (!background) |
|
|
649 signal(SIGHUP, sigterm); /* SIGHUP fatal during debugging */ |
|
|
650 else |
|
|
651 signal(SIGHUP, sighup); /* speed configuration check */ |
|
|
652 signal(SIGTERM, sigterm); |
|
|
653 signal(SIGINT, sigterm); |
|
|
654 signal(SIGPIPE, SIG_IGN); |
|
|
655 #ifdef SIGXFSZ |
|
|
656 signal(SIGXFSZ, SIG_IGN); |
|
|
657 #endif |
|
|
658 |
|
|
659 atexit(stop_children); |
|
|
660 |
|
|
661 gettimeofday(&db_time, 0); |
|
|
662 wake_time = db_time; |
|
|
663 |
|
|
664 flod_mmap_path_set(); |
|
|
665 |
|
|
666 /* open the database, and try once to fix it */ |
|
|
667 if (!dccd_db_open(DB_OPEN_LOCK_NOWAIT)) { |
|
|
668 dcc_error_msg("%s", dcc_emsg); |
|
|
669 run_dbclean("SRbad", "database initially broken"); |
|
|
670 check_dbclean(0); /* stall until dbclean finishes */ |
|
|
671 if (!dccd_db_open(DB_OPEN_LOCK_NOWAIT)) { |
|
|
672 dcc_error_msg("%s", dcc_emsg); |
|
|
673 dcc_logbad(EX_NOINPUT, |
|
|
674 "could not start database %s", db_nm); |
|
|
675 } |
|
|
676 } |
|
|
677 /* do not start if dbclean is running */ |
|
|
678 if (!lock_dbclean(dcc_emsg, db_nm)) |
|
|
679 dcc_logbad(dcc_ex_code, "%s: dbclean already running?", |
|
|
680 dcc_emsg); |
|
|
681 unlock_dbclean(); |
|
|
682 |
|
|
683 flod_trace_gen = db_time.tv_sec; |
|
|
684 host_id_next = db_time.tv_sec + DCC_SRVR_ID_SECS_ST; |
|
|
685 check_blacklist_file(); |
|
|
686 flods_init(); |
|
|
687 clients_load(); |
|
|
688 stats_clear(); |
|
|
689 if (flod_mmaps != 0 |
|
|
690 && flod_mmaps->dccd_stats.reset.tv_sec != 0) { |
|
|
691 memcpy(&dccd_stats, &flod_mmaps->dccd_stats, |
|
|
692 sizeof(dccd_stats)); |
|
|
693 } |
|
|
694 dcc_trace_msg(DCC_VERSION" listening to port %d %s %s", |
|
|
695 ntohs(srvr_socs->arg_port), |
|
|
696 dcc_homedir, db_window_size_str); |
|
|
697 |
|
|
698 recv_job(); |
|
|
699 } |
|
|
700 |
|
|
701 |
|
|
702 |
|
|
703 static SRVR_SOC * /* 0 or new entry */ |
|
|
704 add_srvr_soc(u_char flags, |
|
|
705 int family, /* AF_UNSPEC or 0 if addrp==0 */ |
|
|
706 const void *addrp, /* 0, *in_addr, or *in6_addr */ |
|
|
707 u_int16_t port) |
|
|
708 { |
|
|
709 DCC_SOCKU su; |
|
|
710 SRVR_SOC *sp; |
|
|
711 |
|
|
712 dcc_mk_su(&su, family, addrp, port); |
|
|
713 for (sp = srvr_socs; sp; sp = sp->fwd) { |
|
|
714 if (sp->arg_family == family |
|
|
715 && sp->arg_port == port |
|
|
716 && !memcmp(&sp->arg_addr, addrp, |
|
|
717 ((family == AF_INET) |
|
|
718 ? sizeof(sp->arg_addr.in4) |
|
|
719 : sizeof(sp->arg_addr.in6)))) |
|
|
720 return sp; |
|
|
721 } |
|
|
722 |
|
|
723 sp = dcc_malloc(sizeof(*sp)); |
|
|
724 memset(sp, 0, sizeof(*sp)); |
|
|
725 sp->flags = flags; |
|
|
726 sp->udp = -1; |
|
|
727 sp->listen = -1; |
|
|
728 sp->su = su; |
|
|
729 sp->arg_family = family; |
|
|
730 if (addrp) |
|
|
731 memcpy(&sp->arg_addr, addrp, |
|
|
732 ((family == AF_INET) |
|
|
733 ? sizeof(sp->arg_addr.in4) |
|
|
734 : sizeof(sp->arg_addr.in6))); |
|
|
735 sp->arg_port = port; |
|
|
736 |
|
|
737 *srvr_socs_end = sp; |
|
|
738 srvr_socs_end = &sp->fwd; |
|
|
739 |
|
|
740 return sp; |
|
|
741 } |
|
|
742 |
|
|
743 |
|
|
744 |
|
|
745 static int /* # of sockets opened */ |
|
|
746 open_srvr_socs(int retry_secs) |
|
|
747 { |
|
|
748 static u_char srvr_rcvbuf_set = 0; |
|
|
749 int *retry_secsp; |
|
|
750 u_char family; |
|
|
751 SRVR_SOC *sp; |
|
|
752 int i; |
|
|
753 int num_socs = 0; |
|
|
754 |
|
|
755 if (stopint) |
|
|
756 return -1; |
|
|
757 |
|
|
758 retry_secsp = retry_secs ? &retry_secs : 0; |
|
|
759 |
|
|
760 for (sp = srvr_socs; sp; sp = sp->fwd) { |
|
|
761 if (sp->udp >= 0) { |
|
|
762 ++num_socs; |
|
|
763 continue; |
|
|
764 } |
|
|
765 |
|
|
766 /* resolve default port number if we finally know it */ |
|
|
767 if (!sp->arg_port) |
|
|
768 sp->arg_port = def_port; |
|
|
769 |
|
|
770 family = sp->arg_family; |
|
|
771 |
|
|
772 /* create the UDP socket |
|
|
773 * If we are using INADDR_ANY |
|
|
774 * and do not yet know if IPv6 works, just try it */ |
|
|
775 if (family == AF_UNSPEC |
|
|
776 && use_ipv6 == 2) { |
|
|
777 dcc_mk_su(&sp->su, AF_INET6, |
|
|
778 &sp->arg_addr, sp->arg_port); |
|
|
779 i = dcc_udp_bind(dcc_emsg, &sp->udp, |
|
|
780 &sp->su, retry_secsp); |
|
|
781 if (i == 0) { |
|
|
782 dcc_error_msg("%s", dcc_emsg); |
|
|
783 /* still don't know about IPv6 */ |
|
|
784 continue; |
|
|
785 } |
|
|
786 if (i > 0) { |
|
|
787 /* we finished an INADDR_ANY socket |
|
|
788 * and learned that IPv6 works */ |
|
|
789 use_ipv6 = 1; |
|
|
790 continue; |
|
|
791 } |
|
|
792 /* we know or guess that IPv6 does not work */ |
|
|
793 use_ipv6 = 0; |
|
|
794 } |
|
|
795 |
|
|
796 if (family == AF_UNSPEC) { |
|
|
797 /* using INADDR_ANY but now know whether IPv6 works */ |
|
|
798 family = use_ipv6 ? AF_INET6 : AF_INET; |
|
|
799 } else if (family == AF_INET6 && use_ipv6 == 2) { |
|
|
800 /* don't know if IPv6 works but have an IPv6 address */ |
|
|
801 use_ipv6 = 1; |
|
|
802 } |
|
|
803 |
|
|
804 dcc_mk_su(&sp->su, family, &sp->arg_addr, sp->arg_port); |
|
|
805 if (0 >= dcc_udp_bind(dcc_emsg, &sp->udp, |
|
|
806 &sp->su, retry_secsp)) { |
|
|
807 dcc_error_msg("%s", dcc_emsg); |
|
|
808 continue; |
|
|
809 } |
|
|
810 |
|
|
811 /* set socket receive buffer size as large as possible */ |
|
|
812 for (;;) { |
|
|
813 if (!setsockopt(sp->udp, SOL_SOCKET, SO_RCVBUF, |
|
|
814 &srvr_rcvbuf, sizeof(srvr_rcvbuf))) |
|
|
815 break; |
|
|
816 if (srvr_rcvbuf_set || srvr_rcvbuf <= 4096) { |
|
|
817 dcc_error_msg("setsockopt(%s,SO_RCVBUF=%d): %s", |
|
|
818 dcc_su2str_err(&sp->su), |
|
|
819 srvr_rcvbuf, |
|
|
820 ERROR_STR()); |
|
|
821 break; |
|
|
822 } |
|
|
823 srvr_rcvbuf -= 4096; |
|
|
824 } |
|
|
825 srvr_rcvbuf_set = 1; |
|
|
826 |
|
|
827 ++num_socs; |
|
|
828 } |
|
|
829 |
|
|
830 /* Finally decide the IPv6 issue if we found no sign of IPv6 */ |
|
|
831 if (use_ipv6 == 2) |
|
|
832 use_ipv6 = 0; |
|
|
833 |
|
|
834 return num_socs; |
|
|
835 } |
|
|
836 |
|
|
837 |
|
|
838 |
|
|
839 /* get ready to bind to all local IP addreses */ |
|
|
840 static u_char /* 1=added an interface */ |
|
|
841 add_ifs(u_char not_quiet) |
|
|
842 { |
|
|
843 u_char added; |
|
|
844 SRVR_SOC *sp; |
|
|
845 PORT_LIST *pport; |
|
|
846 #ifdef HAVE_GETIFADDRS |
|
|
847 struct ifaddrs *ifap0, *ifap; |
|
|
848 int num_ifs; |
|
|
849 #endif |
|
|
850 |
|
|
851 if (!ports) |
|
|
852 return 0; |
|
|
853 |
|
|
854 added = 0; |
|
|
855 |
|
|
856 #ifdef HAVE_GETIFADDRS |
|
|
857 if (0 > getifaddrs(&ifap0)) { |
|
|
858 dcc_error_msg("getifaddrs(): %s", ERROR_STR()); |
|
|
859 ifap0 = 0; |
|
|
860 } |
|
|
861 |
|
|
862 num_ifs = 0; |
|
|
863 for (pport = ports; pport; pport = pport->fwd) { |
|
|
864 const SRVR_SOC *listener = 0; |
|
|
865 |
|
|
866 for (ifap = ifap0; ifap; ifap = ifap->ifa_next) { |
|
|
867 if (!(ifap->ifa_flags & IFF_UP)) |
|
|
868 continue; |
|
|
869 if (!ifap->ifa_addr) |
|
|
870 continue; |
|
|
871 switch (ifap->ifa_addr->sa_family) { |
|
|
872 case AF_INET: |
|
|
873 ++num_ifs; |
|
|
874 sp = add_srvr_soc(SRVR_SOC_IF | SRVR_SOC_NEW, |
|
|
875 ifap->ifa_addr->sa_family, |
|
|
876 &((struct sockaddr_in *)ifap |
|
|
877 ->ifa_addr)->sin_addr, |
|
|
878 pport->port); |
|
|
879 break; |
|
|
880 case AF_INET6: |
|
|
881 if (use_ipv6 == 0) |
|
|
882 continue; |
|
|
883 if (use_ipv6 == 2) |
|
|
884 use_ipv6 = 1; |
|
|
885 ++num_ifs; |
|
|
886 sp = add_srvr_soc(SRVR_SOC_IF | SRVR_SOC_NEW, |
|
|
887 ifap->ifa_addr->sa_family, |
|
|
888 &((struct sockaddr_in6*)ifap |
|
|
889 ->ifa_addr)->sin6_addr, |
|
|
890 pport->port); |
|
|
891 break; |
|
|
892 default: |
|
|
893 continue; |
|
|
894 } |
|
|
895 if (sp->flags & SRVR_SOC_NEW) { |
|
|
896 added = 1; |
|
|
897 if (not_quiet) |
|
|
898 dcc_trace_msg("start listening on %s", |
|
|
899 dcc_su2str_err(&sp->su)); |
|
|
900 } |
|
|
901 sp->flags &= ~(SRVR_SOC_MARK | SRVR_SOC_NEW); |
|
|
902 |
|
|
903 /* interfaces can have duplicate addresses */ |
|
|
904 if (listener == sp) |
|
|
905 continue; |
|
|
906 if (!listener) { |
|
|
907 listener = sp; |
|
|
908 if (!(sp->flags & SRVR_SOC_LISTEN)) { |
|
|
909 sp->flags |= SRVR_SOC_LISTEN; |
|
|
910 added = 1; |
|
|
911 } |
|
|
912 } else { |
|
|
913 if (sp->flags & SRVR_SOC_LISTEN) { |
|
|
914 sp->flags &= ~SRVR_SOC_LISTEN; |
|
|
915 added = 1; |
|
|
916 } |
|
|
917 } |
|
|
918 } |
|
|
919 } |
|
|
920 #ifdef HAVE_FREEIFADDRS |
|
|
921 /* since this is done only a few times when HAVE_FREEIFADDRS is not |
|
|
922 * defined, don't worry if we cannot release the list of interfaces */ |
|
|
923 freeifaddrs(ifap0); |
|
|
924 #endif |
|
|
925 |
|
|
926 if (num_ifs > 0) |
|
|
927 return added; |
|
|
928 #endif /* HAVE_GETIFADDRS */ |
|
|
929 |
|
|
930 /* if we got no joy from getifaddrs(), use INADDR_ANY */ |
|
|
931 for (pport = ports; pport; pport = pport->fwd) { |
|
|
932 sp = add_srvr_soc(SRVR_SOC_IF | SRVR_SOC_LISTEN | SRVR_SOC_NEW, |
|
|
933 AF_UNSPEC, 0, pport->port); |
|
|
934 if (sp->flags & SRVR_SOC_NEW) { |
|
|
935 added = 1; |
|
|
936 if (not_quiet) |
|
|
937 dcc_trace_msg("fallback listen on %s", |
|
|
938 dcc_su2str_err(&sp->su)); |
|
|
939 } |
|
|
940 sp->flags &= ~(SRVR_SOC_MARK | SRVR_SOC_NEW); |
|
|
941 } |
|
|
942 |
|
|
943 return added; |
|
|
944 } |
|
|
945 |
|
|
946 |
|
|
947 |
|
|
948 /* deal with changes to network interfaces */ |
|
|
949 static u_char /* 1=something changed */ |
|
|
950 get_if_changes(u_char not_quiet) |
|
|
951 { |
|
|
952 SRVR_SOC *sp, **spp; |
|
|
953 u_char changed; |
|
|
954 |
|
|
955 for (sp = srvr_socs; sp; sp = sp->fwd) { |
|
|
956 if (sp->flags & SRVR_SOC_IF) |
|
|
957 sp->flags |= SRVR_SOC_MARK; |
|
|
958 } |
|
|
959 |
|
|
960 changed = add_ifs(not_quiet); |
|
|
961 |
|
|
962 spp = &srvr_socs; |
|
|
963 while ((sp = *spp) != 0) { |
|
|
964 /* an interface recognized by add_srvr_soc() will have |
|
|
965 * its SRVR_SOC_MARK cleared */ |
|
|
966 if (!(sp->flags & SRVR_SOC_MARK)) { |
|
|
967 spp = &sp->fwd; |
|
|
968 continue; |
|
|
969 } |
|
|
970 |
|
|
971 /* forget interfaces that have disappeared */ |
|
|
972 dcc_trace_msg("stop listening on %s", dcc_su2str_err(&sp->su)); |
|
|
973 changed = 1; |
|
|
974 if (srvr_socs_end == &sp->fwd) |
|
|
975 srvr_socs_end = spp; |
|
|
976 *spp = sp->fwd; |
|
|
977 if (sp->udp >= 0) |
|
|
978 close(sp->udp); |
|
|
979 if (sp->listen >= 0) |
|
|
980 close(sp->listen); |
|
|
981 dcc_free(sp); |
|
|
982 } |
|
|
983 |
|
|
984 return changed; |
|
|
985 } |
|
|
986 |
|
|
987 |
|
|
988 |
|
|
989 static const char * |
|
|
990 parse_rl_rate(RL_RATE *rate, float penalty_secs, |
|
|
991 const char *label, const char *arg) |
|
|
992 { |
|
|
993 char *p; |
|
|
994 int per_sec, hi; |
|
|
995 |
|
|
996 if (penalty_secs >= 0.0) |
|
|
997 rate->penalty_secs = penalty_secs; |
|
|
998 |
|
|
999 if (*arg == '\0') |
|
|
1000 return arg; |
|
|
1001 |
|
|
1002 if (*arg == ',') |
|
|
1003 return ++arg; |
|
|
1004 |
|
|
1005 per_sec = strtod(arg, &p) * RL_SCALE; |
|
|
1006 hi = per_sec*RL_AVG_SECS; |
|
|
1007 if ((*p != '\0' && *p != ',') |
|
|
1008 || hi < RL_SCALE || per_sec > RL_MAX_CREDITS) { |
|
|
1009 dcc_error_msg("invalid %s value in \"%s\"", |
|
|
1010 label, arg); |
|
|
1011 return ""; |
|
|
1012 } |
|
|
1013 |
|
|
1014 /* maximum events/second * RL_SCALE */ |
|
|
1015 rate->per_sec = per_sec; |
|
|
1016 |
|
|
1017 /* maximum allowed accumulated credits */ |
|
|
1018 rate->hi = hi; |
|
|
1019 |
|
|
1020 /* minimum credit account balance */ |
|
|
1021 rate->lo = -per_sec * rate->penalty_secs; |
|
|
1022 |
|
|
1023 return (*p == ',') ? p+1 : p; |
|
|
1024 } |
|
|
1025 |
|
|
1026 |
|
|
1027 |
|
|
1028 static void |
|
|
1029 add_dbclean_flag(char flag) |
|
|
1030 { |
|
|
1031 if (dbclean_flags_len >= MAX_DBCLEAN_FLAGS) |
|
|
1032 dcc_logbad(EX_SOFTWARE, "too many flags for dbclean"); |
|
|
1033 dbclean_flags[dbclean_flags_len++] = flag; |
|
|
1034 } |
|
|
1035 |
|
|
1036 |
|
|
1037 |
|
|
1038 static void |
|
|
1039 add_dbclean_arg(const char *arg) |
|
|
1040 { |
|
|
1041 int i; |
|
|
1042 |
|
|
1043 if (dbclean_argc >= DIM(dbclean_argv)-2) |
|
|
1044 dcc_logbad(EX_SOFTWARE, "too many args for dbclean"); |
|
|
1045 dbclean_argv[dbclean_argc++] = arg; |
|
|
1046 i = snprintf(dbclean_args_str+dbclean_args_str_len, |
|
|
1047 sizeof(dbclean_args_str)-dbclean_args_str_len, |
|
|
1048 " %s", arg); |
|
|
1049 dbclean_args_str_len += i; |
|
|
1050 if (dbclean_args_str_len >= ISZ(dbclean_args_str)-2) |
|
|
1051 dcc_logbad(EX_SOFTWARE, "too many args for dbclean"); |
|
|
1052 } |
|
|
1053 |
|
|
1054 |
|
|
1055 |
|
|
1056 /* check effort to repair database */ |
|
|
1057 static void |
|
|
1058 check_dbclean(int options) |
|
|
1059 { |
|
|
1060 int status; |
|
|
1061 pid_t pid; |
|
|
1062 u_char ok; |
|
|
1063 |
|
|
1064 if (dbclean_pid < 0) |
|
|
1065 return; |
|
|
1066 |
|
|
1067 pid = waitpid(dbclean_pid, &status, options); |
|
|
1068 if (pid != dbclean_pid) |
|
|
1069 return; |
|
|
1070 |
|
|
1071 dbclean_pid = -1; |
|
|
1072 |
|
|
1073 /* do not try failing dbclean too often */ |
|
|
1074 #if defined(WIFEXITED) && defined(WEXITSTATUS) && defined(WTERMSIG) && defined(WIFSIGNALED) |
|
|
1075 ok = 1; |
|
|
1076 if (WIFSIGNALED(status)) { |
|
|
1077 dcc_error_msg("dbclean exited with signal %d", |
|
|
1078 WTERMSIG(status)); |
|
|
1079 ok = 0; |
|
|
1080 } else if (WIFEXITED(status)) { |
|
|
1081 status = WEXITSTATUS(status); |
|
|
1082 if (status != EX_OK) { |
|
|
1083 if (status > 100 && status < 130) |
|
|
1084 dcc_error_msg("dbclean stopped after signal %d", |
|
|
1085 status-100); |
|
|
1086 else |
|
|
1087 dcc_error_msg("dbclean exited with status %d", |
|
|
1088 status); |
|
|
1089 ok = 0; |
|
|
1090 } |
|
|
1091 } |
|
|
1092 #else |
|
|
1093 ok = (status == EX_OK); |
|
|
1094 #endif |
|
|
1095 if (ok) { |
|
|
1096 dbclean_failed = 0; |
|
|
1097 dbclean_limit_secs = DBCLEAN_LIMIT_SECS; |
|
|
1098 } else { |
|
|
1099 dbclean_failed = db_time.tv_sec; |
|
|
1100 dbclean_limit_secs *= 2; |
|
|
1101 if (dbclean_limit_secs > DEL_DBCLEAN_SECS) |
|
|
1102 dbclean_limit_secs = DEL_DBCLEAN_SECS; |
|
|
1103 } |
|
|
1104 |
|
|
1105 /* don't restart dbclean until after it has stopped running |
|
|
1106 * and cooled for a while */ |
|
|
1107 dbclean_limit = db_time.tv_sec + dbclean_limit_secs; |
|
|
1108 } |
|
|
1109 |
|
|
1110 |
|
|
1111 |
|
|
1112 /* try to repair the database */ |
|
|
1113 static void |
|
|
1114 run_dbclean(const char *mode, /* combination of '', R, S, and W */ |
|
|
1115 const char *reason) |
|
|
1116 { |
|
|
1117 int i; |
|
|
1118 |
|
|
1119 check_dbclean(0); /* wait until previous ends */ |
|
|
1120 |
|
|
1121 wfix_later(WFIX_RECHECK_SECS); |
|
|
1122 |
|
|
1123 i = snprintf(&dbclean_flags[dbclean_flags_len], |
|
|
1124 ISZ(dbclean_flags)-dbclean_flags_len, "%s", |
|
|
1125 mode); |
|
|
1126 if (i+dbclean_flags_len >= ISZ(dbclean_flags)) |
|
|
1127 dcc_logbad(EX_SOFTWARE, "too many flags for dbclean"); |
|
|
1128 |
|
|
1129 dbclean_pid = fork(); |
|
|
1130 if (dbclean_pid < 0) { |
|
|
1131 dcc_error_msg("dbclean fork(): %s", ERROR_STR()); |
|
|
1132 } else if (dbclean_pid == 0) { |
|
|
1133 dcc_trace_msg("%s; starting `%s %s%s`", |
|
|
1134 reason, dbclean, dbclean_flags, dbclean_args_str); |
|
|
1135 execv(dbclean, (char **)dbclean_argv); |
|
|
1136 dcc_error_msg("execv(%s %s%s): %s", |
|
|
1137 dbclean, dbclean_flags, dbclean_args_str, |
|
|
1138 ERROR_STR()); |
|
|
1139 exit(-1); |
|
|
1140 } |
|
|
1141 |
|
|
1142 need_del_dbclean = 0; |
|
|
1143 dbclean_limit = db_time.tv_sec + dbclean_limit_secs; |
|
|
1144 } |
|
|
1145 |
|
|
1146 |
|
|
1147 |
|
|
1148 static void |
|
|
1149 close_srvr_socs(void) |
|
|
1150 { |
|
|
1151 SRVR_SOC *sp; |
|
|
1152 |
|
|
1153 for (sp = srvr_socs; sp; sp = sp->fwd) { |
|
|
1154 if (sp->udp >= 0) { |
|
|
1155 close(sp->udp); |
|
|
1156 sp->udp = -1; |
|
|
1157 } |
|
|
1158 iflod_listen_close(sp); |
|
|
1159 } |
|
|
1160 } |
|
|
1161 |
|
|
1162 |
|
|
1163 |
|
|
1164 /* close files and otherwise clean up after being forked as a helper */ |
|
|
1165 void |
|
|
1166 after_fork(void) |
|
|
1167 { |
|
|
1168 IFLOD_INFO *ifp; |
|
|
1169 OFLOD_INFO *ofp; |
|
|
1170 |
|
|
1171 resolve_hosts_pid = -1; |
|
|
1172 dbclean_pid = -1; |
|
|
1173 |
|
|
1174 close_srvr_socs(); |
|
|
1175 for (ifp = iflods.infos; ifp <= LAST(iflods.infos); ++ifp) { |
|
|
1176 if (ifp->soc >= 0) |
|
|
1177 close(ifp->soc); |
|
|
1178 } |
|
|
1179 for (ofp = oflods.infos; ofp <= LAST(oflods.infos); ++ofp) { |
|
|
1180 if (ofp->soc >= 0) |
|
|
1181 close(ofp->soc); |
|
|
1182 } |
|
|
1183 |
|
|
1184 signal(SIGHUP, SIG_DFL); |
|
|
1185 signal(SIGTERM, SIG_DFL); |
|
|
1186 signal(SIGINT, SIG_DFL); |
|
|
1187 signal(SIGPIPE, SIG_DFL); |
|
|
1188 #ifdef SIGXFSZ |
|
|
1189 signal(SIGXFSZ, SIG_DFL); |
|
|
1190 #endif |
|
|
1191 } |
|
|
1192 |
|
|
1193 |
|
|
1194 |
|
|
1195 /* do not worry about cleaning to fix a window overflow for a while */ |
|
|
1196 static void |
|
|
1197 wfix_later(time_t delay) |
|
|
1198 { |
|
|
1199 dbclean_wfix_state = WFIX_DELAY; |
|
|
1200 dbclean_wfix_secs = db_time.tv_sec + delay; |
|
|
1201 } |
|
|
1202 |
|
|
1203 |
|
|
1204 |
|
|
1205 static double |
|
|
1206 wfix_measure(u_char force) |
|
|
1207 { |
|
|
1208 double secs; |
|
|
1209 |
|
|
1210 secs = db_time.tv_sec - wfix_check_start; |
|
|
1211 if (force || secs <= 0.0 || secs > WFIX_MEASURE_SECS*2 |
|
|
1212 || total_ops < wfix_ops) { |
|
|
1213 wfix_check_start = db_time.tv_sec; |
|
|
1214 dbclean_wfix_secs = db_time.tv_sec + WFIX_MEASURE_SECS; |
|
|
1215 wfix_ops = total_ops; |
|
|
1216 return -1.0; |
|
|
1217 } |
|
|
1218 return (total_ops - wfix_ops) / secs; |
|
|
1219 } |
|
|
1220 |
|
|
1221 |
|
|
1222 |
|
|
1223 static u_char /* 1=need dbclean now */ |
|
|
1224 wfix(char *reason, u_int reason_len) |
|
|
1225 { |
|
|
1226 double rate; |
|
|
1227 struct timeval sn; |
|
|
1228 time_t next_clean; |
|
|
1229 |
|
|
1230 /* stop everything if dbclean is running */ |
|
|
1231 if (db_minimum_map || wfix_quiet_rate <= 0.0) { |
|
|
1232 wfix_later(WFIX_RECHECK_SECS); |
|
|
1233 return 0; |
|
|
1234 } |
|
|
1235 |
|
|
1236 switch (dbclean_wfix_state) { |
|
|
1237 case WFIX_DELAY: /* just checking */ |
|
|
1238 if (!DB_IS_TIME(dbclean_wfix_secs, WFIX_MAX_SECS)) |
|
|
1239 return 0; |
|
|
1240 |
|
|
1241 /* no quick cleaning soon after the database was created, |
|
|
1242 * cleaned or repaired */ |
|
|
1243 dcc_ts2timeval(&sn, &db_parms.sn); |
|
|
1244 if (sn.tv_sec > db_time.tv_sec) |
|
|
1245 sn.tv_sec = 0; |
|
|
1246 if (sn.tv_sec < dbclean_failed |
|
|
1247 && dbclean_failed <= db_time.tv_sec) |
|
|
1248 sn.tv_sec = dbclean_failed; |
|
|
1249 if (sn.tv_sec <= db_time.tv_sec) { |
|
|
1250 dbclean_wfix_secs = sn.tv_sec + WFIX_POST_CLEAN_SECS; |
|
|
1251 if (!DB_IS_TIME(dbclean_wfix_secs, WFIX_MAX_SECS)) |
|
|
1252 return 0; |
|
|
1253 } |
|
|
1254 |
|
|
1255 /* check later if dbclean might run soon */ |
|
|
1256 next_clean = clean_fake_secs; |
|
|
1257 if (db_time.tv_sec >= next_clean - WFIX_PRE_CLEAN_SECS) { |
|
|
1258 dbclean_wfix_secs = next_clean + WFIX_POST_CLEAN_SECS; |
|
|
1259 if (!DB_IS_TIME(dbclean_wfix_secs, WFIX_MAX_SECS)) |
|
|
1260 return 0; |
|
|
1261 } |
|
|
1262 next_clean = clean_last_secs + 24*60*60; |
|
|
1263 if (db_time.tv_sec >= next_clean - WFIX_PRE_CLEAN_SECS) { |
|
|
1264 dbclean_wfix_secs = next_clean + WFIX_POST_CLEAN_SECS; |
|
|
1265 if (!DB_IS_TIME(dbclean_wfix_secs, WFIX_MAX_SECS)) |
|
|
1266 return 0; |
|
|
1267 } |
|
|
1268 |
|
|
1269 /* check later if the database is not too large now */ |
|
|
1270 if (db_fsize + db_hash_fsize |
|
|
1271 < (wfix_size_set ? wfix_size : db_max_rss)) { |
|
|
1272 wfix_later(WFIX_RECHECK_SECS); |
|
|
1273 break; |
|
|
1274 } |
|
|
1275 /* the database is too big, so try to chase the clients |
|
|
1276 * to the other DCC server (if any) */ |
|
|
1277 dbclean_wfix_state = WFIX_BUSY; |
|
|
1278 wfix_measure(1); |
|
|
1279 break; |
|
|
1280 |
|
|
1281 case WFIX_BUSY: |
|
|
1282 rate = wfix_measure(0); |
|
|
1283 if (rate >= 0.0) { |
|
|
1284 wfix_busy_rate = rate; |
|
|
1285 dbclean_wfix_state = WFIX_QUIET; |
|
|
1286 dbclean_wfix_secs = db_time.tv_sec + WFIX_QUIET_SECS; |
|
|
1287 } |
|
|
1288 break; |
|
|
1289 |
|
|
1290 case WFIX_QUIET: /* waiting for clients to flee */ |
|
|
1291 dbclean_wfix_state = WFIX_CHECK; |
|
|
1292 wfix_measure(1); |
|
|
1293 break; |
|
|
1294 |
|
|
1295 case WFIX_CHECK: /* counting clients */ |
|
|
1296 rate = wfix_measure(0); |
|
|
1297 if (rate < 0.0) |
|
|
1298 break; |
|
|
1299 if (rate <= wfix_quiet_rate |
|
|
1300 || rate <= wfix_busy_rate * wfix_rate_change) { |
|
|
1301 snprintf(reason, reason_len, |
|
|
1302 "database size "L_DPAT">"L_DPAT |
|
|
1303 "; load changed from %0.1f to %0.1f", |
|
|
1304 db_fsize + db_hash_fsize, |
|
|
1305 wfix_size_set ? wfix_size : db_max_rss, |
|
|
1306 wfix_busy_rate, rate); |
|
|
1307 return 1; |
|
|
1308 } |
|
|
1309 /* Other DCC servers did not take over the load. Maybe later */ |
|
|
1310 if (db_debug) |
|
|
1311 dcc_trace_msg("database size "L_DPAT" > "L_DPAT |
|
|
1312 ", but load changed from %0.1f to %0.1f", |
|
|
1313 db_fsize + db_hash_fsize, |
|
|
1314 wfix_size_set ? wfix_size : db_max_rss, |
|
|
1315 wfix_busy_rate, rate); |
|
|
1316 wfix_later(WFIX_RECHECK_SECS); |
|
|
1317 break; |
|
|
1318 } |
|
|
1319 |
|
|
1320 return 0; |
|
|
1321 } |
|
|
1322 |
|
|
1323 |
|
|
1324 |
|
|
1325 /* check for changes or other interesting events when the flood timer expires */ |
|
|
1326 static time_t /* microseconds to wait */ |
|
|
1327 check_changes(void) |
|
|
1328 { |
|
|
1329 static time_t misc_timer, files_timer; |
|
|
1330 time_t secs; |
|
|
1331 DB_HADDR hash_free; |
|
|
1332 const char *mode; |
|
|
1333 const char *reason; |
|
|
1334 char reason_buf[100]; |
|
|
1335 |
|
|
1336 reason = 0; |
|
|
1337 mode = 0; |
|
|
1338 |
|
|
1339 if (db_failed_line) { |
|
|
1340 snprintf(reason_buf, sizeof(reason_buf), |
|
|
1341 "database broken at line %d in %s "DCC_VERSION, |
|
|
1342 db_failed_line, db_failed_file); |
|
|
1343 reason = reason_buf; |
|
|
1344 mode = "Rbad"; |
|
|
1345 |
|
|
1346 } else if ((hash_free |
|
|
1347 = db_hash_len - db_hash_used) < MIN_CLEAN_HASH_ENTRIES |
|
|
1348 || hash_free < db_hash_len/20) { |
|
|
1349 /* try to expand the hash table when there are only |
|
|
1350 * a few free slots or the load factor rises above .95 */ |
|
|
1351 if (hash_free < MIN_HASH_ENTRIES) |
|
|
1352 snprintf(reason_buf, sizeof(reason_buf), |
|
|
1353 "%d free hash entries", |
|
|
1354 hash_free); |
|
|
1355 else |
|
|
1356 snprintf(reason_buf, sizeof(reason_buf), |
|
|
1357 "%d free hash entries among %d total", |
|
|
1358 hash_free, db_hash_len); |
|
|
1359 reason = reason_buf; |
|
|
1360 mode = "Rhash"; |
|
|
1361 |
|
|
1362 } else { |
|
|
1363 /* check nothing else if it is not yet time */ |
|
|
1364 secs = next_flods_ck - db_time.tv_sec; |
|
|
1365 if (secs > 0 && secs <= flods_ck_secs) |
|
|
1366 return secs * DCC_US; |
|
|
1367 } |
|
|
1368 |
|
|
1369 next_flods_ck = db_time.tv_sec + flods_ck_secs; |
|
|
1370 |
|
|
1371 /* do not make some checks too often even when flood checking is |
|
|
1372 * being rushed */ |
|
|
1373 if (DB_IS_TIME(misc_timer, MISC_CK_SECS)) { |
|
|
1374 misc_timer = db_time.tv_sec + MISC_CK_SECS; |
|
|
1375 |
|
|
1376 /* shrink our memory footprint |
|
|
1377 * if we are so idle that we don't have anything to flush */ |
|
|
1378 if (db_need_flush_secs == 0) { |
|
|
1379 if (db_unload(0, 1) == 1) { |
|
|
1380 rel_db_states(); |
|
|
1381 db_unload(0, 1); |
|
|
1382 } |
|
|
1383 } |
|
|
1384 |
|
|
1385 if (DB_IS_TIME(files_timer, 30)) { |
|
|
1386 files_timer = db_time.tv_sec + 30; |
|
|
1387 |
|
|
1388 if (0 >= check_load_ids(0)) |
|
|
1389 dcc_error_msg("check/reload: %s", dcc_emsg); |
|
|
1390 |
|
|
1391 check_blacklist_file(); |
|
|
1392 |
|
|
1393 #ifdef HAVE_GETIFADDRS |
|
|
1394 /* check for network interface changes, but only |
|
|
1395 * if we can release the result of getifaddrs() */ |
|
|
1396 if (get_if_changes(1)) { |
|
|
1397 int socs = open_srvr_socs(0); |
|
|
1398 if (!socs) |
|
|
1399 bad_stop("no server sockets"); |
|
|
1400 else if (socs > 0) |
|
|
1401 flods_restart("new network interfaces", |
|
|
1402 1); |
|
|
1403 } |
|
|
1404 #endif |
|
|
1405 } |
|
|
1406 |
|
|
1407 if (DB_IS_TIME(need_clients_save, CLIENTS_SAVE_SECS)) |
|
|
1408 clients_save(); |
|
|
1409 |
|
|
1410 /* sound a claim to our server-ID if the database is locked */ |
|
|
1411 if (DB_IS_TIME(host_id_next, DCC_SRVR_ID_SECS) |
|
|
1412 && DB_IS_LOCKED() |
|
|
1413 &&!db_failed_line ) { |
|
|
1414 refresh_srvr_rcd(host_id_sum, my_srvr_id, |
|
|
1415 "adding server-ID claim"); |
|
|
1416 |
|
|
1417 if (!db_failed_line ) { |
|
|
1418 host_id_last = db_time.tv_sec; |
|
|
1419 host_id_next = host_id_last + DCC_SRVR_ID_SECS; |
|
|
1420 } |
|
|
1421 } |
|
|
1422 } |
|
|
1423 |
|
|
1424 /* note when hash expansion finishes and collect a zombie */ |
|
|
1425 check_dbclean(WNOHANG); |
|
|
1426 |
|
|
1427 if (reason != 0) { |
|
|
1428 ; |
|
|
1429 |
|
|
1430 } else if (DB_IS_TIME(clean_fake_secs, 3*24*60*60) |
|
|
1431 && (!db_minimum_map |
|
|
1432 || DB_IS_TIME(clean_last_secs+2*24*60*60, 4*24*60*60))) { |
|
|
1433 reason = "work around broken cron job"; |
|
|
1434 mode = "Rcron"; |
|
|
1435 |
|
|
1436 } else if (need_del_dbclean != 0 |
|
|
1437 && DB_IS_TIME(del_dbclean_next, DEL_DBCLEAN_SECS)) { |
|
|
1438 /* the deletion of a report needs to be cleaned up */ |
|
|
1439 reason = need_del_dbclean; |
|
|
1440 mode = "Rdel"; |
|
|
1441 |
|
|
1442 } else if (DB_IS_TIME(dbclean_wfix_secs, WFIX_MAX_SECS) |
|
|
1443 && wfix(reason_buf, sizeof(reason_buf))) { |
|
|
1444 reason = reason_buf; |
|
|
1445 mode = "Rquick"; |
|
|
1446 } |
|
|
1447 |
|
|
1448 if (reason) { |
|
|
1449 if (!DB_IS_TIME(dbclean_limit, dbclean_limit_secs)) { |
|
|
1450 if (next_flods_ck > dbclean_limit) |
|
|
1451 next_flods_ck = dbclean_limit; |
|
|
1452 } else if (dbclean_pid < 0) { |
|
|
1453 run_dbclean(mode, reason); |
|
|
1454 } else { |
|
|
1455 RUSH_NEXT_FLODS_CK(); |
|
|
1456 } |
|
|
1457 } else { |
|
|
1458 flods_ck(0); |
|
|
1459 } |
|
|
1460 |
|
|
1461 /* we probably delayed */ |
|
|
1462 gettimeofday(&db_time, 0); |
|
|
1463 |
|
|
1464 secs = next_flods_ck - db_time.tv_sec; |
|
|
1465 return secs >= 0 ? secs*DCC_US : 0; |
|
|
1466 } |
|
|
1467 |
|
|
1468 |
|
|
1469 |
|
|
1470 static void NRATTRIB |
|
|
1471 recv_job(void) |
|
|
1472 { |
|
|
1473 fd_set rfds, *prfds, wfds, *pwfds; |
|
|
1474 # define PFD_SET(_fd0,_fds) {int _fd = _fd0; \ |
|
|
1475 p##_fds = &_fds; FD_SET(_fd,p##_fds); \ |
|
|
1476 if (max_fd < _fd) max_fd = _fd;} |
|
|
1477 int max_fd, nfds; |
|
|
1478 IFLOD_INFO *ifp; |
|
|
1479 OFLOD_INFO *ofp; |
|
|
1480 struct timeval delay; |
|
|
1481 time_t delay_us, slept_us, was_too_busy, us; |
|
|
1482 struct timeval iflods_read, busy_time, extra_time; |
|
|
1483 u_char db_has_failed; |
|
|
1484 # define QUANTUM (DCC_US/10) /* try to use only ~50% of the system */ |
|
|
1485 SRVR_SOC *sp; |
|
|
1486 QUEUE *q; |
|
|
1487 int bad_select; |
|
|
1488 u_char worked; |
|
|
1489 int fd, i; |
|
|
1490 |
|
|
1491 bad_select = 3; |
|
|
1492 was_too_busy = 0; |
|
|
1493 gettimeofday(&db_time, 0); |
|
|
1494 iflods_read = db_time; |
|
|
1495 busy_time = db_time; |
|
|
1496 extra_time = db_time; |
|
|
1497 delay_us = flods_ck_secs*DCC_US; |
|
|
1498 db_has_failed = 0; |
|
|
1499 for (;;) { |
|
|
1500 dcc_emsg[0] = '\0'; |
|
|
1501 |
|
|
1502 if (stopint) { |
|
|
1503 flods_ck_secs = SHUTDOWN_DELAY; |
|
|
1504 if (flods_off < 100000) { |
|
|
1505 flods_off = 100000; |
|
|
1506 flods_stop("server stopping", 0); |
|
|
1507 check_dbclean(WNOHANG); |
|
|
1508 if (dbclean_pid > 0) { |
|
|
1509 kill(dbclean_pid, SIGINT); |
|
|
1510 usleep(100*1000); |
|
|
1511 } |
|
|
1512 /* get started flushing the database while |
|
|
1513 * we wait for flooding to stop */ |
|
|
1514 rel_db_states(); |
|
|
1515 db_minimum_map = 1; |
|
|
1516 db_unload(0, 2); |
|
|
1517 } |
|
|
1518 /* get serious when the floods have stopped */ |
|
|
1519 if (oflods.total == 0) { |
|
|
1520 if (stopint < 0) |
|
|
1521 dccd_quit(0, "gracefully stopping%s", |
|
|
1522 stop_mode == 1 |
|
|
1523 ? " for reboot" |
|
|
1524 : stop_mode == 2 |
|
|
1525 ? " cleanly" |
|
|
1526 : ""); |
|
|
1527 dccd_quit(stopint | 128, |
|
|
1528 "exiting with signal %d", stopint); |
|
|
1529 } |
|
|
1530 } |
|
|
1531 |
|
|
1532 if (db_has_failed != db_failed_line) { |
|
|
1533 db_has_failed = db_failed_line; |
|
|
1534 if (db_failed_line) { |
|
|
1535 ++flods_off; |
|
|
1536 flods_stop("database corrupt", 1); |
|
|
1537 rel_db_states(); |
|
|
1538 db_unload(0, 2); |
|
|
1539 db_unlock(); |
|
|
1540 } |
|
|
1541 } |
|
|
1542 |
|
|
1543 FD_ZERO(&rfds); |
|
|
1544 prfds = 0; |
|
|
1545 FD_ZERO(&wfds); |
|
|
1546 pwfds = 0; |
|
|
1547 max_fd = -1; |
|
|
1548 |
|
|
1549 /* look for client requests */ |
|
|
1550 for (sp = srvr_socs; sp; sp = sp->fwd) { |
|
|
1551 if (sp->udp >= 0) |
|
|
1552 PFD_SET(sp->udp, rfds); |
|
|
1553 } |
|
|
1554 |
|
|
1555 if (was_too_busy > 0) |
|
|
1556 was_too_busy = QUANTUM - tv_diff2us(&db_time, |
|
|
1557 &busy_time); |
|
|
1558 if (was_too_busy > 0 |
|
|
1559 && (tv_diff2us(&db_time, &extra_time) |
|
|
1560 < min(30, min(KEEPALIVE_IN, KEEPALIVE_OUT)/2)) |
|
|
1561 && FLODS_OK()) { |
|
|
1562 /* if we have been too busy, |
|
|
1563 * then do nothing extra for a while */ |
|
|
1564 if (delay_us > was_too_busy) |
|
|
1565 delay_us = was_too_busy; |
|
|
1566 } else { |
|
|
1567 extra_time = db_time; |
|
|
1568 |
|
|
1569 /* Accept new incoming flood connections |
|
|
1570 * if flooding is on |
|
|
1571 * and we don't already have too many floods. */ |
|
|
1572 if (iflods.open < DCCD_MAX_FLOODS) { |
|
|
1573 for (sp = srvr_socs; sp; sp = sp->fwd) { |
|
|
1574 if (sp->listen >= 0) |
|
|
1575 PFD_SET(sp->listen, rfds); |
|
|
1576 } |
|
|
1577 } |
|
|
1578 |
|
|
1579 /* pump floods out */ |
|
|
1580 for (ofp = oflods.infos, i = 0; |
|
|
1581 i < oflods.open; |
|
|
1582 ++ofp) { |
|
|
1583 if (ofp->soc < 0) |
|
|
1584 continue; |
|
|
1585 ++i; |
|
|
1586 if (ofp->flags & OFLOD_FG_CONNECTED) { |
|
|
1587 PFD_SET(ofp->soc, rfds); |
|
|
1588 if (!(ofp->flags & OFLOD_FG_EAGAIN) |
|
|
1589 && ofp->obuf_len != 0) |
|
|
1590 PFD_SET(ofp->soc, wfds); |
|
|
1591 } else { |
|
|
1592 PFD_SET(ofp->soc, wfds); |
|
|
1593 } |
|
|
1594 } |
|
|
1595 |
|
|
1596 /* pump floods in */ |
|
|
1597 for (ifp = iflods.infos, i = 0; |
|
|
1598 i < iflods.open; |
|
|
1599 ++ifp) { |
|
|
1600 if (ifp->soc < 0) |
|
|
1601 continue; |
|
|
1602 ++i; |
|
|
1603 if (ifp->flags & IFLOD_FG_CONNECTED) { |
|
|
1604 PFD_SET(ifp->soc, rfds); |
|
|
1605 } else { |
|
|
1606 PFD_SET(ifp->soc, wfds); |
|
|
1607 } |
|
|
1608 } |
|
|
1609 } |
|
|
1610 |
|
|
1611 /* push data to the disk */ |
|
|
1612 if (db_need_flush_secs != 0) { |
|
|
1613 if (DB_IS_TIME(db_need_flush_secs, |
|
|
1614 max(DB_URGENT_NEED_FLUSH_SECS, |
|
|
1615 DB_NEED_FLUSH_SECS))) { |
|
|
1616 db_flush_needed(); |
|
|
1617 gettimeofday(&db_time, 0); |
|
|
1618 } |
|
|
1619 us = db_need_flush_secs - db_time.tv_sec; |
|
|
1620 if (us >= 0) { |
|
|
1621 us *= DCC_US; |
|
|
1622 if (delay_us > us) |
|
|
1623 delay_us = us; |
|
|
1624 } |
|
|
1625 } |
|
|
1626 |
|
|
1627 /* let dbclean run if we have run out of work |
|
|
1628 * or if we have been holding the lock for 0.1 seconds*/ |
|
|
1629 if (db_minimum_map |
|
|
1630 && DB_IS_LOCKED() |
|
|
1631 && (delay_us != 0 |
|
|
1632 || tv_diff2us(&db_time, &db_locked) >= DCC_US/10)) { |
|
|
1633 db_unlock(); |
|
|
1634 } |
|
|
1635 |
|
|
1636 /* delay until it is time to answer the oldest anonymous |
|
|
1637 * request or something else that needs doing */ |
|
|
1638 delay.tv_sec = delay_us/DCC_US; |
|
|
1639 delay.tv_usec = delay_us%DCC_US; |
|
|
1640 nfds = select(max_fd+1, prfds, pwfds, 0, &delay); |
|
|
1641 if (nfds < 0) { |
|
|
1642 if (errno != EINTR) { |
|
|
1643 if (--bad_select < 0) |
|
|
1644 bad_stop("give up after select(): %s", |
|
|
1645 ERROR_STR()); |
|
|
1646 else |
|
|
1647 dcc_error_msg("select(): %s", |
|
|
1648 ERROR_STR()); |
|
|
1649 } |
|
|
1650 /* ignore EINTR but recompute timers */ |
|
|
1651 FD_ZERO(&rfds); |
|
|
1652 FD_ZERO(&wfds); |
|
|
1653 } else { |
|
|
1654 bad_select = 3; |
|
|
1655 } |
|
|
1656 |
|
|
1657 gettimeofday(&wake_time, 0); |
|
|
1658 slept_us = tv_diff2us(&wake_time, &db_time); |
|
|
1659 if (slept_us >= 500) { |
|
|
1660 /* If select() paused for at least 0.5 millisecond, |
|
|
1661 * then the waiting request has just now arrived. */ |
|
|
1662 req_recv_time = wake_time; |
|
|
1663 } else { |
|
|
1664 /* If select() did not pause, then assume the waiting |
|
|
1665 * requests arrived when we were half finished working |
|
|
1666 * on flooding and other work besides ordinary requests |
|
|
1667 * before calling select(). */ |
|
|
1668 tv_add_us(&req_recv_time, |
|
|
1669 tv_diff2us(&wake_time, &req_recv_time) / 2); |
|
|
1670 } |
|
|
1671 db_time = wake_time; |
|
|
1672 |
|
|
1673 worked = 0; |
|
|
1674 for (sp = srvr_socs; sp; sp = sp->fwd) { |
|
|
1675 /* queue a new anonymous request |
|
|
1676 * or answer a new authenticated request */ |
|
|
1677 fd = sp->udp; |
|
|
1678 if (fd >= 0 && FD_ISSET(fd, &rfds)) { |
|
|
1679 --nfds; |
|
|
1680 worked = 1; |
|
|
1681 while (new_job(sp)) |
|
|
1682 continue; |
|
|
1683 } |
|
|
1684 |
|
|
1685 /* start a new incoming flood */ |
|
|
1686 fd = sp->listen; |
|
|
1687 if (fd >= 0 && FD_ISSET(fd, &rfds)) { |
|
|
1688 --nfds; |
|
|
1689 worked = 1; |
|
|
1690 iflod_start(sp); |
|
|
1691 } |
|
|
1692 } |
|
|
1693 if (worked) |
|
|
1694 gettimeofday(&db_time, 0); |
|
|
1695 /* reset request receipt clock for next time */ |
|
|
1696 req_recv_time = db_time; |
|
|
1697 |
|
|
1698 /* Accept new flood data or start new SOCKS floods. |
|
|
1699 * Listen to all peers to prevent starvation */ |
|
|
1700 worked = 0; |
|
|
1701 for (ifp = iflods.infos, i = 0; |
|
|
1702 nfds > 0 && i < iflods.open; |
|
|
1703 ++ifp) { |
|
|
1704 if (ifp->soc < 0) |
|
|
1705 continue; |
|
|
1706 ++i; |
|
|
1707 if (FD_ISSET(ifp->soc, &rfds) |
|
|
1708 || FD_ISSET(ifp->soc, &wfds)) { |
|
|
1709 --nfds; |
|
|
1710 iflod_read(ifp); |
|
|
1711 worked = 1; |
|
|
1712 } |
|
|
1713 } |
|
|
1714 if (worked) { |
|
|
1715 gettimeofday(&db_time, 0); |
|
|
1716 iflods_read = db_time; |
|
|
1717 } else if (was_too_busy <= 0) { |
|
|
1718 /* if incoming floods have been quiet for |
|
|
1719 * awhile, then assume flooding has caught up |
|
|
1720 * after having been turned off */ |
|
|
1721 if (tv_diff2us(&wake_time, &iflods_read) > 2*DCC_US) |
|
|
1722 iflods_ok_timer = db_time.tv_sec; |
|
|
1723 } |
|
|
1724 |
|
|
1725 /* pump output flood data and receive confirmations |
|
|
1726 * talk to all peers to prevent starvation */ |
|
|
1727 worked = 0; |
|
|
1728 for (ofp = oflods.infos, i = 0; |
|
|
1729 nfds > 0 && i < oflods.open; |
|
|
1730 ++ofp) { |
|
|
1731 if (ofp->soc < 0) |
|
|
1732 continue; |
|
|
1733 ++i; |
|
|
1734 if (FD_ISSET(ofp->soc, &rfds)) { |
|
|
1735 --nfds; |
|
|
1736 oflod_read(ofp); |
|
|
1737 if (ofp->soc < 0) |
|
|
1738 continue; |
|
|
1739 } |
|
|
1740 if (FD_ISSET(ofp->soc, &wfds)) { |
|
|
1741 --nfds; |
|
|
1742 oflod_write(ofp); |
|
|
1743 worked = 1; |
|
|
1744 } |
|
|
1745 } |
|
|
1746 if (worked) |
|
|
1747 gettimeofday(&db_time, 0); |
|
|
1748 |
|
|
1749 /* process delayed jobs when their times arrive */ |
|
|
1750 worked = 0; |
|
|
1751 for (;;) { |
|
|
1752 q = queue_head; |
|
|
1753 if (!q) { |
|
|
1754 delay_us = flods_ck_secs*DCC_US; |
|
|
1755 break; |
|
|
1756 } |
|
|
1757 |
|
|
1758 /* decide whether this job's time has come |
|
|
1759 * while defending against time jumps */ |
|
|
1760 delay_us = tv_diff2us(&q->answer, &db_time); |
|
|
1761 if (delay_us >= 1000 |
|
|
1762 && delay_us <= DCC_MAX_RTT |
|
|
1763 && !stopint) |
|
|
1764 break; /* not yet time for next job */ |
|
|
1765 |
|
|
1766 queue_head = q->later; |
|
|
1767 if (queue_head) |
|
|
1768 queue_head->earlier = 0; |
|
|
1769 --queue_cur; |
|
|
1770 do_work(q); |
|
|
1771 worked = 1; |
|
|
1772 free_q(q); |
|
|
1773 } |
|
|
1774 if (worked) |
|
|
1775 gettimeofday(&db_time, 0); |
|
|
1776 |
|
|
1777 /* check configuration changes etc. */ |
|
|
1778 us = check_changes(); |
|
|
1779 if (delay_us >= us) |
|
|
1780 delay_us = us; |
|
|
1781 |
|
|
1782 us = tv_diff2us(&db_time, &wake_time); |
|
|
1783 if (us >= QUANTUM && !stopint) { |
|
|
1784 gettimeofday(&db_time, 0); |
|
|
1785 busy_time = db_time; |
|
|
1786 was_too_busy = QUANTUM; |
|
|
1787 } |
|
|
1788 } |
|
|
1789 } |
|
|
1790 |
|
|
1791 |
|
|
1792 |
|
|
1793 static void |
|
|
1794 add_queue(QUEUE *q) |
|
|
1795 { |
|
|
1796 QUEUE *qnext, **qp; |
|
|
1797 |
|
|
1798 TMSG1(QUERY, "received %s", op_id_ip(q)); |
|
|
1799 if (!ck_clnt_id(q)) { |
|
|
1800 free_q(q); |
|
|
1801 return; |
|
|
1802 } |
|
|
1803 |
|
|
1804 ++total_ops; |
|
|
1805 |
|
|
1806 /* immediately process requests from authenticated clients |
|
|
1807 * if flooding is working */ |
|
|
1808 if (q->delay_us == 0) { |
|
|
1809 do_work(q); |
|
|
1810 free_q(q); |
|
|
1811 return; |
|
|
1812 } |
|
|
1813 |
|
|
1814 /* don't let the queue of delayed requests get too large */ |
|
|
1815 if (queue_cur >= queue_max) { |
|
|
1816 clnt_msg(q, "drop excess queued %s", op_id_ip(q)); |
|
|
1817 free_q(q); |
|
|
1818 return; |
|
|
1819 } |
|
|
1820 |
|
|
1821 tv_add_us(&q->answer, q->delay_us); |
|
|
1822 |
|
|
1823 /* add the new job to the queue */ |
|
|
1824 ++queue_cur; |
|
|
1825 qp = &queue_head; |
|
|
1826 for (;;) { |
|
|
1827 qnext = *qp; |
|
|
1828 if (!qnext) { |
|
|
1829 *qp = q; |
|
|
1830 break; |
|
|
1831 } |
|
|
1832 if (qnext->answer.tv_sec > q->answer.tv_sec |
|
|
1833 || (qnext->answer.tv_sec == q->answer.tv_sec |
|
|
1834 && qnext->answer.tv_usec > q->answer.tv_usec)) { |
|
|
1835 q->later = qnext; |
|
|
1836 qnext->earlier = q; |
|
|
1837 *qp = q; |
|
|
1838 break; |
|
|
1839 } |
|
|
1840 q->earlier = qnext; |
|
|
1841 qp = &qnext->later; |
|
|
1842 } |
|
|
1843 } |
|
|
1844 |
|
|
1845 |
|
|
1846 |
|
|
1847 /* get a new job in a datagram */ |
|
|
1848 static u_char /* 1=call again */ |
|
|
1849 new_job(SRVR_SOC *sp) |
|
|
1850 { |
|
|
1851 QUEUE *q; |
|
|
1852 static struct iovec iov = {0, sizeof(q->pkt)}; |
|
|
1853 static struct msghdr msg; |
|
|
1854 int i, j; |
|
|
1855 |
|
|
1856 /* Find a free queue entry for the job. |
|
|
1857 * Because we don't check for incoming jobs unless we think the |
|
|
1858 * queue is not full, there must always be a free entry or |
|
|
1859 * permission to make more entries. */ |
|
|
1860 q = queue_free; |
|
|
1861 if (q) { |
|
|
1862 queue_free = q->later; |
|
|
1863 } else { |
|
|
1864 i = 16; |
|
|
1865 q = dcc_malloc(i * sizeof(*q)); |
|
|
1866 if (!q) |
|
|
1867 dcc_logbad(EX_UNAVAILABLE, |
|
|
1868 "malloc(%d queue entries) failed", i); |
|
|
1869 queue_max_cur += i; |
|
|
1870 /* put all but the last new queue entry on the free list */ |
|
|
1871 while (--i > 0) { |
|
|
1872 q->later = queue_free; |
|
|
1873 queue_free = q; |
|
|
1874 ++q; |
|
|
1875 } |
|
|
1876 } |
|
|
1877 |
|
|
1878 memset(q, 0, sizeof(*q)); |
|
|
1879 q->sp = sp; |
|
|
1880 iov.iov_base = (char *)&q->pkt; |
|
|
1881 msg.msg_name = (void *)&q->clnt_su; |
|
|
1882 msg.msg_namelen = sizeof(q->clnt_su); |
|
|
1883 msg.msg_iov = &iov; |
|
|
1884 msg.msg_iovlen = 1; |
|
|
1885 i = recvmsg(sp->udp, &msg, 0); |
|
|
1886 if (i < 0) { |
|
|
1887 /* ignore some results of ICMP unreachables for UDP |
|
|
1888 * retransmissions seen on some platforms */ |
|
|
1889 if (DCC_BLOCK_ERROR()) { |
|
|
1890 ; |
|
|
1891 } else if (UNREACHABLE_ERRORS()) { |
|
|
1892 TMSG2(QUERY, "recvmsg(%s): %s", |
|
|
1893 dcc_su2str_err(&sp->su), ERROR_STR()); |
|
|
1894 } else { |
|
|
1895 dcc_error_msg("recvmsg(%s): %s", |
|
|
1896 dcc_su2str_err(&sp->su), ERROR_STR()); |
|
|
1897 } |
|
|
1898 free_q(q); |
|
|
1899 return 0; |
|
|
1900 } |
|
|
1901 if (q->clnt_su.sa.sa_family != sp->su.sa.sa_family |
|
|
1902 && !dcc_ipv4sutoipv6(&q->clnt_su, &q->clnt_su)) { |
|
|
1903 dcc_error_msg("recvmsg address family %d instead of %d", |
|
|
1904 q->clnt_su.sa.sa_family, |
|
|
1905 sp->su.sa.sa_family); |
|
|
1906 free_q(q); |
|
|
1907 return 1; |
|
|
1908 } |
|
|
1909 |
|
|
1910 if (DCC_SU_PORT(&q->clnt_su) == 0) { |
|
|
1911 drop_msg(q, "source port 0"); |
|
|
1912 free_q(q); |
|
|
1913 return 1; |
|
|
1914 } |
|
|
1915 |
|
|
1916 q->pkt_len = i; |
|
|
1917 if (i < ISZ(DCC_HDR)) { |
|
|
1918 drop_msg(q, "short request of %d bytes", i); |
|
|
1919 free_q(q); |
|
|
1920 return 1; |
|
|
1921 } |
|
|
1922 j = ntohs(q->pkt.hdr.len); |
|
|
1923 if (j != i) { |
|
|
1924 drop_msg(q, "request with header length %d instead of %d", |
|
|
1925 j, i); |
|
|
1926 free_q(q); |
|
|
1927 return 1; |
|
|
1928 } |
|
|
1929 |
|
|
1930 if (q->pkt.hdr.pkt_vers > DCC_PKT_VERSION_MAX_VALID |
|
|
1931 || q->pkt.hdr.pkt_vers < DCC_PKT_VERSION_MIN_VALID |
|
|
1932 || ((q->pkt.hdr.pkt_vers > DCC_PKT_VERSION_MAX |
|
|
1933 || q->pkt.hdr.pkt_vers < DCC_PKT_VERSION_MIN) |
|
|
1934 && q->pkt.hdr.op != DCC_OP_NOP)) { |
|
|
1935 drop_msg(q, "%s in unrecognized protocol version #%d", |
|
|
1936 qop2str(q), q->pkt.hdr.pkt_vers); |
|
|
1937 free_q(q); |
|
|
1938 return 1; |
|
|
1939 } |
|
|
1940 |
|
|
1941 q->answer = req_recv_time; |
|
|
1942 |
|
|
1943 switch ((DCC_OPS)q->pkt.hdr.op) { |
|
|
1944 case DCC_OP_NOP: |
|
|
1945 do_nop(q); |
|
|
1946 free_q(q); |
|
|
1947 return 1; |
|
|
1948 |
|
|
1949 case DCC_OP_REPORT: |
|
|
1950 if (db_parms.flags & DB_PARM_FG_GREY) |
|
|
1951 break; /* not valid for greylist servers */ |
|
|
1952 add_queue(q); |
|
|
1953 return 1; |
|
|
1954 |
|
|
1955 case DCC_OP_QUERY: |
|
|
1956 add_queue(q); |
|
|
1957 return 1; |
|
|
1958 |
|
|
1959 case DCC_OP_ADMN: |
|
|
1960 do_admn(q); |
|
|
1961 free_q(q); |
|
|
1962 return 1; |
|
|
1963 |
|
|
1964 case DCC_OP_DELETE: |
|
|
1965 do_delete(q); |
|
|
1966 free_q(q); |
|
|
1967 return 1; |
|
|
1968 |
|
|
1969 case DCC_OP_GREY_REPORT: |
|
|
1970 case DCC_OP_GREY_QUERY: |
|
|
1971 case DCC_OP_GREY_WHITE: |
|
|
1972 if (!(db_parms.flags & DB_PARM_FG_GREY)) |
|
|
1973 break; /* valid only for greylist servers */ |
|
|
1974 do_grey(q); |
|
|
1975 free_q(q); |
|
|
1976 return 1; |
|
|
1977 |
|
|
1978 case DCC_OP_GREY_SPAM: |
|
|
1979 if (!(db_parms.flags & DB_PARM_FG_GREY)) |
|
|
1980 break; /* valid only for greylist servers */ |
|
|
1981 do_grey_spam(q); |
|
|
1982 free_q(q); |
|
|
1983 return 1; |
|
|
1984 |
|
|
1985 case DCC_OP_INVALID: |
|
|
1986 case DCC_OP_ANSWER: |
|
|
1987 case DCC_OP_OK: |
|
|
1988 case DCC_OP_ERROR: |
|
|
1989 break; |
|
|
1990 } |
|
|
1991 |
|
|
1992 drop_msg(q, "invalid %s", op_id_ip(q)); |
|
|
1993 free_q(q); |
|
|
1994 return 1; |
|
|
1995 } |
|
|
1996 |
|
|
1997 |
|
|
1998 |
|
|
1999 void |
|
|
2000 free_q(QUEUE *q) |
|
|
2001 { |
|
|
2002 if (q->rl) |
|
|
2003 --q->rl->ref_cnt; |
|
|
2004 q->later = queue_free; |
|
|
2005 queue_free = q; |
|
|
2006 } |
|
|
2007 |
|
|
2008 |
|
|
2009 |
|
|
2010 u_char |
|
|
2011 dccd_db_open(u_char lock_mode) |
|
|
2012 { |
|
|
2013 DCC_CK_TYPES type; |
|
|
2014 time_t clean_secs; |
|
|
2015 DCC_TGTS tgts; |
|
|
2016 int i; |
|
|
2017 |
|
|
2018 if (!db_open(dcc_emsg, -1, 0, 0, lock_mode | db_mode)) |
|
|
2019 return 0; |
|
|
2020 |
|
|
2021 if (grey_on) { |
|
|
2022 /* for greylisting, ignore the args an silently impose our |
|
|
2023 * notion of which checksums to keep and flooding thresholds */ |
|
|
2024 db_parms.nokeep_cks = def_nokeep_cks(); |
|
|
2025 if (grey_weak_ip) |
|
|
2026 DB_RESET_NOKEEP(db_parms.nokeep_cks, DCC_CK_IP); |
|
|
2027 |
|
|
2028 for (type = DCC_CK_TYPE_FIRST; |
|
|
2029 type <= DCC_CK_TYPE_LAST; |
|
|
2030 ++type) { |
|
|
2031 if (type == DCC_CK_SRVR_ID) { |
|
|
2032 flod_tholds[type] = 1; |
|
|
2033 continue; |
|
|
2034 } |
|
|
2035 |
|
|
2036 if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type)) |
|
|
2037 flod_tholds[type] = DCC_TGTS_INVALID; |
|
|
2038 else |
|
|
2039 flod_tholds[type] = 1; |
|
|
2040 |
|
|
2041 if (DCC_CK_IS_GREY_TRIPLE(grey_on,type) |
|
|
2042 || type == DCC_CK_IP) { |
|
|
2043 db_parms.ex_secs[type].all = grey_window; |
|
|
2044 db_parms.ex_secs[type].spam = grey_white; |
|
|
2045 } else if (type == DCC_CK_BODY |
|
|
2046 || DCC_CK_IS_GREY_MSG(grey_on,type)) { |
|
|
2047 db_parms.ex_secs[type].all = grey_window; |
|
|
2048 db_parms.ex_secs[type].spam = grey_window; |
|
|
2049 } else { |
|
|
2050 db_parms.ex_secs[type].all = 1; |
|
|
2051 db_parms.ex_secs[type].spam = 1; |
|
|
2052 } |
|
|
2053 } |
|
|
2054 |
|
|
2055 summarize_delay_secs = grey_embargo - FLODS_CK_SECS*2; |
|
|
2056 |
|
|
2057 } else { |
|
|
2058 /* impose our notion of which normal checksums to keep */ |
|
|
2059 DB_SET_NOKEEP(set_new_nokeep_cks, DCC_CK_FLOD_PATH); |
|
|
2060 DB_SET_NOKEEP(set_new_nokeep_cks, DCC_CK_INVALID); |
|
|
2061 DB_SET_NOKEEP(set_new_nokeep_cks, DCC_CK_REP_TOTAL); |
|
|
2062 DB_SET_NOKEEP(set_new_nokeep_cks, DCC_CK_REP_BULK); |
|
|
2063 db_parms.nokeep_cks = ((def_nokeep_cks() |
|
|
2064 & ~reset_new_nokeep_cks) |
|
|
2065 | set_new_nokeep_cks); |
|
|
2066 |
|
|
2067 for (type = DCC_CK_TYPE_FIRST; |
|
|
2068 type <= DCC_CK_TYPE_LAST; |
|
|
2069 ++type) { |
|
|
2070 if (type == DCC_CK_SRVR_ID) { |
|
|
2071 flod_tholds[type] = 1; |
|
|
2072 continue; |
|
|
2073 } |
|
|
2074 |
|
|
2075 if (type == DCC_CK_REP_TOTAL) |
|
|
2076 tgts = DCC_TGTS_INVALID; |
|
|
2077 if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type)) |
|
|
2078 tgts = DCC_TGTS_INVALID; |
|
|
2079 else if (DCC_CK_IS_REP_CMN(0, type)) |
|
|
2080 tgts = DCC_TGTS_INVALID; |
|
|
2081 else |
|
|
2082 tgts = BULK_THRESHOLD; |
|
|
2083 flod_tholds[type] = tgts; |
|
|
2084 } |
|
|
2085 |
|
|
2086 /* We should not delay reports or summaries so much that |
|
|
2087 * dbclean might expire them before we can summarize them. */ |
|
|
2088 summarize_delay_secs = DCC_OLD_SPAM_SECS; |
|
|
2089 for (type = DCC_CK_TYPE_FIRST; |
|
|
2090 type <= DCC_CK_TYPE_LAST; |
|
|
2091 ++type) { |
|
|
2092 if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type)) |
|
|
2093 continue; |
|
|
2094 i = db_parms.ex_secs[type].spam; |
|
|
2095 if (i != 0 && summarize_delay_secs > i) |
|
|
2096 summarize_delay_secs = i; |
|
|
2097 } |
|
|
2098 } |
|
|
2099 if (summarize_delay_secs < 1) |
|
|
2100 summarize_delay_secs = 1; |
|
|
2101 |
|
|
2102 /* adjust the thresholds after possible changes to kept checksums */ |
|
|
2103 set_db_tholds(db_parms.nokeep_cks); |
|
|
2104 |
|
|
2105 /* If we instead of cron asked for the last cleaning, make a note |
|
|
2106 * to clean the database during the graveyard shift. |
|
|
2107 * Otherwise the database will bloat while the cron job is broken. |
|
|
2108 * |
|
|
2109 * Compute 1 day + 45 minutes after cron should have last cleaned the |
|
|
2110 * database, if it has been cleaned by cron within the last 3 days |
|
|
2111 * or the quarter hour when it was last cleaned by this mechanism |
|
|
2112 * provided that was between local midnight and 05:00 |
|
|
2113 * or 3 minutes past a random quarter hour beteen midnight and 05:00 */ |
|
|
2114 if (db_parms.cleaned_cron >= db_time.tv_sec - 3*24*60*60 |
|
|
2115 && db_parms.cleaned_cron <= db_time.tv_sec) { |
|
|
2116 clean_last_secs = db_parms.cleaned_cron; |
|
|
2117 /* failsafe cleaning for the greylist database starts 15 minutes |
|
|
2118 * before the main database */ |
|
|
2119 clean_secs = clean_last_secs + 45*60 - grey_on*15*60; |
|
|
2120 } else { |
|
|
2121 struct tm tm; |
|
|
2122 |
|
|
2123 clean_last_secs = db_parms.cleaned; |
|
|
2124 if (clean_last_secs >= db_time.tv_sec) |
|
|
2125 clean_last_secs = 0; |
|
|
2126 clean_secs = clean_last_secs; |
|
|
2127 |
|
|
2128 /* if the previous time for this mechanism is not good, |
|
|
2129 * pick a new random time */ |
|
|
2130 dcc_localtime(clean_secs, &tm); |
|
|
2131 if (clean_secs == 0 || tm.tm_hour < 1 || tm.tm_hour >= 5) { |
|
|
2132 int rnum = (u_int)(db_time.tv_sec + db_time.tv_usec |
|
|
2133 + my_srvr_id - grey_on) % 23; |
|
|
2134 tm.tm_hour = ((rnum / 4) % 4) + 1; |
|
|
2135 tm.tm_min = (rnum % 4) * 15; |
|
|
2136 clean_secs = mktime(&tm); |
|
|
2137 } |
|
|
2138 } |
|
|
2139 /* round down to a quarter hour to prevent creep due to inevitiable |
|
|
2140 * delays in cron or this mechanism starting dbclean */ |
|
|
2141 clean_secs -= clean_secs % (15*60); |
|
|
2142 clean_secs %= (24*60*60); /* failsafe cleaning target minute */ |
|
|
2143 |
|
|
2144 /* compute the next scheduled failsafe cleaning. */ |
|
|
2145 clean_fake_secs = db_time.tv_sec - (db_time.tv_sec % (24*60*60)); |
|
|
2146 clean_fake_secs += clean_secs; |
|
|
2147 if (clean_fake_secs <= db_time.tv_sec) |
|
|
2148 clean_fake_secs += 24*60*60; |
|
|
2149 |
|
|
2150 /* The next failsafe cleaning should happen a day after the |
|
|
2151 * most recent cron or failsafe cleaning, modulo the delay before |
|
|
2152 * dbclean starts */ |
|
|
2153 while (clean_fake_secs <= clean_last_secs + 24*60*60 - 60*60) |
|
|
2154 clean_fake_secs += 24*60*60; |
|
|
2155 |
|
|
2156 /* Do not failsafe clean during the first 48 hours after the |
|
|
2157 * database was created to give the cron job a chance. |
|
|
2158 * We do not want failsafe cleaning to ever be running when the |
|
|
2159 * cron job tries to start. */ |
|
|
2160 while (clean_fake_secs <= db_parms.cleared + 2*24*60*60 |
|
|
2161 && db_parms.cleared <= db_time.tv_sec) |
|
|
2162 clean_fake_secs += 24*60*60; |
|
|
2163 |
|
|
2164 total_ops = 0; |
|
|
2165 |
|
|
2166 /* push our thresholds and flags to the file */ |
|
|
2167 return db_flush_parms(0); |
|
|
2168 } |
|
|
2169 |
|
|
2170 |
|
|
2171 |
|
|
2172 /* clean shut down */ |
|
|
2173 static void NRATTRIB |
|
|
2174 dccd_quit(int exitcode, const char *p, ...) |
|
|
2175 { |
|
|
2176 va_list args; |
|
|
2177 |
|
|
2178 if (stop_mode == 1) |
|
|
2179 db_stop(); |
|
|
2180 else if (stop_mode == 2) |
|
|
2181 make_clean(2); |
|
|
2182 db_unlock(); |
|
|
2183 |
|
|
2184 va_start(args, p); |
|
|
2185 if (exitcode) |
|
|
2186 dcc_verror_msg(p, args); |
|
|
2187 else |
|
|
2188 dcc_vtrace_msg(p, args); |
|
|
2189 va_end(args); |
|
|
2190 |
|
|
2191 /* db_close() can take a long time, so close some things early. */ |
|
|
2192 stop_children(); |
|
|
2193 check_dbclean(WNOHANG); |
|
|
2194 clients_save(); |
|
|
2195 |
|
|
2196 #ifdef HAVE_COHERENT_MMAP |
|
|
2197 /* If mmap() is not coherent, do not call close_srvr_socs() but |
|
|
2198 * keep the UDP sockets open to prevent another server from starting |
|
|
2199 * until we have flushed our buffers to prevent problems on systems |
|
|
2200 * that lack inter-process coherent mmap() */ |
|
|
2201 if (!(db_mode & DB_OPEN_MMAP_WRITE)) |
|
|
2202 close_srvr_socs(); |
|
|
2203 #endif |
|
|
2204 db_close(1); |
|
|
2205 |
|
|
2206 if (exitcode) |
|
|
2207 dcc_error_msg("stopped"); |
|
|
2208 else |
|
|
2209 dcc_trace_msg("stopped"); |
|
|
2210 exit(exitcode); |
|
|
2211 } |
|
|
2212 |
|
|
2213 |
|
|
2214 |
|
|
2215 /* watch for fatal signals */ |
|
|
2216 static void |
|
|
2217 sigterm(int sig) |
|
|
2218 { |
|
|
2219 stopint = sig; |
|
|
2220 stop_mode = 1; |
|
|
2221 next_flods_ck = 0; |
|
|
2222 (void)signal(sig, SIG_DFL); /* catch it only once */ |
|
|
2223 } |
|
|
2224 |
|
|
2225 |
|
|
2226 |
|
|
2227 /* SIGHUP hurries checking the configuration files */ |
|
|
2228 static void |
|
|
2229 sighup(int sig UATTRIB) |
|
|
2230 { |
|
|
2231 next_flods_ck = 0; |
|
|
2232 } |
|
|
2233 |
|
|
2234 |
|
|
2235 |
|
|
2236 /* emergency shutdown but close the database cleanly */ |
|
|
2237 void |
|
|
2238 bad_stop(const char *pat, ...) |
|
|
2239 { |
|
|
2240 va_list args; |
|
|
2241 |
|
|
2242 if (stopint) |
|
|
2243 return; |
|
|
2244 |
|
|
2245 va_start(args, pat); |
|
|
2246 dcc_verror_msg(pat, args); |
|
|
2247 va_end(args); |
|
|
2248 |
|
|
2249 stopint = -1; |
|
|
2250 next_flods_ck = 0; |
|
|
2251 } |
|
|
2252 |
|
|
2253 |
|
|
2254 |
|
|
2255 static void |
|
|
2256 stop_children(void) |
|
|
2257 { |
|
|
2258 if (resolve_hosts_pid > 0) |
|
|
2259 kill(resolve_hosts_pid, SIGKILL); |
|
|
2260 |
|
|
2261 if (dbclean_pid > 0) |
|
|
2262 kill(dbclean_pid, SIGKILL); |
|
|
2263 } |
