1 /*
2 * ntp_peer.c - management of data maintained for peer associations
3 */
4 #ifdef HAVE_CONFIG_H
5 #include <config.h>
6 #endif
7
8 #include <stdio.h>
9 #include <sys/types.h>
10
11 #include "ntpd.h"
12 #include "ntp_lists.h"
13 #include "ntp_stdlib.h"
14 #include "ntp_control.h"
15 #include <ntp_random.h>
16
17 /*
18 * Table of valid association combinations
19 * ---------------------------------------
20 *
21 * packet->mode
22 * peer->mode | UNSPEC ACTIVE PASSIVE CLIENT SERVER BCAST
23 * ---------- | ---------------------------------------------
24 * NO_PEER | e 1 0 1 1 1
25 * ACTIVE | e 1 1 0 0 0
26 * PASSIVE | e 1 e 0 0 0
27 * CLIENT | e 0 0 0 1 0
28 * SERVER | e 0 0 0 0 0
29 * BCAST | e 0 0 0 0 0
30 * BCLIENT | e 0 0 0 e 1
31 *
32 * One point to note here: a packet in BCAST mode can potentially match
33 * a peer in CLIENT mode, but we that is a special case and we check for
34 * that early in the decision process. This avoids having to keep track
35 * of what kind of associations are possible etc... We actually
36 * circumvent that problem by requiring that the first b(m)roadcast
37 * received after the change back to BCLIENT mode sets the clock.
38 */
39 #define AM_MODES 7 /* number of rows and columns */
40 #define NO_PEER 0 /* action when no peer is found */
41
42 int AM[AM_MODES][AM_MODES] = {
43 /* packet->mode */
44 /* peer { UNSPEC, ACTIVE, PASSIVE, CLIENT, SERVER, BCAST } */
45 /* mode */
46 /*NONE*/{ AM_ERR, AM_NEWPASS, AM_NOMATCH, AM_FXMIT, AM_MANYCAST, AM_NEWBCL},
47
48 /*A*/ { AM_ERR, AM_PROCPKT, AM_PROCPKT, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH},
49
50 /*P*/ { AM_ERR, AM_PROCPKT, AM_ERR, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH},
51
52 /*C*/ { AM_ERR, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH, AM_PROCPKT, AM_NOMATCH},
53
54 /*S*/ { AM_ERR, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH},
55
56 /*BCST*/{ AM_ERR, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH},
57
58 /*BCL*/ { AM_ERR, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH, AM_NOMATCH, AM_PROCPKT},
59 };
60
61 #define MATCH_ASSOC(x, y) AM[(x)][(y)]
62
63 /*
64 * These routines manage the allocation of memory to peer structures
65 * and the maintenance of three data structures involving all peers:
66 *
67 * - peer_list is a single list with all peers, suitable for scanning
68 * operations over all peers.
69 * - peer_adr_hash is an array of lists indexed by hashed peer address.
70 * - peer_aid_hash is an array of lists indexed by hashed associd.
71 *
72 * They also maintain a free list of peer structures, peer_free.
73 *
74 * The three main entry points are findpeer(), which looks for matching
75 * peer structures in the peer list, newpeer(), which allocates a new
76 * peer structure and adds it to the list, and unpeer(), which
77 * demobilizes the association and deallocates the structure.
78 */
79 /*
80 * Peer hash tables
81 */
82 struct peer *peer_hash[NTP_HASH_SIZE]; /* peer hash table */
83 int peer_hash_count[NTP_HASH_SIZE]; /* peers in each bucket */
84 struct peer *assoc_hash[NTP_HASH_SIZE]; /* association ID hash table */
85 int assoc_hash_count[NTP_HASH_SIZE];/* peers in each bucket */
86 struct peer *peer_list; /* peer structures list */
87 static struct peer *peer_free; /* peer structures free list */
88 int peer_free_count; /* count of free structures */
89
90 /*
91 * Association ID. We initialize this value randomly, then assign a new
92 * value every time an association is mobilized.
93 */
94 static associd_t current_association_ID; /* association ID */
95 static associd_t initial_association_ID; /* association ID */
96
97 /*
98 * Memory allocation watermarks.
99 */
100 #define INIT_PEER_ALLOC 8 /* static preallocation */
101 #define INC_PEER_ALLOC 4 /* add N more when empty */
102
103 /*
104 * Miscellaneous statistic counters which may be queried.
105 */
106 u_long peer_timereset; /* time stat counters zeroed */
107 u_long findpeer_calls; /* calls to findpeer */
108 u_long assocpeer_calls; /* calls to findpeerbyassoc */
109 u_long peer_allocations; /* allocations from free list */
110 u_long peer_demobilizations; /* structs freed to free list */
111 int total_peer_structs; /* peer structs */
112 int peer_associations; /* mobilized associations */
113 int peer_preempt; /* preemptable associations */
114 static struct peer init_peer_alloc[INIT_PEER_ALLOC]; /* init alloc */
115
116 static struct peer * findexistingpeer_name(const char *, u_short,
117 struct peer *, int);
118 static struct peer * findexistingpeer_addr(sockaddr_u *,
119 struct peer *, int,
120 u_char, int *);
121 static void free_peer(struct peer *, int);
122 static void getmorepeermem(void);
123 static int score(struct peer *);
124
125
126 /*
127 * init_peer - initialize peer data structures and counters
128 *
129 * N.B. We use the random number routine in here. It had better be
130 * initialized prior to getting here.
131 */
132 void
init_peer(void)133 init_peer(void)
134 {
135 int i;
136
137 /*
138 * Initialize peer free list from static allocation.
139 */
140 for (i = COUNTOF(init_peer_alloc) - 1; i >= 0; i--)
141 LINK_SLIST(peer_free, &init_peer_alloc[i], p_link);
142 total_peer_structs = COUNTOF(init_peer_alloc);
143 peer_free_count = COUNTOF(init_peer_alloc);
144
145 /*
146 * Initialize our first association ID
147 */
148 do
149 current_association_ID = ntp_random() & ASSOCID_MAX;
150 while (!current_association_ID);
151 initial_association_ID = current_association_ID;
152 }
153
154
155 /*
156 * getmorepeermem - add more peer structures to the free list
157 */
158 static void
getmorepeermem(void)159 getmorepeermem(void)
160 {
161 int i;
162 struct peer *peers;
163
164 peers = eallocarray(INC_PEER_ALLOC, sizeof(*peers));
165
166 for (i = INC_PEER_ALLOC - 1; i >= 0; i--)
167 LINK_SLIST(peer_free, &peers[i], p_link);
168
169 total_peer_structs += INC_PEER_ALLOC;
170 peer_free_count += INC_PEER_ALLOC;
171 }
172
173
174 static struct peer *
findexistingpeer_name(const char * hostname,u_short hname_fam,struct peer * start_peer,int mode)175 findexistingpeer_name(
176 const char * hostname,
177 u_short hname_fam,
178 struct peer * start_peer,
179 int mode
180 )
181 {
182 struct peer *p;
183
184 if (NULL == start_peer)
185 p = peer_list;
186 else
187 p = start_peer->p_link;
188 for (; p != NULL; p = p->p_link)
189 if (p->hostname != NULL
190 && (-1 == mode || p->hmode == mode)
191 && (AF_UNSPEC == hname_fam
192 || AF_UNSPEC == AF(&p->srcadr)
193 || hname_fam == AF(&p->srcadr))
194 && !strcasecmp(p->hostname, hostname))
195 break;
196 return p;
197 }
198
199
200 static
201 struct peer *
findexistingpeer_addr(sockaddr_u * addr,struct peer * start_peer,int mode,u_char cast_flags,int * ip_count)202 findexistingpeer_addr(
203 sockaddr_u * addr,
204 struct peer * start_peer,
205 int mode,
206 u_char cast_flags,
207 int * ip_count
208 )
209 {
210 struct peer *peer;
211
212 DPRINTF(2, ("findexistingpeer_addr(%s, %s, %d, 0x%x, %p)\n",
213 sptoa(addr),
214 (start_peer)
215 ? sptoa(&start_peer->srcadr)
216 : "NULL",
217 mode, (u_int)cast_flags, ip_count));
218
219 /*
220 * start_peer is included so we can locate instances of the
221 * same peer through different interfaces in the hash table.
222 * Without MDF_BCLNT, a match requires the same mode and remote
223 * address. MDF_BCLNT associations start out as MODE_CLIENT
224 * if broadcastdelay is not specified, and switch to
225 * MODE_BCLIENT after estimating the one-way delay. Duplicate
226 * associations are expanded in definition to match any other
227 * MDF_BCLNT with the same srcadr (remote, unicast address).
228 */
229 if (NULL == start_peer)
230 peer = peer_hash[NTP_HASH_ADDR(addr)];
231 else
232 peer = start_peer->adr_link;
233
234 while (peer != NULL) {
235 DPRINTF(3, ("%s %s %d %d 0x%x 0x%x ", sptoa(addr),
236 sptoa(&peer->srcadr), mode, peer->hmode,
237 (u_int)cast_flags, (u_int)peer->cast_flags));
238 if (ip_count) {
239 if (SOCK_EQ(addr, &peer->srcadr)) {
240 (*ip_count)++;
241 }
242 }
243 if ((-1 == mode || peer->hmode == mode ||
244 ((MDF_BCLNT & peer->cast_flags) &&
245 (MDF_BCLNT & cast_flags))) &&
246 ADDR_PORT_EQ(addr, &peer->srcadr)) {
247 DPRINTF(3, ("found.\n"));
248 break;
249 }
250 DPRINTF(3, ("\n"));
251 peer = peer->adr_link;
252 }
253
254 return peer;
255 }
256
257
258 /*
259 * findexistingpeer - search by address and return a pointer to a peer.
260 */
261 struct peer *
findexistingpeer(sockaddr_u * addr,const char * hostname,struct peer * start_peer,int mode,u_char cast_flags,int * ip_count)262 findexistingpeer(
263 sockaddr_u * addr,
264 const char * hostname,
265 struct peer * start_peer,
266 int mode,
267 u_char cast_flags,
268 int * ip_count
269 )
270 {
271 if (hostname != NULL)
272 return findexistingpeer_name(hostname, AF(addr),
273 start_peer, mode);
274 else
275 return findexistingpeer_addr(addr, start_peer, mode,
276 cast_flags, ip_count);
277 }
278
279
280 /*
281 * findpeer - find and return a peer match for a received datagram in
282 * the peer_hash table.
283 *
284 * [Bug 3072] To faciliate a faster reorganisation after routing changes
285 * the original code re-assigned the peer address to be the destination
286 * of the received packet and initiated another round on a mismatch.
287 * Unfortunately this leaves us wide open for a DoS attack where the
288 * attacker directs a packet with forged destination address to us --
289 * this results in a wrong interface assignment, actually creating a DoS
290 * situation.
291 *
292 * This condition would persist until the next update of the interface
293 * list, but a continued attack would put us out of business again soon
294 * enough. Authentication alone does not help here, since it does not
295 * protect the UDP layer and leaves us open for a replay attack.
296 *
297 * So we do not update the adresses and wait until the next interface
298 * list update does the right thing for us.
299 */
300 struct peer *
findpeer(struct recvbuf * rbufp,int pkt_mode,int * action)301 findpeer(
302 struct recvbuf *rbufp,
303 int pkt_mode,
304 int * action
305 )
306 {
307 struct peer * p;
308 sockaddr_u * srcadr;
309 u_int hash;
310 struct pkt * pkt;
311 l_fp pkt_org;
312
313 findpeer_calls++;
314 srcadr = &rbufp->recv_srcadr;
315 hash = NTP_HASH_ADDR(srcadr);
316 for (p = peer_hash[hash]; p != NULL; p = p->adr_link) {
317
318 /* [Bug 3072] ensure interface of peer matches */
319 /* [Bug 3356] ... if NOT a broadcast peer! */
320 if (p->hmode != MODE_BCLIENT && p->dstadr != rbufp->dstadr)
321 continue;
322
323 /* ensure peer source address matches */
324 if ( ! ADDR_PORT_EQ(srcadr, &p->srcadr))
325 continue;
326
327 /* If the association matching rules determine that this
328 * is not a valid combination, then look for the next
329 * valid peer association.
330 */
331 *action = MATCH_ASSOC(p->hmode, pkt_mode);
332
333 /* A response to our manycastclient solicitation might
334 * be misassociated with an ephemeral peer already spun
335 * for the server. If the packet's org timestamp
336 * doesn't match the peer's, check if it matches the
337 * ACST prototype peer's. If so it is a redundant
338 * solicitation response, return AM_ERR to discard it.
339 * [Bug 1762]
340 */
341 if (MODE_SERVER == pkt_mode && AM_PROCPKT == *action) {
342 pkt = &rbufp->recv_pkt;
343 NTOHL_FP(&pkt->org, &pkt_org);
344 if (!L_ISEQU(&p->aorg, &pkt_org) &&
345 findmanycastpeer(rbufp))
346 *action = AM_ERR;
347 }
348
349 /* if an error was returned, exit back right here. */
350 if (*action == AM_ERR)
351 return NULL;
352
353 /* if a match is found, we stop our search. */
354 if (*action != AM_NOMATCH)
355 break;
356 }
357
358 /* If no matching association is found... */
359 if (NULL == p)
360 *action = MATCH_ASSOC(NO_PEER, pkt_mode);
361
362 return p;
363 }
364
365 /*
366 * findpeerbyassoc - find and return a peer using his association ID
367 */
368 struct peer *
findpeerbyassoc(associd_t assoc)369 findpeerbyassoc(
370 associd_t assoc
371 )
372 {
373 struct peer *p;
374 u_int hash;
375
376 assocpeer_calls++;
377 hash = assoc & NTP_HASH_MASK;
378 for (p = assoc_hash[hash]; p != NULL; p = p->aid_link)
379 if (assoc == p->associd)
380 break;
381 return p;
382 }
383
384
385 /*
386 * clear_all - flush all time values for all associations
387 */
388 void
clear_all(void)389 clear_all(void)
390 {
391 struct peer *p;
392
393 /*
394 * This routine is called when the clock is stepped, and so all
395 * previously saved time values are untrusted.
396 */
397 for (p = peer_list; p != NULL; p = p->p_link)
398 if (!(MDF_TXONLY_MASK & p->cast_flags))
399 peer_clear(p, "STEP");
400
401 DPRINTF(1, ("clear_all: at %lu\n", current_time));
402 }
403
404
405 /*
406 * score_all() - determine if an association can be demobilized
407 */
408 int
score_all(struct peer * peer)409 score_all(
410 struct peer *peer /* peer structure pointer */
411 )
412 {
413 struct peer *speer;
414 int temp, tamp;
415 int x;
416
417 /*
418 * This routine finds the minimum score for all preemptible
419 * associations and returns > 0 if the association can be
420 * demobilized.
421 */
422 tamp = score(peer);
423 temp = 100;
424 for (speer = peer_list; speer != NULL; speer = speer->p_link)
425 if (speer->flags & FLAG_PREEMPT) {
426 x = score(speer);
427 if (x < temp)
428 temp = x;
429 }
430 DPRINTF(1, ("score_all: at %lu score %d min %d\n",
431 current_time, tamp, temp));
432
433 if (tamp != temp)
434 temp = 0;
435
436 return temp;
437 }
438
439
440 /*
441 * score() - calculate preemption score
442 */
443 static int
score(struct peer * peer)444 score(
445 struct peer *peer /* peer structure pointer */
446 )
447 {
448 int temp;
449
450 /*
451 * This routine calculates the premption score from the peer
452 * error bits and status. Increasing values are more cherished.
453 */
454 temp = 0;
455 if (!(peer->flash & TEST10))
456 temp++; /* 1 good synch and stratum */
457 if (!(peer->flash & TEST13))
458 temp++; /* 2 reachable */
459 if (!(peer->flash & TEST12))
460 temp++; /* 3 no loop */
461 if (!(peer->flash & TEST11))
462 temp++; /* 4 good distance */
463 if (peer->status >= CTL_PST_SEL_SELCAND)
464 temp++; /* 5 in the hunt */
465 if (peer->status != CTL_PST_SEL_EXCESS)
466 temp++; /* 6 not spare tire */
467 return (temp); /* selection status */
468 }
469
470
471 /*
472 * free_peer - internal routine to free memory referred to by a struct
473 * peer and return it to the peer free list. If unlink is
474 * nonzero, unlink from the various lists.
475 */
476 static void
free_peer(struct peer * p,int unlink_peer)477 free_peer(
478 struct peer * p,
479 int unlink_peer
480 )
481 {
482 struct peer * unlinked;
483 int hash;
484
485 if (unlink_peer) {
486 hash = NTP_HASH_ADDR(&p->srcadr);
487 peer_hash_count[hash]--;
488
489 UNLINK_SLIST(unlinked, peer_hash[hash], p, adr_link,
490 struct peer);
491 if (NULL == unlinked) {
492 peer_hash_count[hash]++;
493 msyslog(LOG_ERR, "peer %s not in address table!",
494 stoa(&p->srcadr));
495 }
496
497 /*
498 * Remove him from the association hash as well.
499 */
500 hash = p->associd & NTP_HASH_MASK;
501 assoc_hash_count[hash]--;
502
503 UNLINK_SLIST(unlinked, assoc_hash[hash], p, aid_link,
504 struct peer);
505 if (NULL == unlinked) {
506 assoc_hash_count[hash]++;
507 msyslog(LOG_ERR,
508 "peer %s not in association ID table!",
509 stoa(&p->srcadr));
510 }
511
512 /* Remove him from the overall list. */
513 UNLINK_SLIST(unlinked, peer_list, p, p_link,
514 struct peer);
515 if (NULL == unlinked)
516 msyslog(LOG_ERR, "%s not in peer list!",
517 stoa(&p->srcadr));
518 }
519
520 if (p->hostname != NULL)
521 free(p->hostname);
522
523 if (p->ident != NULL)
524 free(p->ident);
525
526 if (p->addrs != NULL)
527 free(p->addrs); /* from copy_addrinfo_list() */
528
529 /* Add his corporeal form to peer free list */
530 ZERO(*p);
531 LINK_SLIST(peer_free, p, p_link);
532 peer_free_count++;
533 }
534
535
536 /*
537 * unpeer - remove peer structure from hash table and free structure
538 */
539 void
unpeer(struct peer * peer)540 unpeer(
541 struct peer *peer
542 )
543 {
544 mprintf_event(PEVNT_DEMOBIL, peer, "assoc %u", peer->associd);
545 restrict_source(&peer->srcadr, 1, 0);
546 set_peerdstadr(peer, NULL);
547 peer_demobilizations++;
548 peer_associations--;
549 if (FLAG_PREEMPT & peer->flags)
550 peer_preempt--;
551 #ifdef REFCLOCK
552 /*
553 * If this peer is actually a clock, shut it down first
554 */
555 if (FLAG_REFCLOCK & peer->flags)
556 refclock_unpeer(peer);
557 #endif
558
559 free_peer(peer, TRUE);
560 }
561
562
563 /*
564 * peer_config - configure a new association
565 */
566 struct peer *
peer_config(sockaddr_u * srcadr,const char * hostname,endpt * dstadr,int ippeerlimit,u_char hmode,u_char version,u_char minpoll,u_char maxpoll,u_int flags,u_int32 ttl,keyid_t key,const char * ident)567 peer_config(
568 sockaddr_u * srcadr,
569 const char * hostname,
570 endpt * dstadr,
571 int ippeerlimit,
572 u_char hmode,
573 u_char version,
574 u_char minpoll,
575 u_char maxpoll,
576 u_int flags,
577 u_int32 ttl,
578 keyid_t key,
579 const char * ident /* autokey group */
580 )
581 {
582 u_char cast_flags;
583
584 /*
585 * We do a dirty little jig to figure the cast flags. This is
586 * probably not the best place to do this, at least until the
587 * configure code is rebuilt. Note only one flag can be set.
588 */
589 switch (hmode) {
590 case MODE_BROADCAST:
591 if (IS_MCAST(srcadr))
592 cast_flags = MDF_MCAST;
593 else
594 cast_flags = MDF_BCAST;
595 break;
596
597 case MODE_CLIENT:
598 if (hostname != NULL && SOCK_UNSPEC(srcadr))
599 cast_flags = MDF_POOL;
600 else if (IS_MCAST(srcadr))
601 cast_flags = MDF_ACAST;
602 else
603 cast_flags = MDF_UCAST;
604 break;
605
606 default:
607 cast_flags = MDF_UCAST;
608 }
609
610 /*
611 * Mobilize the association and initialize its variables. If
612 * emulating ntpdate, force iburst. For pool and manycastclient
613 * strip FLAG_PREEMPT as the prototype associations are not
614 * themselves preemptible, though the resulting associations
615 * are.
616 */
617 flags |= FLAG_CONFIG;
618 if (mode_ntpdate)
619 flags |= FLAG_IBURST;
620 if ((MDF_ACAST | MDF_POOL) & cast_flags)
621 flags &= ~FLAG_PREEMPT;
622 return newpeer(srcadr, hostname, dstadr, ippeerlimit, hmode, version,
623 minpoll, maxpoll, flags, cast_flags, ttl, key, ident);
624 }
625
626 /*
627 * setup peer dstadr field keeping it in sync with the interface
628 * structures
629 */
630 void
set_peerdstadr(struct peer * p,endpt * dstadr)631 set_peerdstadr(
632 struct peer * p,
633 endpt * dstadr
634 )
635 {
636 struct peer * unlinked;
637
638 DEBUG_INSIST(p != NULL);
639
640 if (p == NULL)
641 return;
642
643 /* check for impossible or identical assignment */
644 if (p->dstadr == dstadr)
645 return;
646
647 /*
648 * Don't accept updates to a separate multicast receive-only
649 * endpt while a BCLNT peer is running its unicast protocol.
650 */
651 if (dstadr != NULL && (FLAG_BC_VOL & p->flags) &&
652 (INT_MCASTIF & dstadr->flags) && MODE_CLIENT == p->hmode) {
653 return;
654 }
655
656 /* unlink from list if we have an address prior to assignment */
657 if (p->dstadr != NULL) {
658 p->dstadr->peercnt--;
659 UNLINK_SLIST(unlinked, p->dstadr->peers, p, ilink,
660 struct peer);
661 msyslog(LOG_INFO, "%s local addr %s -> %s",
662 stoa(&p->srcadr), latoa(p->dstadr),
663 latoa(dstadr));
664 }
665
666 p->dstadr = dstadr;
667
668 /* link to list if we have an address after assignment */
669 if (p->dstadr != NULL) {
670 LINK_SLIST(dstadr->peers, p, ilink);
671 dstadr->peercnt++;
672 }
673 }
674
675 /*
676 * attempt to re-rebind interface if necessary
677 */
678 static void
peer_refresh_interface(struct peer * p)679 peer_refresh_interface(
680 struct peer *p
681 )
682 {
683 endpt * niface;
684 endpt * piface;
685
686 niface = select_peerinterface(p, &p->srcadr, NULL);
687
688 DPRINTF(4, (
689 "peer_refresh_interface: %s->%s mode %d vers %d poll %d %d flags 0x%x 0x%x ttl %u key %08x: new interface: ",
690 p->dstadr == NULL ? "<null>" :
691 stoa(&p->dstadr->sin), stoa(&p->srcadr), p->hmode,
692 p->version, p->minpoll, p->maxpoll, p->flags, p->cast_flags,
693 p->ttl, p->keyid));
694 if (niface != NULL) {
695 DPRINTF(4, (
696 "fd=%d, bfd=%d, name=%.16s, flags=0x%x, ifindex=%u, sin=%s",
697 niface->fd, niface->bfd, niface->name,
698 niface->flags, niface->ifindex,
699 stoa(&niface->sin)));
700 if (niface->flags & INT_BROADCAST)
701 DPRINTF(4, (", bcast=%s",
702 stoa(&niface->bcast)));
703 DPRINTF(4, (", mask=%s\n", stoa(&niface->mask)));
704 } else {
705 DPRINTF(4, ("<NONE>\n"));
706 }
707
708 piface = p->dstadr;
709 set_peerdstadr(p, niface);
710 if (p->dstadr != NULL) {
711 /*
712 * clear crypto if we change the local address
713 */
714 if (p->dstadr != piface && !(MDF_ACAST & p->cast_flags)
715 && MODE_BROADCAST != p->pmode)
716 peer_clear(p, "XFAC");
717
718 /*
719 * Broadcast needs the socket enabled for broadcast
720 */
721 if (MDF_BCAST & p->cast_flags)
722 enable_broadcast(p->dstadr, &p->srcadr);
723
724 /*
725 * Multicast needs the socket interface enabled for
726 * multicast
727 */
728 if (MDF_MCAST & p->cast_flags)
729 enable_multicast_if(p->dstadr, &p->srcadr);
730 }
731 }
732
733
734 /*
735 * refresh_all_peerinterfaces - see that all interface bindings are up
736 * to date
737 */
738 void
refresh_all_peerinterfaces(void)739 refresh_all_peerinterfaces(void)
740 {
741 struct peer *p;
742
743 /*
744 * this is called when the interface list has changed
745 * give all peers a chance to find a better interface
746 * but only if either they don't have an address already
747 * or if the one they have hasn't worked for a while.
748 */
749 for (p = peer_list; p != NULL; p = p->p_link) {
750 if (!(p->dstadr && (p->reach & 0x3))) // Bug 2849 XOR 2043
751 peer_refresh_interface(p);
752 }
753 }
754
755
756 /*
757 * newpeer - initialize a new peer association
758 */
759 struct peer *
newpeer(sockaddr_u * srcadr,const char * hostname,endpt * dstadr,int ippeerlimit,u_char hmode,u_char version,u_char minpoll,u_char maxpoll,u_int flags,u_char cast_flags,u_int32 ttl,keyid_t key,const char * ident)760 newpeer(
761 sockaddr_u * srcadr,
762 const char * hostname,
763 endpt * dstadr,
764 int ippeerlimit,
765 u_char hmode,
766 u_char version,
767 u_char minpoll,
768 u_char maxpoll,
769 u_int flags,
770 u_char cast_flags,
771 u_int32 ttl,
772 keyid_t key,
773 const char * ident
774 )
775 {
776 struct peer * peer;
777 u_int hash;
778 int ip_count = 0;
779
780
781 DEBUG_REQUIRE(srcadr);
782
783 #ifdef AUTOKEY
784 /*
785 * If Autokey is requested but not configured, complain loudly.
786 */
787 if (!crypto_flags) {
788 if (key > NTP_MAXKEY) {
789 return (NULL);
790
791 } else if (flags & FLAG_SKEY) {
792 msyslog(LOG_ERR, "Autokey not configured");
793 return (NULL);
794 }
795 }
796 #endif /* AUTOKEY */
797
798 /*
799 * For now only pool associations have a hostname.
800 */
801 INSIST(NULL == hostname || (MDF_POOL & cast_flags));
802
803 /*
804 * First search from the beginning for an association with given
805 * remote address and mode. If an interface is given, search
806 * from there to find the association which matches that
807 * destination. If the given interface is "any", track down the
808 * actual interface, because that's what gets put into the peer
809 * structure.
810 */
811 if (dstadr != NULL) {
812 peer = findexistingpeer(srcadr, hostname, NULL, hmode,
813 cast_flags, &ip_count);
814 while (peer != NULL) {
815 if ( peer->dstadr == dstadr
816 || ( (MDF_BCLNT & cast_flags)
817 && (MDF_BCLNT & peer->cast_flags)))
818 break;
819
820 if (dstadr == ANY_INTERFACE_CHOOSE(srcadr) &&
821 peer->dstadr == findinterface(srcadr))
822 break;
823
824 peer = findexistingpeer(srcadr, hostname, peer,
825 hmode, cast_flags, &ip_count);
826 }
827 } else {
828 /* no endpt address given */
829 peer = findexistingpeer(srcadr, hostname, NULL, hmode,
830 cast_flags, &ip_count);
831 }
832
833 /*
834 * If a peer is found, this would be a duplicate and we don't
835 * allow that. This avoids duplicate ephemeral (broadcast/
836 * multicast) and preemptible (manycast and pool) client
837 * associations.
838 */
839 if (peer != NULL) {
840 DPRINTF(2, ("newpeer(%s) found existing association\n",
841 (hostname)
842 ? hostname
843 : stoa(srcadr)));
844 return NULL;
845 }
846
847 #if 0
848 DPRINTF(1, ("newpeer(%s) found no existing and %d other associations\n",
849 (hostname)
850 ? hostname
851 : stoa(srcadr),
852 ip_count));
853 #endif
854
855 /* Check ippeerlimit wrt ip_count */
856 if (ippeerlimit > -1) {
857 if (ip_count + 1 > ippeerlimit) {
858 DPRINTF(2, ("newpeer(%s) denied - ippeerlimit %d\n",
859 (hostname)
860 ? hostname
861 : stoa(srcadr),
862 ippeerlimit));
863 return NULL;
864 }
865 } else {
866 DPRINTF(1, ("newpeer(%s) - ippeerlimit %d ignored\n",
867 (hostname)
868 ? hostname
869 : stoa(srcadr),
870 ippeerlimit));
871 }
872
873 /*
874 * Allocate a new peer structure. Some dirt here, since some of
875 * the initialization requires knowlege of our system state.
876 */
877 if (peer_free_count == 0)
878 getmorepeermem();
879 UNLINK_HEAD_SLIST(peer, peer_free, p_link);
880 INSIST(peer != NULL);
881 peer_free_count--;
882 peer_associations++;
883 if (FLAG_PREEMPT & flags)
884 peer_preempt++;
885
886 /*
887 * Assign an association ID and increment the system variable.
888 */
889 peer->associd = current_association_ID;
890 if (++current_association_ID == 0)
891 ++current_association_ID;
892
893 peer->srcadr = *srcadr;
894 if (hostname != NULL)
895 peer->hostname = estrdup(hostname);
896 peer->hmode = hmode;
897 peer->version = version;
898 peer->flags = flags;
899 peer->cast_flags = cast_flags;
900 set_peerdstadr(peer,
901 select_peerinterface(peer, srcadr, dstadr));
902
903 /*
904 * It is an error to set minpoll less than NTP_MINPOLL or to
905 * set maxpoll greater than NTP_MAXPOLL. However, minpoll is
906 * clamped not greater than NTP_MAXPOLL and maxpoll is clamped
907 * not less than NTP_MINPOLL without complaint. Finally,
908 * minpoll is clamped not greater than maxpoll.
909 */
910 if (minpoll == 0)
911 peer->minpoll = NTP_MINDPOLL;
912 else
913 peer->minpoll = min(minpoll, NTP_MAXPOLL);
914 if (maxpoll == 0)
915 peer->maxpoll = NTP_MAXDPOLL;
916 else
917 peer->maxpoll = max(maxpoll, NTP_MINPOLL);
918 if (peer->minpoll > peer->maxpoll)
919 peer->minpoll = peer->maxpoll;
920
921 if (peer->dstadr != NULL)
922 DPRINTF(3, ("newpeer(%s): using fd %d and our addr %s\n",
923 stoa(srcadr), peer->dstadr->fd,
924 stoa(&peer->dstadr->sin)));
925 else
926 DPRINTF(3, ("newpeer(%s): local interface currently not bound\n",
927 stoa(srcadr)));
928
929 /*
930 * Broadcast needs the socket enabled for broadcast
931 */
932 if ((MDF_BCAST & cast_flags) && peer->dstadr != NULL)
933 enable_broadcast(peer->dstadr, srcadr);
934
935 /*
936 * Multicast needs the socket interface enabled for multicast
937 */
938 if ((MDF_MCAST & cast_flags) && peer->dstadr != NULL)
939 enable_multicast_if(peer->dstadr, srcadr);
940
941 #ifdef AUTOKEY
942 if (key > NTP_MAXKEY)
943 peer->flags |= FLAG_SKEY;
944 #endif /* AUTOKEY */
945 peer->ttl = ttl;
946 peer->keyid = key;
947 if (ident != NULL)
948 peer->ident = estrdup(ident);
949 peer->precision = sys_precision;
950 peer->hpoll = peer->minpoll;
951 if (cast_flags & MDF_ACAST)
952 peer_clear(peer, "ACST");
953 else if (cast_flags & MDF_POOL)
954 peer_clear(peer, "POOL");
955 else if (cast_flags & MDF_MCAST)
956 peer_clear(peer, "MCST");
957 else if (cast_flags & MDF_BCAST)
958 peer_clear(peer, "BCST");
959 else
960 peer_clear(peer, "INIT");
961 if (mode_ntpdate)
962 peer_ntpdate++;
963
964 /*
965 * Note time on statistics timers.
966 */
967 peer->timereset = current_time;
968 peer->timereachable = current_time;
969 peer->timereceived = current_time;
970
971 if (ISREFCLOCKADR(&peer->srcadr)) {
972 #ifdef REFCLOCK
973 /*
974 * We let the reference clock support do clock
975 * dependent initialization. This includes setting
976 * the peer timer, since the clock may have requirements
977 * for this.
978 */
979 if (maxpoll == 0)
980 peer->maxpoll = peer->minpoll;
981 if (!refclock_newpeer(peer)) {
982 /*
983 * Dump it, something screwed up
984 */
985 set_peerdstadr(peer, NULL);
986 free_peer(peer, 0);
987 return NULL;
988 }
989 #else /* REFCLOCK */
990 msyslog(LOG_ERR, "refclock %s isn't supported. ntpd was compiled without refclock support.",
991 stoa(&peer->srcadr));
992 set_peerdstadr(peer, NULL);
993 free_peer(peer, 0);
994 return NULL;
995 #endif /* REFCLOCK */
996 }
997
998 /*
999 * Put the new peer in the hash tables.
1000 */
1001 hash = NTP_HASH_ADDR(&peer->srcadr);
1002 LINK_SLIST(peer_hash[hash], peer, adr_link);
1003 peer_hash_count[hash]++;
1004 hash = peer->associd & NTP_HASH_MASK;
1005 LINK_SLIST(assoc_hash[hash], peer, aid_link);
1006 assoc_hash_count[hash]++;
1007 LINK_SLIST(peer_list, peer, p_link);
1008
1009 restrict_source(&peer->srcadr, 0, 0);
1010 mprintf_event(PEVNT_MOBIL, peer, "assoc %d", peer->associd);
1011 DPRINTF(1, ("newpeer: %s->%s mode %u vers %u poll %u %u flags 0x%x 0x%x ttl %u key %08x\n",
1012 latoa(peer->dstadr), stoa(&peer->srcadr), peer->hmode,
1013 peer->version, peer->minpoll, peer->maxpoll, peer->flags,
1014 peer->cast_flags, peer->ttl, peer->keyid));
1015 return peer;
1016 }
1017
1018
1019 /*
1020 * peer_clr_stats - clear peer module statistics counters
1021 */
1022 void
peer_clr_stats(void)1023 peer_clr_stats(void)
1024 {
1025 findpeer_calls = 0;
1026 assocpeer_calls = 0;
1027 peer_allocations = 0;
1028 peer_demobilizations = 0;
1029 peer_timereset = current_time;
1030 }
1031
1032
1033 /*
1034 * peer_reset - reset statistics counters
1035 */
1036 void
peer_reset(struct peer * peer)1037 peer_reset(
1038 struct peer *peer
1039 )
1040 {
1041 if (peer == NULL)
1042 return;
1043
1044 peer->timereset = current_time;
1045 peer->sent = 0;
1046 peer->received = 0;
1047 peer->processed = 0;
1048 peer->badauth = 0;
1049 peer->bogusorg = 0;
1050 peer->oldpkt = 0;
1051 peer->seldisptoolarge = 0;
1052 peer->selbroken = 0;
1053 }
1054
1055
1056 /*
1057 * peer_all_reset - reset all peer statistics counters
1058 */
1059 void
peer_all_reset(void)1060 peer_all_reset(void)
1061 {
1062 struct peer *peer;
1063
1064 for (peer = peer_list; peer != NULL; peer = peer->p_link)
1065 peer_reset(peer);
1066 }
1067
1068
1069 /*
1070 * findmanycastpeer - find and return a manycastclient or pool
1071 * association matching a received response.
1072 */
1073 struct peer *
findmanycastpeer(struct recvbuf * rbufp)1074 findmanycastpeer(
1075 struct recvbuf *rbufp /* receive buffer pointer */
1076 )
1077 {
1078 struct peer *peer;
1079 struct pkt *pkt;
1080 l_fp p_org;
1081
1082 /*
1083 * This routine is called upon arrival of a server-mode response
1084 * to a manycastclient multicast solicitation, or to a pool
1085 * server unicast solicitation. Search the peer list for a
1086 * manycastclient association where the last transmit timestamp
1087 * matches the response packet's originate timestamp. There can
1088 * be multiple manycastclient associations, or multiple pool
1089 * solicitation assocations, so this assumes the transmit
1090 * timestamps are unique for such.
1091 */
1092 pkt = &rbufp->recv_pkt;
1093 for (peer = peer_list; peer != NULL; peer = peer->p_link)
1094 if (MDF_SOLICIT_MASK & peer->cast_flags) {
1095 NTOHL_FP(&pkt->org, &p_org);
1096 if (L_ISEQU(&p_org, &peer->aorg))
1097 break;
1098 }
1099
1100 return peer;
1101 }
1102
1103 /* peer_cleanup - clean peer list prior to shutdown */
peer_cleanup(void)1104 void peer_cleanup(void)
1105 {
1106 struct peer *peer;
1107 associd_t assoc;
1108
1109 for (assoc = initial_association_ID; assoc != current_association_ID; assoc++) {
1110 if (assoc != 0U) {
1111 peer = findpeerbyassoc(assoc);
1112 if (peer != NULL)
1113 unpeer(peer);
1114 }
1115 }
1116 peer = findpeerbyassoc(current_association_ID);
1117 if (peer != NULL)
1118 unpeer(peer);
1119 }
1120