Mercurial > notdcc

comparison dccd/oflod.c @ 0:c7f6b056b673

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
First import of vendor version
author Peter Gervai <grin@grin.hu>
date Tue, 10 Mar 2009 13:49:58 +0100
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:c7f6b056b673
1 /* Distributed Checksum Clearinghouse
2 *
3 * deal with outgoing floods of checksums
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.151 $Revision$
40 */
41
42 #include "dccd_defs.h"
43 #include "dcc_ck.h"
44
45
46 int flods_off; /* # of reasons flooding is off */
47
48 time_t next_flods_ck;
49 time_t flod_mtime = 1;
50 enum FLODS_ST flods_st = FLODS_ST_OFF;
51 OFLODS oflods;
52
53 /* records after this have not been flooded
54 * 0 if invalid */
55 DB_PTR oflods_max_cur_pos;
56
57 int summarize_delay_secs; /* delay summaries by this */
58
59
60 static void oflod_fill(OFLOD_INFO *);
61
62
63 /* the socket must already be closed */
64 static void
65 oflod_clear(OFLOD_INFO *ofp)
66 {
67 memset(ofp, 0, sizeof(*ofp));
68 ofp->soc = -1;
69 }
70
71
72
73 void
74 oflods_clear(void)
75 {
76 OFLOD_INFO *ofp;
77
78 iflods_stop("", 1); /* paranoia */
79
80 flod_unmap(0, &dccd_stats);
81
82 for (ofp = oflods.infos; ofp <= LAST(oflods.infos); ++ofp)
83 oflod_clear(ofp);
84 oflods.total = 0;
85 complained_many_iflods = 0;
86 oflods_max_cur_pos = 0;
87 }
88
89
90
91 /* parse ID1->tgt in a flood file entry */
92 static char
93 oflod_parse_map(OFLOD_OPTS *opts, const char *str0, int lno)
94 {
95 DCC_FNM_LNO_BUF fnm_buf;
96 const char *str;
97 OFLOD_SRVR_ID_MAP *imp;
98
99 if (opts->num_maps >= DIM(opts->srvr_map)) {
100 dcc_error_msg("too many ID mappings with\"%s\"%s",
101 str0, fnm_lno(&fnm_buf, flod_path, lno));
102 return 0;
103 }
104 imp = &opts->srvr_map[opts->num_maps];
105
106 if (!CLITCMP(str0, "self->")) {
107 str = str0+LITZ("self->");
108 imp->from_lo = imp->from_hi = my_srvr_id;
109 } else if (!CLITCMP(str0, "all->")) {
110 str = str0+LITZ("all->");
111 imp->from_lo = DCC_SRVR_ID_MIN;
112 imp->from_hi = DCC_SRVR_ID_MAX;
113 } else {
114 /* get ID1 */
115 str = dcc_get_srvr_id(0, &imp->from_lo, str0, "-",
116 flod_path, lno);
117 if (!str)
118 return 0;
119 if (str[0] == '-' && str[1] == '>') {
120 /* ID1 is not a range */
121 imp->from_hi = imp->from_lo;
122 } else {
123 /* ID1 is a range of IDs */
124 str = dcc_get_srvr_id(0, &imp->from_hi,
125 str+1, "-", flod_path, lno);
126 if (!str)
127 return 0;
128 if (imp->from_hi < imp->from_lo) {
129 dcc_error_msg("invalid ID mapping range "
130 "\"%d-%d\"%s",
131 imp->from_lo, imp->from_hi,
132 fnm_lno(&fnm_buf,
133 flod_path, lno));
134 return 0;
135 }
136 }
137 if (*str++ != '-' || *str++ != '>') {
138 dcc_error_msg("invalid server-ID mapping \"%s\"%s",
139 str0, fnm_lno(&fnm_buf, flod_path, lno));
140 return 0;
141 }
142 }
143 if (!strcasecmp(str, "self")) {
144 imp->result = ID_MAP_SELF;
145 } else if (!strcasecmp(str, "reject")) {
146 imp->result = ID_MAP_REJ;
147 } else if (!strcasecmp(str, "ok")) {
148 imp->result = ID_MAP_NO;
149 } else {
150 dcc_error_msg("invalid ID mapping result \"%s\"%s",
151 str, fnm_lno(&fnm_buf, flod_path, lno));
152 return 0;
153 }
154
155 ++opts->num_maps;
156 return 1;
157 }
158
159
160
161 static u_char
162 ck_socks_flags(OFLOD_INFO *ofp, OPT_FLAGS new,
163 DCC_FNM_LNO_BUF fnm_buf, int lno)
164 {
165 if (0 != (ofp->o_opts.flags & (FLOD_OPT_PASSIVE | FLOD_OPT_SOCKS
166 | FLOD_OPT_NAT)
167 & ~new)) {
168 dcc_error_msg("only one of \"passive\", \"SOCKS\", or \"NAT\""
169 " allowed%s",
170 fnm_lno(&fnm_buf, flod_path, lno));
171 return 0;
172 }
173
174 if ((new & (FLOD_OPT_SOCKS | FLOD_OPT_NAT)) != 0
175 && (ofp->loc_hostname[0] != '\0' || ofp->loc_port != 0)) {
176 dcc_error_msg("source host name or port number"
177 " and \"SOCKS\" or \"NAT\""
178 " cannot both be set%s",
179 fnm_lno(&fnm_buf, flod_path, lno));
180 ofp->loc_hostname[0] = '\0';
181 ofp->loc_port = 0;
182 }
183
184 ofp->o_opts.flags |= new;
185 return 1;
186 }
187
188
189
190 /* parse remote or local options that can be any of
191 * a "off", "del", "no-del", "log-del", "passive", ID->map, etc. */
192 static const char * /* rest of the line */
193 parse_flod_opts(OFLOD_INFO *ofp,
194 OFLOD_OPTS *opts,
195 const char *buf, int lno)
196 {
197 DCC_FNM_LNO_BUF fnm_buf;
198 char opts_buf[200];
199 char opt[20];
200 const char *buf_ptr, *p;
201 char *end;
202 unsigned long l;
203 u_int olen;
204
205 /* pick out the blank delimited string of options */
206 buf = dcc_parse_word(0, opts_buf, sizeof(opts_buf),
207 buf, "flood options", flod_path, lno);
208 if (!buf)
209 return 0;
210
211 opts->path_len = DCC_MAX_FLOD_PATH;
212 if (grey_on)
213 opts->flags |= (FLOD_OPT_DEL_OK
214 | FLOD_OPT_NO_LOG_DEL
215 | FLOD_OPT_DEL_SET);
216
217 /* parse the options */
218 buf_ptr = opts_buf;
219 while (*buf_ptr != '\0') {
220 if (*buf_ptr == ',') {
221 ++buf_ptr;
222 continue;
223 }
224 olen = strcspn(buf_ptr, ",");
225 if (olen >= sizeof(opt))
226 olen = sizeof(opt)-1;
227 strncpy(opt, buf_ptr, olen);
228 opt[olen] = '\0';
229 buf_ptr += olen;
230
231 /* ignore "-" */
232 if (!strcmp(opt, "-"))
233 continue;
234
235 if (!strcasecmp(opt, "off")) {
236 opts->flags |= FLOD_OPT_OFF;
237 continue;
238 }
239
240 if (!grey_on) {
241 if (!strcasecmp(opt, "traps")) {
242 opts->flags |= FLOD_OPT_TRAPS;
243 continue;
244 }
245 if (!strcasecmp(opt, "no-del")) {
246 opts->flags &= ~FLOD_OPT_DEL_OK;
247 opts->flags |= FLOD_OPT_DEL_SET;
248 continue;
249 }
250 if (!strcasecmp(opt, "del")) {
251 opts->flags |= FLOD_OPT_DEL_OK;
252 opts->flags |= FLOD_OPT_DEL_SET;
253 continue;
254 }
255 }
256
257 /* put some options in one or the other flag word no matter
258 * for which they are specified */
259 if (!strcasecmp(opt, "trace")) {
260 ofp->o_opts.flags |= FLOD_OPT_TRACE;
261 continue;
262 }
263 if (!strcasecmp(opt, "trace2")) {
264 ofp->o_opts.flags |= FLOD_OPT_TRACE2;
265 continue;
266 }
267
268 if (!strcasecmp(opt, "no-log-del")) {
269 ofp->i_opts.flags |= FLOD_OPT_NO_LOG_DEL;
270 continue;
271 }
272 if (!strcasecmp(opt, "log-del")) {
273 ofp->i_opts.flags &= ~FLOD_OPT_NO_LOG_DEL;
274 continue;
275 }
276 if (!strcasecmp(opt, "passive")) {
277 if (!ck_socks_flags(ofp, FLOD_OPT_PASSIVE,
278 fnm_buf, lno))
279 return 0;
280 continue;
281 }
282 if (!strcasecmp(opt, "socks")) {
283 if (!ck_socks_flags(ofp, FLOD_OPT_SOCKS,
284 fnm_buf, lno))
285 return 0;
286 continue;
287 }
288 if (!strcasecmp(opt, "nat")) {
289 if (!ck_socks_flags(ofp, FLOD_OPT_NAT,
290 fnm_buf, lno))
291 return 0;
292 continue;
293 }
294 if (!strcasecmp(opt, "IPv4")) {
295 if (ofp->o_opts.flags & FLOD_OPT_IPv6) {
296 dcc_error_msg("\"IPv4\" and \"IPv6\";"
297 " cannot both be%s",
298 fnm_lno(&fnm_buf,
299 flod_path, lno));
300 return 0;
301 }
302 ofp->o_opts.flags |= FLOD_OPT_IPv4;
303 continue;
304 }
305 if (!strcasecmp(opt, "IPv6")) {
306 if (ofp->o_opts.flags & FLOD_OPT_IPv4) {
307 dcc_error_msg("\"IPv4\" and \"IPv6\";"
308 " cannot both be%s",
309 fnm_lno(&fnm_buf,
310 flod_path, lno));
311 return 0;
312 }
313 ofp->o_opts.flags |= FLOD_OPT_IPv6;
314 continue;
315 }
316 if (!CLITCMP(opt, "leaf=")
317 && (l = strtoul(opt+LITZ("leaf="), &end, 10),
318 *end == '\0')) {
319 if (l > DCC_MAX_FLOD_PATH)
320 l = DCC_MAX_FLOD_PATH;
321 ofp->o_opts.path_len = l;
322 continue;
323 }
324
325 #ifdef DCC_FLOD_VERSION7
326 if (!strcasecmp(opt, "version7")) {
327 ofp->oversion = DCC_FLOD_VERSION7;
328 continue;
329 }
330
331 #endif
332 /* parse an ID->map */
333 p = strchr(opt, '>');
334 if (p && p > opt && *(p-1) == '-') {
335 if (!oflod_parse_map(opts, opt, lno))
336 return 0;
337 continue;
338 }
339
340 dcc_error_msg("unknown option \"%s\"%s",
341 opt, fnm_lno(&fnm_buf, flod_path, lno));
342 return 0;
343 }
344
345 return buf;
346 }
347
348
349
350 static const char * /* rest of a flod file line */
351 oflod_parse_id(DCC_SRVR_ID *id,
352 const char *buf, const char *type, int lno)
353 {
354 char id_buf[20];
355
356 buf = dcc_parse_word(0, id_buf, sizeof(id_buf),
357 buf, type, flod_path, lno);
358 if (!buf)
359 return 0;
360
361 if (!strcmp(id_buf, "-")
362 || id_buf[0] == '\0') {
363 *id = DCC_ID_INVALID;
364 return buf;
365 }
366
367 if (!dcc_get_srvr_id(0, id, id_buf, 0, flod_path, lno))
368 return 0;
369
370 /* do not check whether we know the local ID here, because
371 * changes in the ids file can make that check moot */
372
373 return buf;
374 }
375
376
377
378 /* compute the maximum position among all floods */
379 static void
380 get_oflods_max_cur_pos(void)
381 {
382 OFLOD_INFO *ofp;
383
384 oflods_max_cur_pos = DB_PTR_BASE;
385 for (ofp = oflods.infos; ofp <= LAST(oflods.infos); ++ofp) {
386 if (ofp->rem_hostname[0] != '\0'
387 && oflods_max_cur_pos < ofp->cur_pos)
388 oflods_max_cur_pos = ofp->cur_pos;
389 }
390 }
391
392
393
394 static void
395 copy_opts2mp(OFLOD_INFO *ofp)
396 {
397 FLOD_MMAP *mp;
398 FLOD_MMAP_FLAGS new_flags;
399 u_char changed;
400
401 mp = ofp->mp;
402 changed = 0;
403 new_flags = mp->flags & (FLODMAP_FG_REWINDING
404 | FLODMAP_FG_NEED_REWIND
405 | FLODMAP_FG_FFWD_IN
406 | FLODMAP_FG_OUT_SRVR
407 | FLODMAP_FG_IN_SRVR
408 | FLODMAP_FG_NAT_AUTO
409 | FLODMAP_FG_USE_2PASSWD);
410
411 if (db_parms.flags & DB_PARM_FG_CLEARED) {
412 new_flags |= FLODMAP_FG_NEED_REWIND;
413 new_flags &= ~FLODMAP_FG_FFWD_IN;
414 changed = 1;
415 }
416
417 if (ofp->o_opts.flags & FLOD_OPT_ROGUE)
418 new_flags |= FLODMAP_FG_ROGUE;
419
420 if ((ofp->o_opts.flags & FLOD_OPT_OFF))
421 new_flags |= FLODMAP_FG_OUT_OFF;
422
423 if (ofp->i_opts.flags & FLOD_OPT_OFF)
424 new_flags |= FLODMAP_FG_IN_OFF;
425
426 if (ofp->o_opts.flags & FLOD_OPT_IPv4) {
427 new_flags |= FLODMAP_FG_IPv4;
428 if (mp->flags & FLODMAP_FG_IPv6)
429 got_hosts = 0;
430 } else if (ofp->o_opts.flags & FLOD_OPT_IPv6) {
431 new_flags |= FLODMAP_FG_IPv6;
432 if (mp->flags & FLODMAP_FG_IPv4)
433 got_hosts = 0;
434 }
435
436 if (ofp->o_opts.flags & FLOD_OPT_PASSIVE) {
437 new_flags |= FLODMAP_FG_PASSIVE;
438 } else if (ofp->o_opts.flags & FLOD_OPT_SOCKS) {
439 new_flags |= FLODMAP_FG_SOCKS;
440 } else if (ofp->o_opts.flags & FLOD_OPT_NAT) {
441 new_flags |= FLODMAP_FG_NAT;
442 }
443
444 if (ofp->o_opts.path_len != DCC_MAX_FLOD_PATH)
445 new_flags |= FLODMAP_FG_LEAF;
446
447 if (ofp->o_opts.num_maps != 0
448 || ofp->i_opts.num_maps != 0)
449 new_flags |= FLODMAP_FG_MAPPED;
450
451 if ((mp->flags ^ new_flags) && (FLODMAP_FG_ROGUE
452 | FLODMAP_FG_OUT_OFF
453 | FLODMAP_FG_IN_OFF
454 | FLODMAP_FG_IPv6
455 | FLODMAP_FG_IPv4
456 | FLODMAP_FG_PASSIVE
457 | FLODMAP_FG_SOCKS
458 | FLODMAP_FG_NAT
459 | FLODMAP_FG_LEAF
460 | FLODMAP_FG_MAPPED)) {
461 mp->flags = new_flags;
462 changed = 1;
463 }
464
465 /* get new hostname if it changes */
466 if (strcasecmp(mp->rem_hostname, ofp->rem_hostname)) {
467 BUFCPY(mp->rem_hostname, ofp->rem_hostname);
468 got_hosts = 0; /* force name resolution for new name */
469 changed = 1;
470 }
471 /* always get new port name
472 * in case the name but not the number changes */
473 BUFCPY(mp->rem_portname, ofp->rem_portname);
474 if (mp->rem_port != ofp->rem_port) {
475 mp->rem_port = ofp->rem_port;
476 changed = 1;
477 }
478
479 if (mp->ids_mtime != ids_mtime) {
480 mp->ids_mtime = ids_mtime;
481 mp->flags &= ~FLODMAP_FG_USE_2PASSWD;
482 changed = 1;
483 }
484
485 if (mp->in_passwd_id != ofp->in_passwd_id) {
486 mp->in_passwd_id = ofp->in_passwd_id;
487 changed = 1;
488 }
489 if (mp->out_passwd_id != ofp->out_passwd_id) {
490 mp->out_passwd_id = ofp->out_passwd_id;
491 changed = 1;
492 }
493
494 if (changed)
495 flod_try_again(ofp);
496 }
497
498
499
500 /* Load the hostnames of DCC server peers and their output flood positions.
501 * flod_names_resolve_ck() must say ok before this function is called,
502 * to avoid races with changing host names.
503 *
504 * Parse lines of the form
505 * name,port;name,port rem-ID [passwd-id [out-opts [in-opts [versionX]]]]
506 */
507 u_char /* 1=ok to start flooding */
508 load_flod(u_char complain)
509 {
510 DCC_FNM_LNO_BUF fnm_buf;
511 OFLOD_INFO *ofp, *ofp1;
512 FILE *f;
513 struct stat sb;
514 int lno;
515 char buf[200];
516 char hostname[60];
517 const char *bufp, *bufp1;
518 FLOD_MMAP *mp, *mp1;
519 union {
520 OFLOD_INFO info;
521 FLOD_MMAP map;
522 } swap;
523 const ID_TBL *tp;
524 char *p;
525 int i;
526
527 /* the caller should use RUSH_NEXT_FLODS_CK() or similar, but
528 * just in case ... */
529 if (!flod_names_resolve_ck())
530 return 0;
531
532 /* forget everything about flooding */
533 oflods_clear();
534
535 /* keep the map open and locked most of the time */
536 if (!flod_mmap(dcc_emsg, &db_parms.sn, &dccd_stats, 1,
537 (DCC_TRACE_FLOD_BIT & dccd_tracemask) != 0)) {
538 if (complain)
539 dcc_error_msg("%s", dcc_emsg);
540 flod_mtime = 0;
541 return 0;
542 }
543
544 f = fopen(flod_path, "r");
545 if (!f) {
546 if (flod_mtime != 0) {
547 dcc_error_msg("fopen(%s): %s",
548 flod_path, ERROR_STR());
549 flod_mtime = 0;
550 }
551
552 flod_unmap(0, &dccd_stats);
553 return 0;
554 }
555 if (0 > fstat(fileno(f), &sb)) {
556 if (flod_mtime!= 0)
557 dcc_error_msg("stat(%s): %s",
558 flod_path, ERROR_STR());
559 fclose(f);
560 flod_unmap(0, &dccd_stats);
561 flod_mtime = 0;
562 return 0;
563 }
564 flod_mtime = sb.st_mtime;
565
566 /* Parse the ASCII file of names and parameters first so that we do not
567 * destroy the position information if there is a problem with names */
568 ofp = oflods.infos;
569 lno = 0;
570 for (;;) {
571 /* clear the entry in case we started to set it with the
572 * preceding line from the /var/dcc/flod file */
573 if (ofp <= LAST(oflods.infos))
574 oflod_clear(ofp);
575
576 ++lno;
577 bufp = fgets(buf, sizeof(buf), f);
578 if (!bufp) {
579 if (ferror(f)) {
580 dcc_error_msg("fgets(%s): %s",
581 flod_path, ERROR_STR());
582 break;
583 }
584 if (fclose(f) == EOF) {
585 dcc_error_msg("fclose(%s): %s",
586 flod_path, ERROR_STR());
587 }
588 f = 0;
589 break;
590 }
591 i = strlen(bufp);
592 if (i >= ISZ(buf)-1) {
593 dcc_error_msg("too many characters%s",
594 fnm_lno(&fnm_buf, flod_path, lno));
595 do {
596 i = getc(f);
597 } while (i != '\n' && i != EOF);
598 continue;
599 }
600 /* ignore comments */
601 p = strchr(bufp, '#');
602 if (p)
603 *p = '\0';
604 else
605 p = &buf[i];
606 /* trim trailing blanks */
607 while (--p > bufp && (*p == ' ' || *p == '\t' || *p == '\n'))
608 *p = '\0';
609 /* skip blank lines */
610 bufp += strspn(bufp, DCC_WHITESPACE);
611 if (*bufp == '\0')
612 continue;
613
614 if (oflods.total >= DIM(oflods.infos)) {
615 dcc_error_msg("too many DCC peers in %s; max=%d",
616 flod_path, DIM(oflods.infos));
617 continue;
618 }
619
620 ofp->lno = lno;
621
622 /* get IP address and port number of remote DCC server */
623 bufp1 = bufp+strcspn(bufp, DCC_WHITESPACE";");
624 if (*bufp1 != ';') {
625 bufp1 = 0;
626 } else {
627 /* Allow the local or client TCP IP address and
628 * port number to be specified. */
629 buf[bufp1++ - buf] = '\0';
630 }
631 bufp = dcc_parse_nm_port(0, bufp, def_port,
632 ofp->rem_hostname,
633 sizeof(ofp->rem_hostname),
634 &ofp->rem_port,
635 ofp->rem_portname,
636 sizeof(ofp->rem_portname),
637 flod_path, lno);
638 if (!bufp)
639 continue;
640 if (bufp1) {
641 /* parse the local IP address first */
642 bufp = dcc_parse_nm_port(0, bufp1, 0,
643 ofp->loc_hostname,
644 sizeof(ofp->loc_hostname),
645 &ofp->loc_port, 0, 0,
646 flod_path, lno);
647 if (!bufp)
648 continue;
649 }
650
651 bufp = oflod_parse_id(&ofp->rem_id, bufp,
652 "rem-id", lno);
653 if (!bufp)
654 continue;
655 if (ofp->rem_id == DCC_ID_INVALID) {
656 dcc_error_msg("missing rem-id%s",
657 fnm_lno(&fnm_buf, flod_path, lno));
658 continue;
659 }
660
661 bufp = oflod_parse_id(&ofp->out_passwd_id, bufp,
662 "passwd-id", lno);
663 if (!bufp)
664 continue;
665 if (ofp->out_passwd_id == DCC_ID_INVALID) {
666 ofp->out_passwd_id = my_srvr_id;
667 ofp->in_passwd_id = ofp->rem_id;
668 } else {
669 ofp->in_passwd_id = ofp->out_passwd_id;
670 }
671
672 ofp->oversion = DCC_FLOD_VERSION_DEF;
673 bufp = parse_flod_opts(ofp, &ofp->o_opts, bufp, lno);
674 if (!bufp)
675 continue;
676 bufp = parse_flod_opts(ofp, &ofp->i_opts, bufp, lno);
677 if (!bufp)
678 continue;
679 if (*bufp != '\0')
680 dcc_error_msg("trailing garbage \"%s\" ignored%s",
681 bufp, fnm_lno(&fnm_buf, flod_path, lno));
682
683 tp = find_srvr_type(ofp->rem_id);
684 if (0 < find_srvr_rcd_type(ofp->rem_id)) {
685 switch (DB_RCD_ID(db_sts.rcd2.d.r)) {
686 case DCC_ID_SRVR_REP_OK:
687 case DCC_ID_SRVR_SIMPLE:
688 ofp->o_opts.flags |= FLOD_OPT_SIMPLE;
689 break;
690 case DCC_ID_SRVR_ROGUE:
691 ofp->o_opts.flags |= FLOD_OPT_ROGUE;
692 break;
693 default:
694 dcc_error_msg("unknown state for server-ID %d",
695 ofp->rem_id);
696 break;
697 }
698 }
699
700 /* both servers having spam traps and assuming the other
701 * doesn't makes no sense */
702 if (((ofp->o_opts.flags & FLOD_OPT_TRAPS)
703 || (ofp->i_opts.flags & FLOD_OPT_TRAPS))
704 && !(ofp->i_opts.flags & FLOD_OPT_OFF)
705 && !(ofp->o_opts.flags & FLOD_OPT_OFF)) {
706 dcc_error_msg("symmetric trap-only link%s",
707 fnm_lno(&fnm_buf, flod_path, lno));
708 continue;
709 }
710
711 for (ofp1 = oflods.infos; ofp1 < ofp; ++ofp1) {
712 if ((!strcmp(ofp1->rem_hostname, ofp->rem_hostname)
713 && ofp1->rem_port == ofp->rem_port)
714 || ofp1->rem_id == ofp->rem_id)
715 break;
716 }
717 if (ofp1 != ofp) {
718 dcc_error_msg("duplicate DCC peer%s",
719 fnm_lno(&fnm_buf, flod_path, lno));
720 continue;
721 }
722
723 /* ignore ourself */
724 if (ofp->rem_id == my_srvr_id)
725 continue;
726
727 ofp->limit_reset = db_time.tv_sec + FLOD_LIM_CLEAR_SECS;
728
729 ++ofp;
730 ++oflods.total;
731 }
732 if (f)
733 fclose(f);
734
735 /* sort new list by server-ID so that `cdcc "flood list"` is sorted */
736 ofp = oflods.infos;
737 while (ofp < LAST(oflods.infos)) {
738 ofp1 = ofp+1;
739 if (ofp1->rem_hostname[0] == '\0')
740 break;
741 if (ofp->rem_id <= ofp1->rem_id) {
742 ofp = ofp1;
743 continue;
744 }
745 /* bubble sort because the list is usually already
746 * ordered and almost always tiny */
747 memcpy(&swap.info, ofp1, sizeof(swap.info));
748 memcpy(ofp1, ofp, sizeof(*ofp1));
749 memcpy(ofp, &swap.info, sizeof(*ofp));
750 ofp = oflods.infos;
751 }
752
753 mp = flod_mmaps->mmaps;
754
755 /* Bubble sort the list in the /var/dcc/flod/map file so that is
756 * sorted for `dblist -Hv`. The file will usually already be sorted
757 * and is tiny. */
758 mp1 = mp+1;
759 while (mp1 <= LAST(flod_mmaps->mmaps)) {
760 if (mp1->rem_hostname[0] == '\0') {
761 ++mp1;
762 continue;
763 }
764 if (mp->rem_hostname[0] == '\0'
765 || mp->rem_id <= mp1->rem_id) {
766 mp = mp1++;
767 continue;
768 }
769 memcpy(&swap.map, mp1, sizeof(swap.map));
770 memcpy(mp1, mp, sizeof(*mp1));
771 memcpy(mp, &swap.map, sizeof(*mp));
772 mp = flod_mmaps->mmaps;
773 mp1 = mp+1;
774 }
775
776 /* combine our list that is based on the ASCII file /var/dcc/flod
777 * with the memory mapped /var/dcc/flod.map list of what has
778 * been sent to each peer */
779 for (mp = flod_mmaps->mmaps; mp <= LAST(flod_mmaps->mmaps); ++mp)
780 mp->flags &= ~FLODMAP_FG_MARK;
781
782 /* make one pass matching old names with their slots in the
783 * mapped file */
784 mp = flod_mmaps->mmaps;
785 for (ofp = oflods.infos; ofp <= LAST(oflods.infos); ++ofp) {
786 if (ofp->rem_hostname[0] == '\0')
787 break;
788 for (i = 0; i < DIM(flod_mmaps->mmaps); ++i) {
789 if (++mp > LAST(flod_mmaps->mmaps))
790 mp = flod_mmaps->mmaps;
791 if (mp->rem_hostname[0] == '\0')
792 continue;
793 if (!(mp->flags & FLODMAP_FG_MARK)
794 && ofp->rem_id == mp->rem_id) {
795 /* found the old slot */
796 if (DB_PTR_IS_BAD(mp->confirm_pos)
797 || mp->confirm_pos > db_csize) {
798 dcc_error_msg("bogus position "L_HPAT
799 " for %s in %s",
800 mp->confirm_pos,
801 ofp->rem_hostname,
802 flod_mmap_path);
803 mp->rem_hostname[0] = '\0';
804 continue;
805 }
806 ofp->cur_pos = mp->confirm_pos;
807 ofp->rewind_pos = db_csize;
808 ofp->mp = mp;
809 copy_opts2mp(ofp);
810 mp->flags |= FLODMAP_FG_MARK;
811 break;
812 }
813 }
814 }
815
816
817 /* use a free or obsolete slot in the mapped file for new entries */
818 mp = flod_mmaps->mmaps;
819 for (ofp = oflods.infos; ofp <= LAST(oflods.infos); ++ofp) {
820 /* find the next new peer without a mapped file slot */
821 if (ofp->rem_hostname[0] == '\0')
822 break;
823 if (ofp->mp != 0)
824 continue;
825
826 /* find a free or no longer used slot */
827 while (mp->flags & FLODMAP_FG_MARK) {
828 if (++mp > LAST(flod_mmaps->mmaps)) {
829 bad_stop("too few oflod mmap slots");
830 goto out;
831 }
832 }
833 if (mp->rem_hostname[0] != '\0')
834 dcc_error_msg("forget flood to %s %d",
835 dcc_host_portname(hostname,
836 sizeof(hostname),
837 mp->rem_hostname,
838 mp->rem_portname),
839 mp->rem_id);
840
841 /* we have found a free slot */
842 memset(mp, 0, sizeof(*mp));
843 ofp->mp = mp;
844 mp->rem_su.sa.sa_family = AF_UNSPEC;
845 mp->rem_id = ofp->rem_id;
846 copy_opts2mp(ofp);
847
848 mp->cnts.cnts_cleared = db_time.tv_sec;
849
850 if (flod_mmaps->delay_pos < DB_PTR_BASE) {
851 /* do not rewind if repairing a broken file */
852 ofp->cur_pos = mp->confirm_pos = db_csize;
853 ofp->recv_pos = ofp->xmit_pos = db_csize;
854 } else {
855 ofp->cur_pos = mp->confirm_pos = DB_PTR_BASE;
856 ofp->recv_pos = ofp->xmit_pos = DB_PTR_BASE;
857 }
858
859 mp->flags |= FLODMAP_FG_MARK;
860
861 dcc_error_msg("initialize flood to %s %d%s",
862 dcc_host_portname(hostname, sizeof(hostname),
863 mp->rem_hostname,
864 mp->rem_portname),
865 mp->rem_id,
866 fnm_lno(&fnm_buf, flod_path, ofp->lno));
867 }
868 out:;
869
870 /* clear the slots that contain forgotten hosts */
871 for (mp = flod_mmaps->mmaps; mp <= LAST(flod_mmaps->mmaps); ++mp) {
872 if (!(mp->flags & FLODMAP_FG_MARK)) {
873 if (mp->rem_hostname[0] != '\0')
874 dcc_error_msg("forget flood to %s %d",
875 dcc_host_portname(hostname,
876 sizeof(hostname),
877 mp->rem_hostname,
878 mp->rem_portname),
879 mp->rem_id);
880 memset(mp, 0, sizeof(*mp));
881 }
882 }
883
884 flod_mmap_sync(0, 1);
885
886 db_parms.flags &= ~DB_PARM_FG_CLEARED;
887 db_flush_parms(0);
888
889 get_oflods_max_cur_pos();
890 return 1;
891 }
892
893
894
895 /* put the flood counters in stable storage */
896 void
897 save_flod_cnts(OFLOD_INFO *ofp)
898 {
899 FLOD_MMAP *mp;
900 time_t delta;
901 FLOD_LIMCNT *lc;
902
903 dccd_stats.iflod_total += ofp->cnts.total;
904 dccd_stats.iflod_accepted += ofp->cnts.accepted;
905 dccd_stats.iflod_stale += ofp->lc.stale.cur;
906 dccd_stats.iflod_dup += ofp->lc.dup.cur;
907 dccd_stats.iflod_wlist += ofp->lc.wlist.cur;
908 dccd_stats.iflod_not_deleted += ofp->lc.not_deleted.cur;
909
910 mp = ofp->mp;
911 if (mp) {
912 if (ofp->xmit_pos == ofp->recv_pos)
913 ofp->mp->confirm_pos = ofp->cur_pos;
914
915 mp->cnts.total += ofp->cnts.total;
916 mp->cnts.accepted += ofp->cnts.accepted;
917 mp->cnts.stale += ofp->lc.stale.cur;
918 mp->cnts.dup += ofp->lc.dup.cur;
919 mp->cnts.wlist += ofp->lc.wlist.cur;
920 mp->cnts.not_deleted += ofp->lc.not_deleted.cur;
921
922 mp->cnts.out_reports += ofp->cnts.out_reports;
923
924 delta = db_time.tv_sec - ofp->cnts.saved;
925 if (delta < 0)
926 delta = 0;
927 if (ofp->ifp) {
928 if (mp->flags & FLODMAP_FG_IN_CONN) {
929 mp->cnts.in_total_conn += delta;
930 } else {
931 mp->flags |= FLODMAP_FG_IN_CONN;
932 mp->cnts.in_conn_changed = db_time.tv_sec;
933 }
934 } else {
935 if (mp->flags & FLODMAP_FG_IN_CONN) {
936 mp->flags &= ~FLODMAP_FG_IN_CONN;
937 mp->cnts.in_conn_changed = db_time.tv_sec;
938 }
939 }
940
941 if (ofp->flags & OFLOD_FG_CONNECTED) {
942 if (mp->flags & FLODMAP_FG_OUT_CONN) {
943 mp->cnts.out_total_conn += delta;
944 } else {
945 mp->flags |= FLODMAP_FG_OUT_CONN;
946 mp->cnts.out_conn_changed = db_time.tv_sec;
947 }
948 } else {
949 if (mp->flags & FLODMAP_FG_OUT_CONN) {
950 mp->flags &= ~FLODMAP_FG_OUT_CONN;
951 mp->cnts.out_conn_changed = db_time.tv_sec;
952 }
953 }
954 }
955
956 memset(&ofp->cnts, 0, sizeof(ofp->cnts));
957 for (lc = (FLOD_LIMCNT *)&ofp->lc;
958 lc < (FLOD_LIMCNT *)(sizeof(ofp->lc)+(char *)&ofp->lc);
959 ++lc) {
960 lc->lim -= lc->cur;
961 lc->cur = 0;
962 }
963
964 ofp->cnts.saved = db_time.tv_sec;
965 }
966
967
968
969 void
970 oflod_close(OFLOD_INFO *ofp, u_char fail)
971 {
972 u_char need_oflods_clear = 0;
973
974 if (ofp->rem_hostname[0] == '\0')
975 return;
976
977 if (ofp->soc >= 0) {
978 if (0 > close(ofp->soc)
979 && !fail) {
980 if (errno == ECONNRESET)
981 TMSG2_FLOD(ofp, "close(flood to %s): %s",
982 ofp_rem_str(ofp), ERROR_STR());
983 else
984 dcc_error_msg("close(flod to %s): %s",
985 ofp_rem_str(ofp), ERROR_STR());
986 }
987 ofp->soc = -1;
988 ofp->flags &= ~(OFLOD_FG_CONNECTED
989 | OFLOD_FG_SHUTDOWN_REQ
990 | OFLOD_FG_SHUTDOWN);
991 ofp->obuf_len = 0;
992 ofp->cnts.out_reports = 0;
993
994 save_flod_cnts(ofp);
995
996 if (--oflods.open == 0
997 && iflods.open == 0
998 && flods_st != FLODS_ST_ON)
999 need_oflods_clear = 1;
1000 }
1001
1002 if (fail) {
1003 if (ofp->mp->otimers.retry_secs < FLOD_RETRY_SECS/2)
1004 ofp->mp->otimers.retry_secs = FLOD_RETRY_SECS/2;
1005 ofp->mp->otimers.retry = (db_time.tv_sec
1006 + ofp->mp->otimers.retry_secs);
1007 if (!(ofp->mp->flags & FLODMAP_FG_PASSIVE))
1008 TMSG2_FLOD(ofp,
1009 "postpone restarting flood to %s"
1010 " for %d seconds",
1011 ofp_rem_str(ofp),
1012 ofp->mp->otimers.retry_secs);
1013 }
1014
1015 if (need_oflods_clear)
1016 oflods_clear();
1017 }
1018
1019
1020
1021 /* get ready to shut down */
1022 static void
1023 start_shutdown(OFLOD_INFO *ofp)
1024 {
1025 if (ofp->flags & (OFLOD_FG_SHUTDOWN_REQ
1026 | OFLOD_FG_SHUTDOWN))
1027 return;
1028
1029 /* arrange to ask the peer to ask us to stop */
1030 ofp->flags |= OFLOD_FG_SHUTDOWN_REQ;
1031 ofp->flags &= ~OFLOD_FG_NEW;
1032 oflod_fill(ofp);
1033
1034 /* oflod_write() might set this again, but that will either be soon
1035 * or a good thing if delayed */
1036 ofp->oflod_alive = db_time.tv_sec;
1037 }
1038
1039
1040
1041 /* Half-close the TCP connection.
1042 * The other DCC server will notice and send our final position
1043 * to acknowledge dealing with our reports. */
1044 static void
1045 oflod_shutdown(OFLOD_INFO *ofp)
1046 {
1047 struct linger nowait;
1048
1049 /* wait until the output buffer is empty */
1050 if (ofp->obuf_len != 0)
1051 return;
1052
1053 /* do it only once */
1054 if ((ofp->flags & OFLOD_FG_SHUTDOWN))
1055 return;
1056 ofp->flags |= OFLOD_FG_SHUTDOWN;
1057
1058 /* on Solaris and Linux you must set SO_LINGER before shutdown() */
1059 nowait.l_onoff = 1;
1060 nowait.l_linger = SHUTDOWN_DELAY;
1061 if (0 > setsockopt(ofp->soc, SOL_SOCKET, SO_LINGER,
1062 &nowait, sizeof(nowait)))
1063 rpt_err(ofp, 0, 0,
1064 "setsockopt(SO_LINGER flood to %s): %s",
1065 ofp_rem_str(ofp), ERROR_STR());
1066
1067 if (0 > shutdown(ofp->soc, 1)) {
1068 rpt_err(ofp, errno == ECONNRESET, 0,
1069 "shutdown(flood to %s): %s",
1070 ofp_rem_str(ofp), ERROR_STR());
1071 oflod_close(ofp, 1);
1072 }
1073 }
1074
1075
1076
1077 /* see if a report should be put into the output buffer for a flood
1078 * db_sts.rcd.d.r points to the current record.
1079 * ofp->cur_pos has already been advanced */
1080 static u_char /* 1=flood this report, 0=don't */
1081 oflod_ck_put(void)
1082 {
1083 const DB_RCD_CK *cur_rcd_ck;
1084 DCC_TGTS rcd_tgts, ck_tgts;
1085 int num_cks;
1086 DCC_CK_TYPES type;
1087 u_char obs_lvl, result;
1088
1089 /* skip padding, whitelisted, compressed, trimmed
1090 * and deleted entries */
1091 if (DB_RCD_ID(db_sts.rcd.d.r) == DCC_ID_WHITE
1092 || DB_RCD_ID(db_sts.rcd.d.r) == DCC_ID_COMP
1093 || (rcd_tgts = DB_TGTS_RCD_RAW(db_sts.rcd.d.r)) == 0
1094 || DB_RCD_TRIMMED(db_sts.rcd.d.r))
1095 return 0;
1096
1097 /* Skip reports that should not be flooded yet
1098 * The flooding thresholds are used to set the delay flag.
1099 * Small reports are marked with the delay flag when they are added
1100 * to the database. If later it seems they should be flooded,
1101 * they are summarized in a new report that is flooded. */
1102 if (DB_RCD_DELAY(db_sts.rcd.d.r))
1103 return 0;
1104
1105 result = 0;
1106 obs_lvl = 0;
1107 cur_rcd_ck = db_sts.rcd.d.r->cks;
1108 for (num_cks = DB_NUM_CKS(db_sts.rcd.d.r);
1109 num_cks != 0;
1110 ++cur_rcd_ck, --num_cks) {
1111 type = DB_CK_TYPE(cur_rcd_ck);
1112
1113 /* ignore junk for deciding whether we can send this report. */
1114 if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type))
1115 continue;
1116
1117 if (DB_CK_OBS(cur_rcd_ck)) {
1118 /* an obsolete fuzzier checksum
1119 * makes less fuzzy checksums obsolete */
1120 if (obs_lvl < db_ck_fuzziness[type]) {
1121 obs_lvl = db_ck_fuzziness[type];
1122 result = 0;
1123 }
1124 continue;
1125 }
1126
1127 /* send server-ID declarations
1128 * unless they are delete requests */
1129 if (type == DCC_CK_SRVR_ID) {
1130 if (rcd_tgts == DCC_TGTS_DEL)
1131 continue;
1132 return 1;
1133 }
1134
1135 /* do not send whitelisted reports */
1136 ck_tgts = DB_TGTS_CK(cur_rcd_ck);
1137 if (ck_tgts == DCC_TGTS_OK || ck_tgts == DCC_TGTS_OK2)
1138 return 0;
1139
1140 /* send non-obsolete results */
1141 if (obs_lvl <= db_ck_fuzziness[type]) {
1142 obs_lvl = db_ck_fuzziness[type];
1143 result = 1;
1144 }
1145 }
1146 return result;
1147 }
1148
1149
1150
1151 /* put report into the output buffer for a flood if appropriate
1152 * db_sts.rcd.d.r points to the current record.
1153 * ofp->cur_pos has already been advanced */
1154 static void
1155 put_rcd_obuf(OFLOD_INFO *ofp, const DB_RCD *cur_rcd)
1156 {
1157 DCC_FLOD_RPT *rp;
1158 DCC_TGTS tgts;
1159 DCC_SRVR_ID srvr, psrvr;
1160 const DB_RCD_CK *cur_rcd_ck;
1161 DCC_CK *buf_ck;
1162 DCC_FLOD_PATH_ID *new_path_idp, *new_path_id_limp, *rcd_path_id;
1163 int path_id_max;
1164 DCC_CK_TYPES type;
1165 ID_MAP_RESULT srvr_mapped;
1166 u_char reflecting; /* 1=report is pointed at its source */
1167 u_char non_path, all_spam;
1168 int num_cks, j;
1169
1170 /* decide whether to send this report */
1171 if (!oflod_ck_put())
1172 return; /* skip it */
1173
1174 rp = (DCC_FLOD_RPT *)&ofp->obuf.b[ofp->obuf_len];
1175 db_ptr2flod_pos(rp->pos, ofp->cur_pos);
1176 tgts = DB_TGTS_RCD_RAW(cur_rcd);
1177 if (tgts == DCC_TGTS_DEL) {
1178 /* don't send delete requests to systems that don't want them */
1179 if (!(ofp->o_opts.flags & FLOD_OPT_DEL_OK))
1180 return;
1181 } else if (ofp->o_opts.flags & FLOD_OPT_TRAPS) {
1182 tgts = DCC_TGTS_TOO_MANY;
1183 }
1184
1185 srvr = DB_RCD_ID(cur_rcd);
1186 /* translate the source server-ID */
1187 srvr_mapped = id_map(srvr, &ofp->o_opts);
1188 switch (srvr_mapped) {
1189 case ID_MAP_NO:
1190 break;
1191 case ID_MAP_REJ:
1192 return;
1193 case ID_MAP_SELF:
1194 srvr = my_srvr_id;
1195 break;
1196 }
1197 /* this loses the DCC_SRVR_ID_AUTH bit */
1198 rp->srvr_id_auth[0] = srvr>>8;
1199 rp->srvr_id_auth[1] = srvr;
1200
1201 reflecting = (srvr == ofp->rem_id);
1202 non_path = 0;
1203
1204 rp->ts = cur_rcd->ts;
1205
1206 cur_rcd_ck = cur_rcd->cks;
1207
1208 /* Add a path if we are not the source of the report
1209 * or if it already has a path */
1210 buf_ck = rp->cks;
1211 if (srvr != my_srvr_id
1212 || DB_CK_TYPE(cur_rcd_ck) == DCC_CK_FLOD_PATH) {
1213 /* Add a checksum entry for a path consisting of only our
1214 * server-ID. If the report contains a path, we will
1215 * concatenate to this entry */
1216 memset(buf_ck, 0, sizeof(*buf_ck));
1217 buf_ck->len = sizeof(*buf_ck);
1218 buf_ck->type = DCC_CK_FLOD_PATH;
1219 new_path_idp = (DCC_FLOD_PATH_ID *)buf_ck->sum;
1220 new_path_idp->hi = my_srvr_id>>8;
1221 new_path_idp->lo = my_srvr_id;
1222 new_path_id_limp = new_path_idp + DCC_NUM_FLOD_PATH;
1223 path_id_max = ofp->o_opts.path_len-1;
1224 ++new_path_idp;
1225 ++buf_ck;
1226 rp->num_cks = 1;
1227 } else {
1228 /* do not add a path */
1229 new_path_idp = new_path_id_limp = 0;
1230 path_id_max = 0;
1231 rp->num_cks = 0;
1232 }
1233
1234 all_spam = 1;
1235 for (num_cks = DB_NUM_CKS(cur_rcd);
1236 num_cks != 0;
1237 ++cur_rcd_ck, --num_cks) {
1238 type = DB_CK_TYPE(cur_rcd_ck);
1239 if (type == DCC_CK_FLOD_PATH) {
1240 rcd_path_id = (DCC_FLOD_PATH_ID *)&cur_rcd_ck->sum;
1241 for (j = 0; j < DCC_NUM_FLOD_PATH; ++j, ++rcd_path_id) {
1242 psrvr = ((rcd_path_id->hi<<8)
1243 | rcd_path_id->lo);
1244 /* stop copying the path at its end */
1245 if (psrvr == DCC_ID_INVALID)
1246 break;
1247 /* don't send report if its path is too long */
1248 if (--path_id_max < 0)
1249 return;
1250 /* add another "checksum" to continue path */
1251 if (new_path_idp >= new_path_id_limp) {
1252 memset(buf_ck, 0, sizeof(*buf_ck));
1253 buf_ck->len = sizeof(*buf_ck);
1254 buf_ck->type = DCC_CK_FLOD_PATH;
1255 new_path_idp = (DCC_FLOD_PATH_ID *
1256 )buf_ck->sum;
1257 new_path_id_limp = (new_path_idp
1258 + DCC_NUM_FLOD_PATH);
1259 ++buf_ck;
1260 ++rp->num_cks;
1261 }
1262 /* Do not send reports from the target back
1263 * to the target unless the report is a
1264 * server-ID declaration */
1265 if (psrvr == ofp->rem_id)
1266 reflecting = 1;
1267 switch (id_map(psrvr, &ofp->o_opts)) {
1268 case ID_MAP_NO:
1269 break;
1270 case ID_MAP_REJ:
1271 return;
1272 case ID_MAP_SELF:
1273 psrvr = my_srvr_id;
1274 break;
1275 }
1276 new_path_idp->hi = psrvr>>8;
1277 new_path_idp->lo = psrvr;
1278 ++new_path_idp;
1279 }
1280
1281 } else {
1282 /* Do not send translated server-ID declarations
1283 * or checksums in our own or in translated server-ID
1284 * reports that we wouldn't have kept if we had
1285 * received the original reports */
1286 if (srvr_mapped == ID_MAP_SELF) {
1287 if (type == DCC_CK_SRVR_ID)
1288 return;
1289 if (DB_TEST_NOKEEP(db_parms.nokeep_cks, type))
1290 continue;
1291 }
1292 /* Do not send reports from the target to the target
1293 * unless the report is a Server-ID declaration */
1294 if (reflecting && type != DCC_CK_SRVR_ID)
1295 return;
1296
1297 /* send everything else */
1298 buf_ck->type = type;
1299 buf_ck->len = sizeof(*buf_ck);
1300 memcpy(buf_ck->sum, cur_rcd_ck->sum,
1301 sizeof(buf_ck->sum));
1302 ++buf_ck;
1303 ++rp->num_cks;
1304
1305 non_path = 1;
1306 if (all_spam
1307 && DB_TGTS_CK(cur_rcd_ck) != DCC_TGTS_TOO_MANY)
1308 all_spam = 0;
1309 }
1310 }
1311
1312 /* quit if we found nothing but the path to send */
1313 if (!non_path)
1314 return;
1315
1316 if (all_spam && srvr == my_srvr_id)
1317 tgts = DCC_TGTS_TOO_MANY;
1318 tgts = htonl(tgts);
1319 memcpy(&rp->tgts, &tgts, sizeof(rp->tgts));
1320
1321 ofp->obuf_len += (char *)buf_ck - (char *)rp;
1322 ++ofp->cnts.out_reports;
1323 ofp->xmit_pos = ofp->cur_pos;
1324 }
1325
1326
1327
1328 /* send reports from the database to a peer DCC server
1329 * This routine only fills the buffer. The buffer is eventually
1330 * written by oflod_write(). */
1331 static void
1332 oflod_fill(OFLOD_INFO *ofp)
1333 {
1334 int cur_rcd_len;
1335
1336 /* stop when things are not ready or shutting down */
1337 if (!(ofp->flags & OFLOD_FG_CONNECTED)
1338 || (ofp->flags & OFLOD_FG_SHUTDOWN)
1339 || (ofp->flags & OFLOD_FG_NEW))
1340 return;
1341
1342 /* stop when we are about to clean the database for a deletion so
1343 * that we will not be shut down cleaning along with our neighbors */
1344 if (need_del_dbclean)
1345 return;
1346
1347 if (db_failed_line)
1348 return;
1349
1350 while (ofp->obuf_len < sizeof(ofp->obuf) - sizeof(DCC_FLOD_RPT)) {
1351 /* start a new entry unless we are shutting down */
1352 if (ofp->flags & OFLOD_FG_SHUTDOWN_REQ) {
1353 oflod_shutdown(ofp);
1354 break;
1355 }
1356
1357 if (ofp->cur_pos >= db_csize) {
1358 /* nothing to send
1359 * shut down if needed */
1360 if (ofp->xmit_pos == ofp->recv_pos)
1361 ofp->mp->confirm_pos = ofp->cur_pos;
1362 if (ofp->mp->confirm_pos >= ofp->rewind_pos)
1363 ofp->mp->flags &= ~FLODMAP_FG_REWINDING;
1364 break;
1365 }
1366
1367 /* don't try to look at reports crossing page bounardies */
1368 if (ofp->cur_pos%db_pagesize >= db_page_max) {
1369 ofp->cur_pos += DB_RCD_HDR_LEN;
1370 continue;
1371 }
1372
1373 if (!db_map_rcd(dcc_emsg, &db_sts.rcd, ofp->cur_pos,
1374 &cur_rcd_len)) {
1375 dcc_error_msg("oflod_fill() starting at "L_HPAT
1376 " for %s: %s",
1377 ofp->cur_pos, ofp_rem_str(ofp), dcc_emsg);
1378 ofp->cur_pos = db_csize;
1379 break;
1380 }
1381
1382 if (DB_NUM_CKS(db_sts.rcd.d.r) > DCC_DIM_CKS) {
1383 dcc_error_msg("impossible %d checksums in "L_HPAT,
1384 DB_NUM_CKS(db_sts.rcd.d.r),
1385 ofp->cur_pos);
1386 ofp->cur_pos = db_csize;
1387 break;
1388 }
1389
1390 /* send the record */
1391 ofp->cur_pos += cur_rcd_len;
1392 put_rcd_obuf(ofp, db_sts.rcd.d.r);
1393 }
1394
1395 if (oflods_max_cur_pos < ofp->cur_pos)
1396 oflods_max_cur_pos = ofp->cur_pos;
1397 }
1398
1399
1400
1401 /* figure out what version to tell the peer */
1402 const char *
1403 version_str(OFLOD_INFO *ofp)
1404 {
1405 if (ofp->oversion == 0)
1406 return DCC_FLOD_VERSION_CUR_STR;
1407 #ifdef DCC_FLOD_VERSION7
1408 if (ofp->oversion == DCC_FLOD_VERSION7)
1409 return DCC_FLOD_VERSION_CUR_STR;
1410 #endif
1411 dcc_logbad(EX_SOFTWARE, "unknown ofp->oversion=%d",
1412 ofp->oversion);
1413 }
1414
1415
1416
1417 /* reset connect() or daily complaint timers and keep backoffs steady */
1418 void
1419 flod_try_again(OFLOD_INFO *ofp)
1420 {
1421 FLOD_MMAP *mp = ofp->mp;
1422
1423 mp = ofp->mp;
1424 if (!mp)
1425 return;
1426
1427 /* ordinary connect() timer should fire immediately */
1428 mp->otimers.retry_secs /= 2;
1429 mp->otimers.retry = 0;
1430
1431 /* delay complaints for passive connections */
1432 if (DCC_IS_TIME(db_time.tv_sec+FLOD_IN_COMPLAIN_NOW,
1433 mp->otimers.msg, mp->otimers.msg_secs)) {
1434 mp->otimers.msg_secs = FLOD_IN_COMPLAIN_NOW;
1435 mp->otimers.msg = db_time.tv_sec + FLOD_IN_COMPLAIN_NOW;
1436 }
1437
1438 mp->oflod_err.msg[0] = '\0';
1439 mp->oflod_err.trace_msg[0] = '\0';
1440
1441 /* give the peer a chance to connect to us */
1442 mp->itimers.retry_secs /= 2;
1443 if (mp->itimers.retry_secs < FLOD_SOCKS_SOCKS_IRETRY)
1444 mp->itimers.retry_secs = FLOD_SOCKS_SOCKS_IRETRY;
1445 mp->itimers.retry = db_time.tv_sec + FLOD_SOCKS_SOCKS_IRETRY;
1446
1447 if (DCC_IS_TIME(db_time.tv_sec+FLOD_IN_COMPLAIN_NOW,
1448 mp->itimers.msg, mp->itimers.msg_secs)) {
1449 mp->itimers.msg_secs = FLOD_IN_COMPLAIN_NOW;
1450 mp->itimers.msg = db_time.tv_sec + FLOD_IN_COMPLAIN_NOW;
1451 }
1452
1453 mp->iflod_err.msg[0] = '\0';
1454 mp->iflod_err.trace_msg[0] = '\0';
1455 }
1456
1457
1458
1459 /* authenticate the outgoing start of a flood */
1460 const char * /* error message */
1461 flod_sign(OFLOD_INFO *ofp, u_char in, void *buf, int buf_len)
1462 {
1463 const ID_TBL *tp;
1464
1465 tp = find_id_tbl(ofp->out_passwd_id);
1466 if (!tp)
1467 return DCC_FLOD_PASSWD_ID_MSG;
1468 if (tp->cur_passwd[0] == '\0')
1469 return "no password for passwd-ID";
1470
1471 if (tp->next_passwd[0] != '\0') {
1472 ofp->flags |= OFLOD_FG_HAVE_2PASSWD;
1473 } else {
1474 ofp->flags &= ~OFLOD_FG_HAVE_2PASSWD;
1475 ofp->mp->flags &= ~FLODMAP_FG_USE_2PASSWD;
1476 }
1477 if (ofp->mp->flags & FLODMAP_FG_USE_2PASSWD) {
1478 if (in)
1479 ofp->flags |= OFLOD_FG_I_USED_2PASSWD;
1480 else
1481 ofp->flags |= OFLOD_FG_O_USED_2PASSWD;
1482 TMSG1_FLOD(ofp, "try 2nd password to %s", ofp_rem_str(ofp));
1483 dcc_sign(tp->next_passwd, sizeof(tp->next_passwd),
1484 buf, buf_len);
1485 } else {
1486 if (in)
1487 ofp->flags &= ~OFLOD_FG_I_USED_2PASSWD;
1488 else
1489 ofp->flags &= ~OFLOD_FG_O_USED_2PASSWD;
1490 dcc_sign(tp->cur_passwd, sizeof(tp->cur_passwd),
1491 buf, buf_len);
1492 }
1493 return 0;
1494 }
1495
1496
1497
1498 /* finish connecting output flood by sending our version number and signature
1499 * to authenticate ourself */
1500 u_char /* 1=ok, 0=close output stream */
1501 oflod_connect_fin(OFLOD_INFO *ofp)
1502 {
1503 DCC_SRVR_ID id;
1504 DCC_FNM_LNO_BUF fnm_buf;
1505 const char *emsg;
1506
1507 ofp->oflod_alive = db_time.tv_sec;
1508 ofp->flags |= (OFLOD_FG_CONNECTED | OFLOD_FG_NEW);
1509 save_flod_cnts(ofp);
1510
1511 ofp->recv_pos = ofp->xmit_pos = ofp->cur_pos = ofp->mp->confirm_pos;
1512 get_oflods_max_cur_pos();
1513
1514 ofp->ibuf_len = 0;
1515
1516 /* convince the peer we're sane by sending our version string */
1517 ofp->obuf_len = sizeof(ofp->obuf.s.v);
1518 memset(&ofp->obuf.s.v, 0, sizeof(ofp->obuf.s.v));
1519 strcpy(ofp->obuf.s.v.body.str, version_str(ofp));
1520 id = htons(my_srvr_id);
1521 memcpy(ofp->obuf.s.v.body.sender_srvr_id, &id,
1522 sizeof(ofp->obuf.s.v.body.sender_srvr_id));
1523
1524 emsg = flod_sign(ofp, 0, &ofp->obuf.s.v, ofp->obuf_len);
1525 if (emsg) {
1526 rpt_err(ofp, 0, 0, "%s %d%s",
1527 emsg, ofp->out_passwd_id,
1528 fnm_lno(&fnm_buf, flod_path, ofp->lno));
1529 return 0;
1530 }
1531
1532 TMSG1_FLOD(ofp, "start flood to %s", ofp_rem_str(ofp));
1533
1534 /* all is well, so forget old complaints */
1535 if (!(ofp->mp->flags & FLODMAP_FG_OUT_SRVR)) {
1536 ofp->mp->oflod_err.msg[0] = '\0';
1537 ofp->mp->oflod_err.trace_msg[0] = '\0';
1538 }
1539
1540 oflod_write(ofp); /* send our authentication */
1541
1542 return 1;
1543 }
1544
1545
1546
1547 static void
1548 oflod_backoff(OFLOD_INFO *ofp, u_char fast)
1549 {
1550 FLOD_MMAP *mp;
1551 int max;
1552
1553 mp = ofp->mp;
1554 mp->otimers.retry_secs *= 2;
1555 max = fast ? FLOD_SUBMAX_RETRY_SECS : FLOD_MAX_RETRY_SECS;
1556 if (mp->otimers.retry_secs > max)
1557 mp->otimers.retry_secs = max;
1558 else if (mp->otimers.retry_secs < FLOD_RETRY_SECS)
1559 mp->otimers.retry_secs = FLOD_RETRY_SECS;
1560 }
1561
1562
1563
1564 /* start to connect an out-going flood */
1565 static int /* -1=failure, 0=not yet, 1=done */
1566 oflod_connect_start(OFLOD_INFO *ofp, const char *syscall_name)
1567 {
1568 DCC_FNM_LNO_BUF fnm_buf;
1569 int i;
1570
1571 ofp->mp->flags &= ~FLODMAP_FG_OUT_SRVR;
1572
1573 if (ofp->o_opts.flags & FLOD_OPT_SOCKS) {
1574 i = Rconnect(ofp->soc, &ofp->rem_su.sa,
1575 DCC_SU_LEN(&ofp->rem_su));
1576 } else {
1577 /* must be NAT */
1578 i = connect(ofp->soc, &ofp->rem_su.sa,
1579 DCC_SU_LEN(&ofp->rem_su));
1580 }
1581 if (0 > i && errno != EISCONN) {
1582 if (errno == EAGAIN
1583 || errno == EINPROGRESS
1584 || errno == EALREADY) {
1585 rpt_err(ofp, 1, 0, "starting flood to %s",
1586 ofp_rem_str(ofp));
1587 return 0;
1588 }
1589
1590 /* Several UNIX-like systems return EINVAL for the second
1591 * connect() after a Unreachable ICMP message or timeout.
1592 * It is lame to obscure the real errno, but it is worse
1593 * to worry users and deal with their concerns. */
1594 rpt_err(ofp,
1595 (errno == EINVAL || errno == ECONNABORTED
1596 || errno == ECONNRESET || errno == ETIMEDOUT
1597 || errno == ECONNREFUSED),
1598 0, "%s(%s%s): %s",
1599 syscall_name,
1600 ofp_rem_str(ofp),
1601 fnm_lno(&fnm_buf, flod_path, ofp->lno),
1602 errno == EINVAL
1603 ? "likely connection refused or local firewall"
1604 : ERROR_STR());
1605
1606 /* do not back off connection attempts for SOCKS or NAT because
1607 * the peer cannot trigger anything by connecting to us */
1608 oflod_backoff(ofp, (ofp->mp->flags & FLODMAP_FG_ACT) != 0);
1609 oflod_close(ofp, 1);
1610 return -1;
1611 }
1612
1613 if (!oflod_connect_fin(ofp)) {
1614 oflod_close(ofp, 1);
1615 return -1;
1616 }
1617
1618 return 1;
1619 }
1620
1621
1622
1623 void
1624 oflod_open(OFLOD_INFO *ofp)
1625 {
1626 DCC_FNM_LNO_BUF fnm_buf;
1627 DCC_SOCKU loc_su, su2;
1628 const DCC_SOCKU *sup;
1629 const SRVR_SOC *sp;
1630 int error;
1631
1632 if (ofp->soc >= 0
1633 || ofp->rem_hostname[0] == '\0'
1634 || OFLOD_OPT_OFF_ROGUE(ofp)
1635 || flods_st != FLODS_ST_ON
1636 || (ofp->mp->flags & FLODMAP_FG_PASSIVE))
1637 return;
1638
1639 if (!DB_IS_TIME(ofp->mp->otimers.retry, ofp->mp->otimers.retry_secs))
1640 return;
1641
1642 if (!flod_names_resolve_start())
1643 return; /* wait for name resolution */
1644
1645 if (ofp->mp->rem_su.sa.sa_family == AF_UNSPEC) {
1646 rpt_err(ofp, 0, 0, "peer name %s: '%s'%s",
1647 ofp->rem_hostname,
1648 DCC_HSTRERROR(ofp->mp->host_error),
1649 fnm_lno(&fnm_buf, flod_path, ofp->lno));
1650 oflod_backoff(ofp, 0);
1651 oflod_close(ofp, 1);
1652 return;
1653 }
1654 if (!LITCMP(ofp->mp->oflod_err.msg, "peer name "))
1655 ofp->mp->oflod_err.msg[0] = '\0';
1656
1657 ofp->rem_su = ofp->mp->rem_su;
1658
1659 ofp->soc = socket(ofp->rem_su.sa.sa_family, SOCK_STREAM, 0);
1660 if (ofp->soc < 0) {
1661 rpt_err(ofp, 0, 0, "flood socket(%s): %s",
1662 ofp_rem_str(ofp), ERROR_STR());
1663 oflod_close(ofp, 1);
1664 return;
1665 }
1666 ++oflods.open;
1667
1668 if (!set_flod_socket(ofp, 0, ofp->soc,
1669 ofp->rem_hostname, &ofp->rem_su)) {
1670 oflod_close(ofp, 1);
1671 return;
1672 }
1673
1674 memset(&loc_su, 0, sizeof(loc_su));
1675 if (ofp->loc_hostname[0] != '\0'
1676 || ofp->loc_port != 0) {
1677 /* Resolve the local host name.
1678 * This should not take significant time because
1679 * the local hostnames should be locally known. That
1680 * implies that we don't need to use a separate thread. */
1681 if (ofp->loc_hostname[0] != '\0') {
1682 dcc_host_lock();
1683 if (!dcc_get_host(ofp->loc_hostname,
1684 ofp->rem_su.sa.sa_family == AF_INET
1685 ? 0 : 1,
1686 &error)) {
1687 dcc_error_msg("flood local name %s: %s%s",
1688 ofp->loc_hostname,
1689 DCC_HSTRERROR(error),
1690 fnm_lno(&fnm_buf, flod_path,
1691 ofp->lno));
1692 } else {
1693 /* match local address family to remote */
1694 sup = dcc_hostaddrs;
1695 for (;;) {
1696 if (sup->sa.sa_family
1697 == ofp->rem_su.sa.sa_family) {
1698 loc_su = *sup;
1699 break;
1700 }
1701 if (++sup >= dcc_hostaddrs_end) {
1702 dcc_error_msg("family matching %s"
1703 " not available for %s",
1704 ofp_rem_str(ofp),
1705 ofp->loc_hostname);
1706 ofp->loc_hostname[0] = '\0';
1707 break;
1708 }
1709 }
1710 }
1711 dcc_host_unlock();
1712 }
1713 }
1714
1715 /* If there is a single "-a address" other than localhost
1716 * and of the right family, then default to it.
1717 * but only if we are not trying to get past a firewall */
1718 if ((ofp->mp->flags & (FLODMAP_FG_SOCKS | FLODMAP_FG_NAT)) == 0
1719 && loc_su.sa.sa_family == AF_UNSPEC) {
1720 for (sp = srvr_socs; sp; sp = sp->fwd) {
1721 if (dcc_ipv6sutoipv4(&su2, &sp->su)
1722 && su2.ipv4.sin_addr.s_addr == ntohl(0x7f000001))
1723 continue;
1724 if (sp->su.sa.sa_family != ofp->rem_su.sa.sa_family)
1725 continue;
1726 if (loc_su.sa.sa_family != AF_UNSPEC) {
1727 /* more than one, so give up */
1728 memset(&loc_su, 0, sizeof(loc_su));
1729 break;
1730 }
1731 loc_su = sp->su;
1732 }
1733 }
1734
1735 if (loc_su.sa.sa_family != AF_UNSPEC
1736 || ofp->loc_port != 0) {
1737 loc_su.sa.sa_family = ofp->rem_su.sa.sa_family;
1738 *DCC_SU_PORTP(&loc_su) = ofp->loc_port;
1739 if (0 > bind(ofp->soc, &loc_su.sa, DCC_SU_LEN(&loc_su)))
1740 dcc_error_msg("bind(flood %s%s): %s",
1741 dcc_su2str_err(&loc_su),
1742 fnm_lno(&fnm_buf, flod_path, ofp->lno),
1743 ERROR_STR());
1744 }
1745
1746 oflod_connect_start(ofp, "connect");
1747 }
1748
1749
1750
1751 void
1752 oflod_write(OFLOD_INFO *ofp)
1753 {
1754 int i;
1755
1756 if (ofp->obuf_len == 0) {
1757 if (!(ofp->flags & OFLOD_FG_CONNECTED)
1758 && 0 >= oflod_connect_start(ofp, "connect2"))
1759 return;
1760 oflod_fill(ofp);
1761 if (ofp->obuf_len == 0)
1762 return;
1763 }
1764
1765 if (ofp->o_opts.flags & FLOD_OPT_SOCKS)
1766 i = Rsend(ofp->soc, &ofp->obuf.b, ofp->obuf_len, 0);
1767 else
1768 i = send(ofp->soc, &ofp->obuf.b, ofp->obuf_len, 0);
1769 if (i > 0) {
1770 ofp->obuf_len -= i;
1771 if (ofp->obuf_len != 0)
1772 memmove(&ofp->obuf.b[0], &ofp->obuf.b[i],
1773 ofp->obuf_len);
1774 ofp->oflod_alive = db_time.tv_sec;
1775
1776 /* fill buffer so that the main loop will
1777 * ask select() when we can send again */
1778 oflod_fill(ofp);
1779 return;
1780 }
1781
1782 /* we had an error or EOF */
1783 if (i < 0) {
1784 /* oflod_write() is called only when select() has said that
1785 * we can send() and so we should never see the non-blocking
1786 * send() fail.
1787 * However, Solaris nevertheless sometimes says EAGAIN */
1788 if (DCC_BLOCK_ERROR()) {
1789 ofp->flags |= OFLOD_FG_EAGAIN;
1790 TMSG2_FLOD(ofp, "pause after send(flood to %s): %s",
1791 ofp_rem_str(ofp), ERROR_STR());
1792 return;
1793 }
1794
1795 rpt_err(ofp, 0, 0, "send(flood to %s): %s",
1796 ofp_rem_str(ofp), ERROR_STR());
1797 } else {
1798 rpt_err(ofp, 0, 0, "premature end of flood to %s",
1799 ofp_rem_str(ofp));
1800 }
1801 oflod_read(ofp); /* get any last error message */
1802 oflod_close(ofp, 1);
1803 }
1804
1805
1806 /* parse end of transmission message for familiar complaints
1807 * to adjust retry timer */
1808 int /* 1=try again soon, 0=ok, -1=failure */
1809 oflod_parse_eof(OFLOD_INFO *ofp, u_char in,
1810 const DCC_FLOD_END *end, int msg_len)
1811 {
1812 if (msg_len >= LITZ(DCC_FLOD_OK_STR)
1813 && !strncmp(end->msg, DCC_FLOD_OK_STR,
1814 LITZ(DCC_FLOD_OK_STR))) {
1815 return 0; /* success */
1816 }
1817
1818 if (msg_len >= LITZ(DCC_FLOD_BAD_AUTH_MSG)
1819 && !strncmp(end->msg, DCC_FLOD_BAD_AUTH_MSG,
1820 LITZ(DCC_FLOD_BAD_AUTH_MSG))) {
1821 /* try the second password if available
1822 * after the peer rejects the first */
1823 if (in) {
1824 if ((ofp->flags & OFLOD_FG_HAVE_2PASSWD)
1825 && !(ofp->flags & OFLOD_FG_I_USED_2PASSWD)) {
1826 ofp->flags |= OFLOD_FG_I_USED_2PASSWD;
1827 ofp->mp->flags |= FLODMAP_FG_USE_2PASSWD;
1828 return 1; /* try again soon */
1829 }
1830 } else {
1831 if ((ofp->flags & OFLOD_FG_HAVE_2PASSWD)
1832 && !(ofp->flags & OFLOD_FG_O_USED_2PASSWD)) {
1833 ofp->flags |= OFLOD_FG_O_USED_2PASSWD;
1834 ofp->mp->flags |= FLODMAP_FG_USE_2PASSWD;
1835 return 1; /* try again soon */
1836 }
1837 }
1838 return -1;
1839 }
1840
1841 if (msg_len > LITZ(DCC_FLOD_BAD_VER_MSG)
1842 && !strncmp(end->msg, DCC_FLOD_BAD_VER_MSG,
1843 LITZ(DCC_FLOD_BAD_VER_MSG))) {
1844 /* notice if this peer demands a version
1845 * other than what we have been trying */
1846 if (ofp->oversion != ofp->mp->iversion) {
1847 ofp->oversion = ofp->mp->iversion;
1848 return 1; /* try again soon */
1849 }
1850 return -1;
1851 }
1852
1853 return -1;
1854 }
1855
1856
1857
1858 /* see what the target has to say about the reports we have been sending */
1859 void
1860 oflod_read(OFLOD_INFO *ofp)
1861 {
1862 int used, req_len, recv_len;
1863 DB_PTR pos;
1864 int fail;
1865
1866 again:;
1867 req_len = sizeof(ofp->ibuf) - ofp->ibuf_len;
1868 if (ofp->o_opts.flags & FLOD_OPT_SOCKS)
1869 recv_len = Rrecv(ofp->soc, &ofp->ibuf.b[ofp->ibuf_len],
1870 req_len, 0);
1871 else
1872 recv_len = recv(ofp->soc, &ofp->ibuf.b[ofp->ibuf_len],
1873 req_len, 0);
1874 if (recv_len < 0) {
1875 if (!DCC_BLOCK_ERROR()) {
1876 rpt_err(ofp, 1, 0, "recv(outgoing flood %s): %s",
1877 ofp_rem_str(ofp), ERROR_STR());
1878 oflod_close(ofp, 1);
1879 }
1880 return;
1881 }
1882 if (recv_len > 0) {
1883 /* the connection is alive and working */
1884 if (!(ofp->flags & (OFLOD_FG_SHUTDOWN_REQ | OFLOD_FG_SHUTDOWN)))
1885 ofp->oflod_alive = db_time.tv_sec;
1886 ofp->flags &= ~OFLOD_FG_NEW;
1887 if (!(ofp->flags & (OFLOD_FG_SHUTDOWN_REQ
1888 | OFLOD_FG_SHUTDOWN)))
1889 ofp->oflod_alive = db_time.tv_sec;
1890
1891 /* limit the backoff for incoming SOCKS connection attempts
1892 * while the outgoing connection is working */
1893 DB_ADJ_TIMER(&ofp->mp->itimers.retry,
1894 &ofp->mp->itimers.retry_secs,
1895 FLOD_RETRY_SECS);
1896 }
1897
1898 ofp->ibuf_len += recv_len;
1899 while (ofp->ibuf_len >= ISZ(ofp->ibuf.r.pos)) {
1900 used = sizeof(ofp->ibuf.r.pos);
1901
1902 pos = flod_pos2db_ptr(ofp->ibuf.r.pos);
1903 switch ((DCC_FLOD_POS_OPS)pos) {
1904 case DCC_FLOD_POS_END:
1905 /* Wait for all of the final status message or
1906 * until the target closes the TCP connection.
1907 * Do not worry if the target stops without
1908 * asking nicely, since at worst we will
1909 * resend whatever was in the pipe next time. */
1910 if (ofp->ibuf_len <= ISZ(ofp->ibuf.r.end)
1911 && recv_len != 0)
1912 goto again;
1913 /* shut down after trying to recognize
1914 * a complaint from the target */
1915 fail = oflod_parse_eof(ofp, 0,
1916 &ofp->ibuf.r.end,
1917 ofp->ibuf_len - FLOD_END_OVHD);
1918 rpt_err(ofp, fail>=0, 0,
1919 "outgoing flood end 'status from %s \"%.*s\"'",
1920 ofp_rem_str(ofp),
1921 ofp->ibuf_len - FLOD_END_OVHD,
1922 ofp->ibuf.r.end.msg);
1923 if (fail < 0)
1924 oflod_backoff(ofp, 0);
1925 oflod_close(ofp, fail<0);
1926 return;
1927
1928 case DCC_FLOD_POS_END_REQ:
1929 /* try to update our pointers and shutdown() */
1930 start_shutdown(ofp);
1931 ofp->mp->otimers.retry_secs = FLOD_RETRY_SECS;
1932 ofp->mp->otimers.retry = (db_time.tv_sec
1933 + FLOD_RETRY_SECS);
1934 if (!(ofp->mp->flags & FLODMAP_FG_PASSIVE))
1935 TMSG2_FLOD(ofp, "postpone restarting flood to"
1936 " %s for %d"
1937 " seconds after end request",
1938 ofp_rem_str(ofp), FLOD_RETRY_SECS);
1939 break;
1940
1941 case DCC_FLOD_POS_NOTE:
1942 /* wait until we get the length of the complaint */
1943 if (ofp->ibuf_len < FLOD_NOTE_OVHD)
1944 goto again;
1945 used = ofp->ibuf.r.note.len;
1946 if (used > ISZ(ofp->ibuf.r.note)
1947 || used <= FLOD_NOTE_OVHD) {
1948 rpt_err(ofp, 0,0,
1949 "bogus outgoing flood note length"
1950 " %d from %s",
1951 used, ofp_rem_str(ofp));
1952 oflod_close(ofp, 1);
1953 return;
1954 }
1955 if (ofp->ibuf_len < used)
1956 goto again;
1957 TMSG3_FLOD(ofp, "outgoing flood note from %s: \"%.*s\"",
1958 ofp_rem_str(ofp),
1959 used-FLOD_NOTE_OVHD, ofp->ibuf.r.note.str);
1960 break;
1961
1962 case DCC_FLOD_POS_COMPLAINT:
1963 /* wait until we get the length of the complaint */
1964 if (ofp->ibuf_len < FLOD_NOTE_OVHD)
1965 goto again;
1966 used = ofp->ibuf.r.note.len;
1967 if (used > ISZ(ofp->ibuf.r.note)
1968 || used <= FLOD_NOTE_OVHD) {
1969 rpt_err(ofp, 0, 0,
1970 "bogus outgoing flood complaint length"
1971 " %d from %s",
1972 used, ofp_rem_str(ofp));
1973 oflod_close(ofp, 1);
1974 return;
1975 }
1976 if (ofp->ibuf_len < used)
1977 goto again;
1978 if (CK_FLOD_CNTERR(&ofp->lc.complaint))
1979 flod_cnterr(&ofp->lc.complaint,
1980 "outgoing flood complaint from %s:"
1981 " %.*s",
1982 ofp_rem_str(ofp),
1983 used - FLOD_NOTE_OVHD,
1984 ofp->ibuf.r.note.str);
1985 break;
1986
1987 case DCC_FLOD_POS_REWIND:
1988 dcc_trace_msg("flood rewind request from %s",
1989 ofp_rem_str(ofp));
1990 ofp->mp->flags |= FLODMAP_FG_REWINDING;
1991 ofp->cur_pos = ofp->mp->confirm_pos = DB_PTR_BASE;
1992 ofp->recv_pos = ofp->xmit_pos = DB_PTR_BASE;
1993 ofp->rewind_pos = db_csize;
1994 get_oflods_max_cur_pos();
1995 oflod_fill(ofp);
1996 break;
1997
1998 case DCC_FLOD_POS_FFWD_IN:
1999 dcc_trace_msg("FFWD its input from %s",
2000 ofp_rem_str(ofp));
2001 ofp->cur_pos = db_csize;
2002 get_oflods_max_cur_pos();
2003 break;
2004
2005
2006 default:
2007 /* The position from the peer must be one we sent,
2008 * and in the window we expect unless our
2009 * window has been broken by rewinding.
2010 * Even if our window is broken, the position must
2011 * be reasonable. */
2012 if ((pos < ofp->recv_pos
2013 || pos > ofp->xmit_pos)
2014 && (!(ofp->mp->flags & FLODMAP_FG_REWINDING)
2015 || pos < DCC_FLOD_POS_MIN
2016 || pos > db_csize)) {
2017 rpt_err(ofp, 0, 0,
2018 "bogus confirmed flood position"
2019 " "L_HPAT" from %s;"
2020 " recv_pos="L_HPAT" xmit_pos="L_HPAT,
2021 pos, ofp_rem_str(ofp),
2022 ofp->recv_pos, ofp->xmit_pos);
2023 oflod_close(ofp, 1);
2024 return;
2025 }
2026 ofp->recv_pos = pos;
2027 if (ofp->xmit_pos == ofp->recv_pos)
2028 ofp->mp->confirm_pos = ofp->cur_pos;
2029 else if (ofp->mp->confirm_pos < ofp->recv_pos)
2030 ofp->mp->confirm_pos = ofp->recv_pos;
2031
2032 /* things are going ok, so reset the connect() backoff
2033 * and the no-connection complaint */
2034 ofp->mp->otimers.retry_secs = 0;
2035 ofp->mp->otimers.msg_secs = FLOD_IN_COMPLAIN1;
2036 ofp->mp->otimers.msg = (db_time.tv_sec
2037 + FLOD_IN_COMPLAIN1);
2038 break;
2039 }
2040
2041 ofp->ibuf_len -= used;
2042 if (ofp->ibuf_len == 0)
2043 return;
2044 if (ofp->ibuf_len < 0)
2045 dcc_logbad(EX_SOFTWARE, "ofp->ibuf_len=%d",
2046 ofp->ibuf_len);
2047 /* assume there will rarely be more than one position
2048 * in the buffer */
2049 memmove(ofp->ibuf.b, &ofp->ibuf.b[used], ofp->ibuf_len);
2050 }
2051
2052 if (recv_len == 0) {
2053 /* before closing, the peer is supposed to send a
2054 * "position" of DCC_FLOD_POS_END followed by
2055 * an ASCII message */
2056 if (ofp->ibuf_len != 0)
2057 rpt_err(ofp, 0, 0,
2058 "truncated outgoing flood response from %s",
2059 ofp_rem_str(ofp));
2060 else
2061 rpt_err(ofp, 0, 0,
2062 "missing outgoing flood response from %s",
2063 ofp_rem_str(ofp));
2064 oflod_close(ofp, 1);
2065 }
2066 }
2067
2068
2069
2070 static void
2071 oflods_ck(void)
2072 {
2073 OFLOD_INFO *ofp;
2074
2075 for (ofp = oflods.infos; ofp <= LAST(oflods.infos); ++ofp) {
2076 if (ofp->rem_hostname[0] == '\0')
2077 break;
2078
2079 if (ofp->flags & OFLOD_FG_EAGAIN) {
2080 TMSG1_FLOD(ofp, "resume flooding %s after EAGAIN",
2081 ofp->rem_hostname);
2082 ofp->flags &= ~OFLOD_FG_EAGAIN;
2083 }
2084
2085 if (!(ofp->flags & OFLOD_FG_CONNECTED))
2086 continue;
2087
2088 /* close the peer has failed to respond to a shutdown request */
2089 if (ofp->flags & (OFLOD_FG_SHUTDOWN_REQ | OFLOD_FG_SHUTDOWN)) {
2090 if (stopint && OFP_DEAD(ofp, SHUTDOWN_DELAY)) {
2091 rpt_err(ofp, 1, 0,
2092 "stopping; force close flood to %s",
2093 ofp_rem_str(ofp));
2094 oflod_close(ofp, 0);
2095
2096 } else if (OFP_DEAD(ofp, KEEPALIVE_OUT_STOP)) {
2097 rpt_err(ofp, 1, 0,
2098 "off; force close flood to %s",
2099 ofp_rem_str(ofp));
2100 oflod_close(ofp, 0);
2101 }
2102 continue;
2103 }
2104
2105 /* Shut down any streams that have been quiet for too long.
2106 * If the TCP connection is healthy we should at least have
2107 * received keep alive position repetitions or "are you there?"
2108 * notes from the peer. */
2109 if (OFP_DEAD(ofp, KEEPALIVE_OUT)) {
2110 rpt_err(ofp, 1, 0,
2111 "keepalive start shutdown flood to %s",
2112 ofp_rem_str(ofp));
2113 start_shutdown(ofp);
2114 continue;
2115 }
2116 }
2117 }
2118
2119
2120
2121 static void
2122 oflods_stop(u_char force)
2123 {
2124 OFLOD_INFO *ofp;
2125
2126 if (!flod_mmaps)
2127 return;
2128
2129 for (ofp = oflods.infos; ofp <= LAST(oflods.infos); ++ofp) {
2130 if (ofp->rem_hostname[0] == '\0')
2131 break;
2132 if (ofp->soc < 0)
2133 continue;
2134 if (force || !(ofp->flags & OFLOD_FG_CONNECTED)) {
2135 rpt_err(ofp, 1, 0, "halting flood to %s",
2136 ofp_rem_str(ofp));
2137 oflod_close(ofp, 0);
2138 } else if (!(ofp->flags & (OFLOD_FG_SHUTDOWN_REQ
2139 | OFLOD_FG_SHUTDOWN))) {
2140 rpt_err(ofp, 1, 0, "stopping flood to %s",
2141 ofp_rem_str(ofp));
2142 start_shutdown(ofp);
2143 }
2144 }
2145
2146 if (oflods.open == 0 && iflods.open == 0)
2147 oflods_clear();
2148 }
2149
2150
2151
2152 void
2153 flods_stop(const char *iflod_msg, u_char force)
2154 {
2155 flods_st = FLODS_ST_OFF;
2156 iflods_stop(iflod_msg, force);
2157 oflods_stop(force);
2158 }
2159
2160
2161
2162 /* (re)start listening for incoming floods and sending outgoing floods */
2163 void
2164 flods_restart(const char *msg, u_char force_ck)
2165 {
2166 if (FLODS_OK())
2167 flods_st = FLODS_ST_RESTART;
2168 iflods_stop(msg, 0);
2169 flods_ck(force_ck);
2170 }
2171
2172
2173
2174 /* load the ids file if it has changed */
2175 int /* -1=our ID missing, 0=sick file */
2176 check_load_ids(u_char mode) /* 0=if needed, 1=reboot, 2=new db */
2177 {
2178 const ID_TBL *tp;
2179 int result;
2180
2181 result = load_ids(dcc_emsg, my_srvr_id, &tp, mode ? 1 : 0 );
2182 if (result == 2)
2183 return 1;
2184 if (result <= 0)
2185 return result;
2186
2187 if (mode == 0 || ( mode == 2 && db_debug))
2188 dcc_trace_msg("reloaded %s", ids_path);
2189
2190 if (mode == 0) {
2191 if (flod_mtime > 1)
2192 flod_mtime = 1;
2193 flods_restart("restart flooding with new IDs", 0);
2194 }
2195
2196 return 1;
2197 }
2198
2199
2200 /* called periodically and at need */
2201 void
2202 flods_ck(u_char force)
2203 {
2204 static int map_delayed;
2205 IFLOD_INFO *ifp;
2206 OFLOD_INFO *ofp;
2207 struct stat flod_sb;
2208 struct timeval;
2209 DCC_TS past, present;
2210 int rcd_len;
2211 int work;
2212 u_char loaded; /* mapped flod.map file just for this */
2213
2214 if (force) /* force hostname resolution */
2215 got_hosts = 0;
2216
2217 for (ifp = iflods.infos; ifp <= LAST(iflods.infos); ++ifp) {
2218 if (ifp->soc < 0)
2219 continue;
2220
2221 /* end incoming connections that are not completed in time */
2222 ofp = ifp->ofp;
2223 if (!ofp) {
2224 iflod_read(ifp);
2225 if (ifp->soc < 0)
2226 continue;
2227 ofp = ifp->ofp;
2228 if (!ofp) {
2229 if (IFP_DEAD(ifp, KEEPALIVE_IN_STOP))
2230 iflod_close(ifp, 1, 1, 0,
2231 "no authentication from %s",
2232 ifp_rem_str(ifp));
2233 continue;
2234 }
2235 }
2236
2237 /* allow more complaints */
2238 if (DB_IS_TIME(ofp->limit_reset, FLOD_LIM_CLEAR_SECS)
2239 || force) {
2240 FLOD_LIMCNT *lc;
2241
2242 complained_many_iflods = 0;
2243 for (lc = (FLOD_LIMCNT *)&ofp->lc;
2244 lc < (FLOD_LIMCNT *)(sizeof(ofp->lc)
2245 +(char *)&ofp->lc);
2246 ++lc) {
2247 lc->lim = lc->cur;
2248 }
2249 ofp->limit_reset = db_time.tv_sec+FLOD_LIM_CLEAR_SECS;
2250 }
2251
2252 if (!(ifp->flags & IFLOD_FG_VERS_CK))
2253 continue; /* done if peer not really known */
2254
2255 save_flod_cnts(ofp);
2256
2257 if (!IFP_DEAD(ifp, KEEPALIVE_IN)) {
2258 /* The link is warm.
2259 * Send a delayed position update if needed. */
2260 iflod_send_pos(ifp, 0);
2261
2262 } else if (ifp->flags & IFLOD_FG_END_REQ) {
2263 /* The link is cold. If we have asked the peer to
2264 * stop but it has not, then break the link. */
2265 iflod_close(ifp, 1, 0, 0, "%s ignored close request",
2266 ifp_rem_str(ifp));
2267
2268 } else {
2269 /* The link is cold., so repeat our position or
2270 * send a note as a keepalive. The will be closed if
2271 * that fails. */
2272 iflod_send_pos(ifp, 1);
2273 }
2274 }
2275
2276 if (FLODS_OK()) {
2277 /* stop and restart the pumps if the list of peers has
2278 * changed or if our map has disappeared
2279 * and if dbclean is not running */
2280 if (0 > stat(flod_path, &flod_sb)) {
2281 if (errno != ENOENT
2282 && flod_mtime != 0)
2283 dcc_error_msg("stat(%s): %s",
2284 flod_path, ERROR_STR());
2285 flod_sb.st_mtime = 0;
2286 }
2287 if (flod_mtime != 0
2288 && 0 > access(flod_mmap_path, W_OK | R_OK)) {
2289 if (errno != ENOENT)
2290 dcc_error_msg("access(%s): %s",
2291 flod_mmap_path, ERROR_STR());
2292 flod_sb.st_mtime = 0;
2293 }
2294 if (flods_st != FLODS_ST_RESTART
2295 && flod_sb.st_mtime != flod_mtime) {
2296 if (flod_mtime > 1) {
2297 dcc_trace_msg("%s has changed", flod_path);
2298 flod_mtime = 0;
2299 }
2300 flods_st = FLODS_ST_RESTART;
2301 }
2302 }
2303
2304 if (flods_st != FLODS_ST_ON) {
2305 flods_stop("", 0);
2306
2307 /* wait until the previous floods have stopped and dbclean
2308 * is not running to restart flooding */
2309 if (FLODS_OK()) {
2310 if (oflods.open != 0 || iflods.open != 0
2311 || !flod_names_resolve_ck()) {
2312 flods_st = FLODS_ST_RESTART;
2313 /* check again soon but not immediately */
2314 RUSH_NEXT_FLODS_CK();
2315 } else {
2316 if (load_flod(1))
2317 flods_st = FLODS_ST_ON;
2318 }
2319 }
2320 }
2321
2322 /* try to reap the hostname resolving child */
2323 flod_names_resolve_ck();
2324
2325 /* that is all we can do if flooding is off or dbclean is running */
2326 if (!FLODS_OK_ON()) {
2327 oflods_ck();
2328 return;
2329 }
2330
2331 iflods_listen();
2332
2333 /* generate summaries of some of our delayed reports */
2334 dcc_timeval2ts(&past, &db_time, -summarize_delay_secs);
2335 dcc_timeval2ts(&present, &db_time, 0);
2336 if (flod_mmaps) {
2337 if (flod_mmaps->delay_pos > db_csize
2338 || flod_mmaps->delay_pos < DB_PTR_BASE)
2339 flod_mmaps->delay_pos = DB_PTR_BASE;
2340 work = 0;
2341 while (flod_mmaps->delay_pos < db_csize) {
2342 if (!db_map_rcd(0, &db_sts.sumrcd,
2343 flod_mmaps->delay_pos,
2344 &rcd_len)) {
2345 flod_mmaps->delay_pos = db_csize;
2346 break;
2347 }
2348 /* only our own reports are delayed */
2349 if (DB_RCD_DELAY(db_sts.sumrcd.d.r)) {
2350 /* wait until it is time */
2351 if (dcc_ts_newer_ts(&db_sts.sumrcd.d.r->ts,
2352 &past)
2353 && !dcc_ts_newer_ts(&db_sts.sumrcd.d.r->ts,
2354 &present))
2355 break;
2356 if (!summarize_dly()) {
2357 flod_mmaps->delay_pos = db_csize;
2358 break;
2359 }
2360 }
2361 flod_mmaps->delay_pos += rcd_len;
2362
2363 if (++work >= 1000) {
2364 /* spend at most 0.5 second at this
2365 * and then let other processes run*/
2366 gettimeofday(&db_time, 0);
2367 if (tv_diff2us(&db_time, &wake_time)>DCC_US/2) {
2368 next_flods_ck = 0;
2369 break;
2370 }
2371 work = 0;
2372 }
2373 }
2374
2375 /* prime the outgoing pumps */
2376 for (ofp = oflods.infos;
2377 ofp <= LAST(oflods.infos);
2378 ++ofp) {
2379 if (ofp->rem_hostname[0] == '\0')
2380 break;
2381
2382 if (ofp->soc >= 0) {
2383 /* The connection is no longer new if it has
2384 * been a while since it was completed */
2385 if ((ofp->flags & OFLOD_FG_NEW)
2386 && DB_IS_TIME(ofp->mp->cnts.out_conn_changed
2387 + FLODS_CK_SECS,
2388 FLODS_CK_SECS))
2389 ofp->flags &= ~OFLOD_FG_NEW;
2390 oflod_fill(ofp);
2391 } else {
2392 oflod_open(ofp);
2393 }
2394
2395 iflod_socks_start(ofp);
2396 }
2397 }
2398
2399 /* complain once per day about incoming links that are not working
2400 * even if dbclean is continually running. */
2401 loaded = 0;
2402 if (flod_mmaps) {
2403 map_delayed = 0;
2404 } else if ((force || ++map_delayed > 10) && load_flod(0)) {
2405 loaded = 1;
2406 map_delayed = 0;
2407 }
2408 for (ofp = oflods.infos;
2409 ofp->rem_hostname[0] != '\0' && ofp <= LAST(oflods.infos)
2410 && flod_mmaps;
2411 ++ofp) {
2412 FLOD_MMAP *mp;
2413 LAST_ERROR *ep;
2414 const char *msg;
2415
2416 if (force) {
2417 /* Force new outgoing connection attempts. Also force
2418 * incoming error messages soon but not now to give new
2419 * connetions a chance to be triggered by outgoing
2420 * connections. */
2421 flod_try_again(ofp);
2422 }
2423
2424 mp = ofp->mp;
2425 if (ofp->soc < 0
2426 && (ofp->mp->flags & FLODMAP_FG_PASSIVE)
2427 && !OFLOD_OPT_OFF_ROGUE(ofp)
2428 && DB_IS_TIME(mp->otimers.msg, mp->otimers.msg_secs)) {
2429 ep = &mp->oflod_err;
2430 msg = (ep->complained
2431 ? ""
2432 : ep->msg[0] != '\0'
2433 ? ep->msg
2434 : ep->trace_msg);
2435 dcc_error_msg("no passive connection to %s%s%s%s",
2436 ofp->rem_hostname,
2437 msg[0] ? ": \"" : "",
2438 msg,
2439 msg[0] ? "\"" : "");
2440 ep->complained = 1;
2441 mp->otimers.msg_secs = FLOD_IN_COMPLAIN;
2442 mp->otimers.msg = db_time.tv_sec + FLOD_IN_COMPLAIN;
2443 }
2444
2445 if ((ofp->mp->flags & (FLODMAP_FG_SOCKS | FLODMAP_FG_NAT)) == 0
2446 && !ofp->ifp
2447 && !IFLOD_OPT_OFF_ROGUE(ofp)
2448 && DB_IS_TIME(mp->itimers.msg, mp->itimers.msg_secs)) {
2449 ep = &mp->iflod_err;
2450 msg = (ep->complained
2451 ? ""
2452 : ep->msg[0] != '\0'
2453 ? ep->msg
2454 : ep->trace_msg);
2455 dcc_error_msg("no incoming connection from %s%s%s%s",
2456 ofp->rem_hostname,
2457 msg[0] ? ": \"" : "",
2458 msg,
2459 msg[0] ? "\"" : "");
2460 ep->complained = 1;
2461 mp->itimers.msg_secs = FLOD_IN_COMPLAIN;
2462 mp->itimers.msg = db_time.tv_sec + FLOD_IN_COMPLAIN;
2463 }
2464 }
2465 if (loaded)
2466 oflods_clear();
2467
2468 oflods_ck();
2469 }
2470
2471
2472
2473 void
2474 flods_init(void)
2475 {
2476 IFLOD_INFO *ifp;
2477
2478 for (ifp = iflods.infos; ifp <= LAST(iflods.infos); ++ifp)
2479 ifp->soc = -1;
2480 oflods_clear();
2481
2482 flods_restart("", 1);
2483 }