1/*
2 * ntp_proto.c - NTP version 4 protocol machinery
3 *
4 * $FreeBSD: head/contrib/ntp/ntpd/ntp_proto.c 82505 2001-08-29 15:15:59Z roberto $
5 */
6#ifdef HAVE_CONFIG_H
7#include <config.h>
8#endif
9
10#include "ntpd.h"
11#include "ntp_stdlib.h"
12#include "ntp_unixtime.h"
13#include "ntp_control.h"
14#include "ntp_string.h"
15#include "ntp_crypto.h"
16
17#include <stdio.h>
18
19#if defined(VMS) && defined(VMS_LOCALUNIT) /*wjm*/
20#include "ntp_refclock.h"
21#endif
22
23#if defined(__FreeBSD__) && __FreeBSD__ >= 3
24#include <sys/sysctl.h>
25#endif
26
27/*
28 * System variables are declared here. See Section 3.2 of the
29 * specification.
30 */
31u_char sys_leap; /* system leap indicator */
32u_char sys_stratum; /* stratum of system */
33s_char sys_precision; /* local clock precision */
34double sys_rootdelay; /* roundtrip delay to primary source */
35double sys_rootdispersion; /* dispersion to primary source */
36u_int32 sys_refid; /* reference source for local clock */
37static double sys_offset; /* current local clock offset */
38l_fp sys_reftime; /* time we were last updated */
39struct peer *sys_peer; /* our current peer */
40struct peer *sys_prefer; /* our cherished peer */
41#ifdef AUTOKEY
42u_long sys_automax; /* maximum session key lifetime */
43#endif /* AUTOKEY */
44
45/*
46 * Nonspecified system state variables.
47 */
48int sys_bclient; /* we set our time to broadcasts */
49double sys_bdelay; /* broadcast client default delay */
50int sys_authenticate; /* requre authentication for config */
51l_fp sys_authdelay; /* authentication delay */
52static u_long sys_authdly[2]; /* authentication delay shift reg */
53static u_char leap_consensus; /* consensus of survivor leap bits */
54static double sys_selerr; /* select error (squares) */
55static double sys_syserr; /* system error (squares) */
56keyid_t sys_private; /* private value for session seed */
57int sys_manycastserver; /* respond to manycast client pkts */
58u_int sys_survivors; /* truest of the truechimers */
59int peer_ntpdate; /* active peers in ntpdate mode */
60#ifdef AUTOKEY
61char *sys_hostname; /* gethostname() name */
62#endif /* AUTOKEY */
63
64/*
65 * Statistics counters
66 */
67u_long sys_stattime; /* time when we started recording */
68u_long sys_badstratum; /* packets with invalid stratum */
69u_long sys_oldversionpkt; /* old version packets received */
70u_long sys_newversionpkt; /* new version packets received */
71u_long sys_unknownversion; /* don't know version packets */
72u_long sys_badlength; /* packets with bad length */
73u_long sys_processed; /* packets processed */
74u_long sys_badauth; /* packets dropped because of auth */
75u_long sys_limitrejected; /* pkts rejected due to client count per net */
76
77static double root_distance P((struct peer *));
78static double clock_combine P((struct peer **, int));
79static void peer_xmit P((struct peer *));
80static void fast_xmit P((struct recvbuf *, int, keyid_t, int));
81static void clock_update P((void));
82int default_get_precision P((void));
83
84
85/*
86 * transmit - Transmit Procedure. See Section 3.4.2 of the
87 * specification.
88 */
89void
90transmit(
91 struct peer *peer /* peer structure pointer */
92 )
93{
94 int hpoll;
95
96 hpoll = peer->hpoll;
97 if (peer->burst == 0) {
98 u_char oreach;
99
100 /*
101 * The polling state machine. There are two kinds of
102 * machines, those that never expect a reply (broadcast
103 * and manycast server modes) and those that do (all
104 * other modes). The dance is intricate...
105 */
106 if (peer->cast_flags & (MDF_BCAST | MDF_MCAST)) {
107
108 /*
109 * In broadcast mode the poll interval is fixed
110 * at minpoll and the ttl at ttlmax.
111 */
112 hpoll = peer->minpoll;
113 peer->ttl = peer->ttlmax;
114#ifdef AUTOKEY
115 } else if (peer->cast_flags & MDF_ACAST) {
116
117 /*
118 * In manycast mode we start with the minpoll
119 * interval and ttl. However, the actual poll
120 * interval is eight times the nominal poll
121 * interval shown here. If fewer than three
122 * servers are found, the ttl is increased by
123 * one and we try again. If this continues to
124 * the max ttl, the poll interval is bumped by
125 * one and we try again. If at least three
126 * servers are found, the poll interval
127 * increases with the system poll interval to
128 * the max and we continue indefinately.
129 * However, about once per day when the
130 * agreement parameters are refreshed, the
131 * manycast clients are reset and we start from
132 * the beginning. This is to catch and clamp the
133 * ttl to the lowest practical value and avoid
134 * knocking on spurious doors.
135 */
136 if (sys_survivors < NTP_MINCLOCK && peer->ttl <
137 peer->ttlmax)
138 peer->ttl++;
139 hpoll = sys_poll;
140#endif /* AUTOKEY */
141 } else {
142
143 /*
144 * For associations expecting a reply, the
145 * watchdog counter is bumped by one if the peer
146 * has not been heard since the previous poll.
147 * If the counter reaches the max, the peer is
148 * demobilized if not configured and just
149 * cleared if it is, but in this case the poll
150 * interval is bumped by one.
151 */
152 if (peer->unreach < NTP_UNREACH) {
153 peer->unreach++;
154 } else if (!(peer->flags & FLAG_CONFIG)) {
155 unpeer(peer);
156 clock_select();
157 return;
158
159 } else {
160 peer_clear(peer);
161 hpoll++;
162 }
163 }
164 oreach = peer->reach;
165 peer->reach <<= 1;
166 if (peer->reach == 0) {
167
168 /*
169 * If this association has become unreachable,
170 * clear it and raise a trap.
171 */
172 if (oreach != 0) {
173 report_event(EVNT_UNREACH, peer);
174 peer->timereachable = current_time;
175 if (!(peer->flags & FLAG_CONFIG)) {
176 unpeer(peer);
177 clock_select();
178 return;
179 } else {
180 peer_clear(peer);
181 hpoll = peer->minpoll;
182 }
183 }
184 if (peer->flags & FLAG_IBURST)
185 peer->burst = NTP_SHIFT;
186 } else {
187
188 /*
189 * Here the peer is reachable. If it has not
190 * been heard for three consecutive polls, stuff
191 * the clock filter. Next, determine the poll
192 * interval. If the peer is a synchronization
193 * candidate, use the system poll interval. If
194 * the peer is not sane, increase it by one. If
195 * the number of valid updates is not greater
196 * than half the register size, clamp it to the
197 * minimum. This is to quickly recover the time
198 * variables when a noisy peer shows life.
199 */
200 if (!(peer->reach & 0x07)) {
201 clock_filter(peer, 0., 0., MAXDISPERSE);
202 clock_select();
203 }
204 if ((peer->stratum > 1 && peer->refid ==
205 peer->dstadr->sin.sin_addr.s_addr) ||
206 peer->stratum >= STRATUM_UNSPEC)
207 hpoll++;
208 else
209 hpoll = sys_poll;
210 if (peer->flags & FLAG_BURST)
211 peer->burst = NTP_SHIFT;
212 }
213 } else {
214 peer->burst--;
215 if (peer->burst == 0) {
216
217 /*
218 * If a broadcast client at this point, the
219 * burst has concluded, so we switch to client
220 * mode and purge the keylist, since no further
221 * transmissions will be made.
222 */
223 if (peer->cast_flags & MDF_BCLNT) {
224 peer->hmode = MODE_BCLIENT;
225#ifdef AUTOKEY
226 key_expire(peer);
227#endif /* AUTOKEY */
228 }
229 poll_update(peer, hpoll);
230 clock_select();
231
232 /*
233 * If ntpdate mode and the clock has not been
234 * set and all peers have completed the burst,
235 * we declare a successful failure.
236 */
237 if (mode_ntpdate) {
238 peer_ntpdate--;
239 if (peer_ntpdate > 0)
240 return;
241 NLOG(NLOG_SYNCEVENT | NLOG_SYSEVENT)
242 msyslog(LOG_NOTICE,
243 "no reply; clock not set");
244 printf(
245 "ntpd: no reply; clock not set\n");
246 exit(0);
247 }
248 return;
249
250 }
251 }
252 peer->outdate = current_time;
253 poll_update(peer, hpoll);
254
255 /*
256 * We need to be very careful about honking uncivilized time.
257 * Never transmit if in broadcast client mode or access denied.
258 * If in broadcast mode, transmit only if synchronized to a
259 * valid source.
260 */
261 if (peer->hmode == MODE_BCLIENT || peer->flash & TEST4) {
262 return;
263 } else if (peer->hmode == MODE_BROADCAST) {
264 if (sys_peer == NULL)
265 return;
266 }
267 peer_xmit(peer);
268}
269
270/*
271 * receive - Receive Procedure. See section 3.4.3 in the specification.
272 */
273void
274receive(
275 struct recvbuf *rbufp
276 )
277{
278 register struct peer *peer;
279 register struct pkt *pkt;
280 int hismode;
281 int oflags;
282 int restrict_mask;
283 int has_mac; /* length of MAC field */
284 int authlen; /* offset of MAC field */
285 int is_authentic; /* cryptosum ok */
286 keyid_t skeyid; /* cryptographic keys */
287 struct sockaddr_in *dstadr_sin; /* active runway */
288#ifdef AUTOKEY
289 keyid_t pkeyid, tkeyid; /* cryptographic keys */
290#endif /* AUTOKEY */
291 struct peer *peer2;
292 int retcode = AM_NOMATCH;
293
294 /*
295 * Monitor the packet and get restrictions. Note that the packet
296 * length for control and private mode packets must be checked
297 * by the service routines. Note that no statistics counters are
298 * recorded for restrict violations, since these counters are in
299 * the restriction routine. Note the careful distinctions here
300 * between a packet with a format error and a packet that is
301 * simply discarded without prejudice. Some restrictions have to
302 * be handled later in order to generate a kiss-of-death packet.
303 */
304 ntp_monitor(rbufp);
305 restrict_mask = restrictions(&rbufp->recv_srcadr);
306#ifdef DEBUG
307 if (debug > 2)
308 printf("receive: at %ld %s<-%s restrict %02x\n",
309 current_time, ntoa(&rbufp->dstadr->sin),
310 ntoa(&rbufp->recv_srcadr), restrict_mask);
311#endif
312 if (restrict_mask & RES_IGNORE)
313 return; /* no anything */
314 if (!(SRCPORT(&rbufp->recv_srcadr) == NTP_PORT ||
315 SRCPORT(&rbufp->recv_srcadr) >= IPPORT_RESERVED)) {
316 sys_badlength++;
317 return; /* invalid port */
318 }
319 pkt = &rbufp->recv_pkt;
320 if (PKT_VERSION(pkt->li_vn_mode) == NTP_VERSION) {
321 sys_newversionpkt++; /* new version */
322 } else if (!(restrict_mask & RES_VERSION) &&
323 PKT_VERSION(pkt->li_vn_mode) >= NTP_OLDVERSION) {
324 sys_oldversionpkt++; /* old version */
325 } else {
326 sys_unknownversion++;
327 return; /* invalid version */
328 }
329 if (PKT_MODE(pkt->li_vn_mode) == MODE_PRIVATE) {
330 if (restrict_mask & RES_NOQUERY)
331 return; /* no query private */
332 process_private(rbufp, ((restrict_mask &
333 RES_NOMODIFY) == 0));
334 return;
335 }
336 if (PKT_MODE(pkt->li_vn_mode) == MODE_CONTROL) {
337 if (restrict_mask & RES_NOQUERY)
338 return; /* no query control */
339 process_control(rbufp, restrict_mask);
340 return;
341 }
342 if (rbufp->recv_length < LEN_PKT_NOMAC) {
343 sys_badlength++;
344 return; /* runt packet */
345 }
346
347 /*
348 * Validate mode. Note that NTPv1 is no longer supported.
349 */
350 hismode = (int)PKT_MODE(pkt->li_vn_mode);
351 if (hismode == MODE_UNSPEC) {
352 sys_badlength++;
353 return; /* invalid mode */
354 }
355
356 /*
357 * Discard broadcast packets received on the wildcard interface
358 * or if not enabled as broadcast client.
359 */
360 if (PKT_MODE(pkt->li_vn_mode) == MODE_BROADCAST &&
361 (rbufp->dstadr == any_interface || !sys_bclient))
362 return;
363
364 /*
365 * Parse the extension field if present. We figure out whether
366 * an extension field is present by measuring the MAC size. If
367 * the number of words following the packet header is 0 or 1, no
368 * MAC is present and the packet is not authenticated. If 1, the
369 * packet is a reply to a previous request that failed to
370 * authenticate. If 3, the packet is authenticated with DES; if
371 * 5, the packet is authenticated with MD5. If greater than 5,
372 * an extension field is present. If 2 or 4, the packet is a
373 * runt and goes poof! with a brilliant flash.
374 */
375 skeyid = 0;
376#ifdef AUTOKEY
377 pkeyid = tkeyid = 0;
378#endif /* AUTOKEY */
379 authlen = LEN_PKT_NOMAC;
380 while ((has_mac = rbufp->recv_length - authlen) > 0) {
381 int temp;
382
383 if (has_mac % 4 != 0 || has_mac < 0) {
384 sys_badlength++;
385 return;
386 }
387 if (has_mac == 1 * 4 || has_mac == 3 * 4 || has_mac ==
388 MAX_MAC_LEN) {
389 skeyid = ntohl(((u_int32 *)pkt)[authlen / 4]);
390 break;
391
392 } else if (has_mac > MAX_MAC_LEN) {
393 temp = ntohl(((u_int32 *)pkt)[authlen / 4]) &
394 0xffff;
395 if (temp < 4 || temp % 4 != 0) {
396 sys_badlength++;
397 return;
398 }
399 authlen += temp;
400 } else {
401 sys_badlength++;
402 return;
403 }
404 }
405
406 /*
407 * We have tossed out as many buggy packets as possible early in
408 * the game to reduce the exposure to a clogging attack. Now we
409 * have to burn some cycles to find the association and
410 * authenticate the packet if required. Note that we burn only
411 * MD5 or DES cycles, again to reduce exposure. There may be no
412 * matching association and that's okay.
413 *
414 * More on the autokey mambo. Normally the local interface is
415 * found when the association was mobilized with respect to a
416 * designated remote address. We assume packets arriving from
417 * the remote address arrive via this interface and the local
418 * address used to construct the autokey is the unicast address
419 * of the interface. However, if the sender is a broadcaster,
420 * the interface broadcast address is used instead.
421 * Notwithstanding this technobabble, if the sender is a
422 * multicaster, the broadcast address is null, so we use the
423 * unicast address anyway. Don't ask.
424 */
425 peer = findpeer(&rbufp->recv_srcadr, rbufp->dstadr, rbufp->fd,
426 hismode, &retcode);
427 is_authentic = 0;
428 dstadr_sin = &rbufp->dstadr->sin;
429 if (has_mac == 0) {
430#ifdef DEBUG
431 if (debug)
432 printf("receive: at %ld %s<-%s mode %d code %d\n",
433 current_time, ntoa(&rbufp->dstadr->sin),
434 ntoa(&rbufp->recv_srcadr), hismode, retcode);
435#endif
436 } else {
437#ifdef AUTOKEY
438 /*
439 * For autokey modes, generate the session key
440 * and install in the key cache. Use the socket
441 * broadcast or unicast address as appropriate.
442 */
443 if (skeyid > NTP_MAXKEY) {
444
445 /*
446 * More on the autokey dance (AKD). A cookie is
447 * constructed from public and private values.
448 * For broadcast packets, the cookie is public
449 * (zero). For packets that match no
450 * association, the cookie is hashed from the
451 * addresses and private value. For server
452 * packets, the cookie was previously obtained
453 * from the server. For symmetric modes, the
454 * cookie was previously constructed using an
455 * agreement protocol; however, should PKI be
456 * unavailable, we construct a fake agreement as
457 * the EXOR of the peer and host cookies.
458 *
459 * hismode ephemeral persistent
460 * =======================================
461 * active 0 cookie#
462 * passive 0% cookie#
463 * client sys cookie 0%
464 * server 0% sys cookie
465 * broadcast 0 0
466 *
467 * # if unsync, 0
468 * % can't happen
469 */
470 if (hismode == MODE_BROADCAST) {
471
472 /*
473 * For broadcaster, use the interface
474 * broadcast address when available;
475 * otherwise, use the unicast address
476 * found when the association was
477 * mobilized.
478 */
479 pkeyid = 0;
480 if (rbufp->dstadr->bcast.sin_addr.s_addr
481 != 0)
482 dstadr_sin =
483 &rbufp->dstadr->bcast;
484 } else if (peer == NULL) {
485 pkeyid = session_key(
486 &rbufp->recv_srcadr, dstadr_sin, 0,
487 sys_private, 0);
488 } else {
489 pkeyid = peer->pcookie.key;
490 }
491
492 /*
493 * The session key includes both the public
494 * values and cookie. In case of an extension
495 * field, the cookie used for authentication
496 * purposes is zero. Note the hash is saved for
497 * use later in the autokey mambo.
498 */
499 if (authlen > LEN_PKT_NOMAC && pkeyid != 0) {
500 session_key(&rbufp->recv_srcadr,
501 dstadr_sin, skeyid, 0, 2);
502 tkeyid = session_key(
503 &rbufp->recv_srcadr, dstadr_sin,
504 skeyid, pkeyid, 0);
505 } else {
506 tkeyid = session_key(
507 &rbufp->recv_srcadr, dstadr_sin,
508 skeyid, pkeyid, 2);
509 }
510
511 }
512#endif /* AUTOKEY */
513
514 /*
515 * Compute the cryptosum. Note a clogging attack may
516 * succeed in bloating the key cache. If an autokey,
517 * purge it immediately, since we won't be needing it
518 * again.
519 */
520 if (authdecrypt(skeyid, (u_int32 *)pkt, authlen,
521 has_mac))
522 is_authentic = 1;
523 else
524 sys_badauth++;
525#ifdef AUTOKEY
526 if (skeyid > NTP_MAXKEY)
527 authtrust(skeyid, 0);
528#endif /* AUTOKEY */
529#ifdef DEBUG
530 if (debug)
531 printf(
532 "receive: at %ld %s<-%s mode %d code %d keyid %08x len %d mac %d auth %d\n",
533 current_time, ntoa(dstadr_sin),
534 ntoa(&rbufp->recv_srcadr), hismode, retcode,
535 skeyid, authlen, has_mac,
536 is_authentic);
537#endif
538 }
539
540 /*
541 * The association matching rules are implemented by a set of
542 * routines and a table in ntp_peer.c. A packet matching an
543 * association is processed by that association. If not and
544 * certain conditions prevail, then an ephemeral association is
545 * mobilized: a broadcast packet mobilizes a broadcast client
546 * aassociation; a server packet mobilizes a client association;
547 * a symmetric active packet mobilizes a symmetric passive
548 * association. And, the adventure continues...
549 */
550 switch (retcode) {
551 case AM_FXMIT:
552
553 /*
554 * This is a client mode packet not matching a known
555 * association. If from a manycast client we run a few
556 * sanity checks before deciding to send a unicast
557 * server response. Otherwise, it must be a client
558 * request, so send a server response and go home.
559 */
560 if (sys_manycastserver && (rbufp->dstadr->flags &
561 INT_MULTICAST)) {
562
563 /*
564 * We are picky about responding to a
565 * manycaster. There is no reason to respond to
566 * a request if our time is worse than the
567 * manycaster. We certainly don't reply if not
568 * synchronized to proventic time.
569 */
570 if (sys_peer == NULL)
571 return;
572
573 /*
574 * We don't reply if the our stratum is greater
575 * than the manycaster.
576 */
577 if (PKT_TO_STRATUM(pkt->stratum) < sys_stratum)
578 return;
579 }
580
581 /*
582 * Note that we don't require an authentication check
583 * here, since we can't set the system clock; but, we do
584 * set the key ID to zero to tell the caller about this.
585 */
586 if (is_authentic)
587 fast_xmit(rbufp, MODE_SERVER, skeyid,
588 restrict_mask);
589 else
590 fast_xmit(rbufp, MODE_SERVER, 0, restrict_mask);
591 return;
592
593 case AM_MANYCAST:
594
595 /*
596 * This is a server mode packet returned in response to
597 * a client mode packet sent to a multicast group
598 * address. The originate timestamp is a good nonce to
599 * reliably associate the reply with what was sent. If
600 * there is no match, that's curious and could be an
601 * intruder attempting to clog, so we just ignore it.
602 *
603 * First, make sure the packet is authentic. If so and
604 * the manycast association is found, we mobilize a
605 * client mode association, copy pertinent variables
606 * from the manycast to the client mode association and
607 * wind up the spring.
608 *
609 * There is an implosion hazard at the manycast client,
610 * since the manycast servers send the server packet
611 * immediately.
612 */
613 if ((restrict_mask & (RES_DONTSERVE | RES_LIMITED |
614 RES_NOPEER)) || (sys_authenticate &&
615 !is_authentic))
616 return;
617
618 peer2 = findmanycastpeer(rbufp);
619 if (peer2 == 0)
620 return;
621
622 peer = newpeer(&rbufp->recv_srcadr, rbufp->dstadr,
623 MODE_CLIENT, PKT_VERSION(pkt->li_vn_mode),
624 sys_minpoll, NTP_MAXDPOLL, FLAG_IBURST |
625 (peer2->flags & (FLAG_AUTHENABLE | FLAG_SKEY)),
626 MDF_UCAST, 0, skeyid);
627 if (peer == NULL)
628 return;
629 break;
630
631 case AM_NEWPASS:
632
633 /*
634 * This is the first packet received from a symmetric
635 * active peer. First, make sure the packet is
636 * authentic. If so, mobilize a symmetric passive
637 * association.
638 */
639 if ((restrict_mask & (RES_DONTSERVE | RES_LIMITED |
640 RES_NOPEER)) || (sys_authenticate &&
641 !is_authentic)) {
642 fast_xmit(rbufp, MODE_PASSIVE, 0,
643 restrict_mask);
644 return;
645 }
646 peer = newpeer(&rbufp->recv_srcadr, rbufp->dstadr,
647 MODE_PASSIVE, PKT_VERSION(pkt->li_vn_mode),
648 sys_minpoll, NTP_MAXDPOLL, sys_authenticate ?
649 FLAG_AUTHENABLE : 0, MDF_UCAST, 0, skeyid);
650 if (peer == NULL)
651 return;
652 break;
653
654 case AM_NEWBCL:
655
656 /*
657 * This is the first packet received from a broadcast
658 * server. First, make sure the packet is authentic, not
659 * restricted and that we are a broadcast or multicast
660 * client. If so, mobilize a broadcast client
661 * association.
662 */
663 if ((restrict_mask & (RES_DONTSERVE | RES_LIMITED |
664 RES_NOPEER)) || (sys_authenticate &&
665 !is_authentic) || !sys_bclient)
666 return;
667
668 peer = newpeer(&rbufp->recv_srcadr, rbufp->dstadr,
669 MODE_CLIENT, PKT_VERSION(pkt->li_vn_mode),
670 sys_minpoll, NTP_MAXDPOLL, FLAG_MCAST |
671 FLAG_IBURST | (sys_authenticate ?
672 FLAG_AUTHENABLE : 0), MDF_BCLNT, 0, skeyid);
673#ifdef AUTOKEY
674#ifdef PUBKEY
675 if (peer == NULL)
676 return;
677 if (peer->flags & FLAG_SKEY)
678 crypto_recv(peer, rbufp);
679#endif /* PUBKEY */
680#endif /* AUTOKEY */
681 return;
682
683 case AM_POSSBCL:
684 case AM_PROCPKT:
685
686 /*
687 * Happiness and nothing broke. Earn some revenue.
688 */
689 break;
690
691 default:
692
693 /*
694 * Invalid mode combination. Leave the island
695 * immediately.
696 */
697#ifdef DEBUG
698 if (debug)
699 printf("receive: bad protocol %d\n", retcode);
700#endif
701 return;
702 }
703
704 /*
705 * If the peer isn't configured, set his authenable and autokey
706 * status based on the packet. Once the status is set, it can't
707 * be unset. It seems like a silly idea to do this here, rather
708 * in the configuration routine, but in some goofy cases the
709 * first packet sent cannot be authenticated and we need a way
710 * for the dude to change his mind.
711 */
712 oflags = peer->flags;
713 peer->timereceived = current_time;
714 peer->received++;
715 if (!(peer->flags & FLAG_CONFIG) && has_mac) {
716 peer->flags |= FLAG_AUTHENABLE;
717#ifdef AUTOKEY
718 if (skeyid > NTP_MAXKEY)
719 peer->flags |= FLAG_SKEY;
720#endif /* AUTOKEY */
721 }
722
723 /*
724 * A valid packet must be from an authentic and allowed source.
725 * All packets must pass the authentication allowed tests.
726 * Autokey authenticated packets must pass additional tests and
727 * public-key authenticated packets must have the credentials
728 * verified. If all tests are passed, the packet is forwarded
729 * for processing. If not, the packet is discarded and the
730 * association demobilized if appropriate.
731 */
732 peer->flash = 0;
733 if (is_authentic) {
734 peer->flags |= FLAG_AUTHENTIC;
735 } else {
736 peer->flags &= ~FLAG_AUTHENTIC;
737 }
738 if (peer->hmode == MODE_BROADCAST &&
739 (restrict_mask & RES_DONTTRUST)) /* test 4 */
740 peer->flash |= TEST4; /* access denied */
741 if (peer->flags & FLAG_AUTHENABLE) {
742 if (!(peer->flags & FLAG_AUTHENTIC)) /* test 5 */
743 peer->flash |= TEST5; /* auth failed */
744 else if (!(oflags & FLAG_AUTHENABLE))
745 report_event(EVNT_PEERAUTH, peer);
746 }
747 if (peer->flash) {
748#ifdef DEBUG
749 if (debug)
750 printf("receive: bad auth %03x\n", peer->flash);
751#endif
752 return;
753 }
754
755#ifdef AUTOKEY
756 /*
757 * More autokey dance. The rules of the cha-cha are as follows:
758 *
759 * 1. If there is no key or the key is not auto, do nothing.
760 *
761 * 2. If an extension field contains a verified signature, it is
762 * self-authenticated and we sit the dance.
763 *
764 * 3. If this is a server reply, check only to see that the
765 * transmitted key ID matches the received key ID.
766 *
767 * 4. Check to see that one or more hashes of the current key ID
768 * matches the previous key ID or ultimate original key ID
769 * obtained from the broadcaster or symmetric peer. If no
770 * match, sit the dance and wait for timeout.
771 */
772 if (peer->flags & FLAG_SKEY) {
773 peer->flash |= TEST10;
774 crypto_recv(peer, rbufp);
775 poll_update(peer, peer->hpoll);
776 if (hismode == MODE_SERVER) {
777 if (skeyid == peer->keyid)
778 peer->flash &= ~TEST10;
779 } else if (!peer->flash & TEST10) {
780 peer->pkeyid = skeyid;
781 } else {
782 int i;
783
784 for (i = 0; ; i++) {
785 if (tkeyid == peer->pkeyid ||
786 tkeyid == peer->recauto.key) {
787 peer->flash &= ~TEST10;
788 peer->pkeyid = skeyid;
789 break;
790 }
791 if (i > peer->recauto.seq)
792 break;
793 tkeyid = session_key(
794 &rbufp->recv_srcadr, dstadr_sin,
795 tkeyid, pkeyid, 0);
796 }
797 }
798#ifdef PUBKEY
799
800 /*
801 * This is delicious. Ordinarily, we kick out all errors
802 * at this point; however, in symmetric mode and just
803 * warming up, an unsynchronized peer must inject the
804 * timestamps, even if it fails further up the road. So,
805 * let the dude by here, but only if the jerk is not yet
806 * reachable. After that, he's on his own.
807 */
808 if (!(peer->flags & FLAG_PROVEN))
809 peer->flash |= TEST11;
810 if (peer->flash && peer->reach) {
811#ifdef DEBUG
812 if (debug)
813 printf("packet: bad autokey %03x\n",
814 peer->flash);
815#endif
816 return;
817 }
818#endif /* PUBKEY */
819 }
820#endif /* AUTOKEY */
821
822 /*
823 * We have survived the gaunt. Forward to the packet routine. If
824 * a symmetric passive association has been mobilized and the
825 * association doesn't deserve to live, it will die in the
826 * transmit routine if not reachable after timeout.
827 */
828 process_packet(peer, pkt, &rbufp->recv_time);
829}
830
831
832/*
833 * process_packet - Packet Procedure, a la Section 3.4.4 of the
834 * specification. Or almost, at least. If we're in here we have a
835 * reasonable expectation that we will be having a long term
836 * relationship with this host.
837 */
838void
839process_packet(
840 register struct peer *peer,
841 register struct pkt *pkt,
842 l_fp *recv_ts
843 )
844{
845 l_fp t10, t23;
846 double p_offset, p_del, p_disp;
847 double dtemp;
848 l_fp p_rec, p_xmt, p_org, p_reftime;
849 l_fp ci;
850 int pmode, pleap, pstratum;
851
852 /*
853 * Swap header fields and keep the books. The books amount to
854 * the receive timestamp and poll interval in the header. We
855 * need these even if there are other problems in order to crank
856 * up the state machine.
857 */
858 sys_processed++;
859 peer->processed++;
860 p_del = FPTOD(NTOHS_FP(pkt->rootdelay));
861 p_disp = FPTOD(NTOHS_FP(pkt->rootdispersion));
862 NTOHL_FP(&pkt->reftime, &p_reftime);
863 NTOHL_FP(&pkt->rec, &p_rec);
864 NTOHL_FP(&pkt->xmt, &p_xmt);
865 if (PKT_MODE(pkt->li_vn_mode) != MODE_BROADCAST)
866 NTOHL_FP(&pkt->org, &p_org);
867 else
868 p_org = peer->rec;
869
870 /*
871 * Test for old, duplicate or unsynch packets (tests 1-3).
872 */
873 peer->rec = *recv_ts;
874 pmode = PKT_MODE(pkt->li_vn_mode);
875 pleap = PKT_LEAP(pkt->li_vn_mode);
876 pstratum = PKT_TO_STRATUM(pkt->stratum);
877 if (L_ISHIS(&peer->org, &p_xmt)) /* count old packets */
878 peer->oldpkt++;
879 if (L_ISEQU(&peer->org, &p_xmt)) /* 1 */
880 peer->flash |= TEST1; /* dupe */
881 if (pmode != MODE_BROADCAST) {
882 if (!L_ISEQU(&peer->xmt, &p_org)) /* 2 */
883 peer->flash |= TEST2; /* bogus */
884 if (L_ISZERO(&p_rec) || L_ISZERO(&p_org)) /* test 3 */
885 peer->flash |= TEST3; /* unsynch */
886 }
887 if (L_ISZERO(&p_xmt)) /* 3 */
888 peer->flash |= TEST3; /* unsynch */
889 peer->org = p_xmt;
890
891 /*
892 * If tests 1-3 fail, the packet is discarded leaving only the
893 * receive and origin timestamps and poll interval, which is
894 * enough to get the protocol started.
895 */
896 if (peer->flash) {
897#ifdef DEBUG
898 if (debug)
899 printf("packet: bad data %03x\n",
900 peer->flash);
901#endif
902 return;
903 }
904
905 /*
906 * A kiss-of-death (kod) packet is returned by a server in case
907 * the client is denied access. It consists of the client
908 * request packet with the leap bits indicating never
909 * synchronized, stratum zero and reference ID field the ASCII
910 * string "DENY". If the packet originate timestamp matches the
911 * association transmit timestamp the kod is legitimate. If the
912 * peer leap bits indicate never synchronized, this must be
913 * access deny and the association is disabled; otherwise this
914 * must be a limit reject. In either case a naughty message is
915 * forced to the system log.
916 */
917 if (pleap == LEAP_NOTINSYNC && pstratum >= STRATUM_UNSPEC &&
918 memcmp(&pkt->refid, "DENY", 4) == 0) {
919 if (peer->leap == LEAP_NOTINSYNC) {
920 peer->stratum = STRATUM_UNSPEC;
921 peer->flash |= TEST4;
922 memcpy(&peer->refid, &pkt->refid, 4);
923 msyslog(LOG_INFO, "access denied");
924 } else {
925 msyslog(LOG_INFO, "limit reject");
926 }
927 return;
928 }
929
930 /*
931 * Test for valid peer data (tests 6-8)
932 */
933 ci = p_xmt;
934 L_SUB(&ci, &p_reftime);
935 LFPTOD(&ci, dtemp);
936 if (pleap == LEAP_NOTINSYNC || /* 6 */
937 pstratum >= STRATUM_UNSPEC || dtemp < 0)
938 peer->flash |= TEST6; /* bad synch */
939 if (!(peer->flags & FLAG_CONFIG) && sys_peer != NULL) { /* 7 */
940 if (pstratum > sys_stratum && pmode != MODE_ACTIVE) {
941 peer->flash |= TEST7; /* bad stratum */
942 sys_badstratum++;
943 }
944 }
945 if (p_del < 0 || p_disp < 0 || p_del / /* 8 */
946 2 + p_disp >= MAXDISPERSE)
947 peer->flash |= TEST8; /* bad peer distance */
948 if (peer->flash) {
949#ifdef DEBUG
950 if (debug)
951 printf("packet: bad header %03x\n",
952 peer->flash);
953#endif
954 return;
955 }
956
957 /*
958 * The header is valid. Capture the remaining header values and
959 * mark as reachable.
960 */
961 record_raw_stats(&peer->srcadr, &peer->dstadr->sin, &p_org,
962 &p_rec, &p_xmt, &peer->rec);
963 peer->leap = pleap;
964 peer->pmode = pmode;
965 peer->stratum = pstratum;
966 peer->ppoll = pkt->ppoll;
967 peer->precision = pkt->precision;
968 peer->rootdelay = p_del;
969 peer->rootdispersion = p_disp;
970 peer->refid = pkt->refid;
971 peer->reftime = p_reftime;
972 if (!(peer->reach)) {
973 report_event(EVNT_REACH, peer);
974 peer->timereachable = current_time;
975 }
976 peer->reach |= 1;
977 peer->unreach = 0;
978 poll_update(peer, peer->hpoll);
979
980 /*
981 * If running in a client/server association, calculate the
982 * clock offset c, roundtrip delay d and dispersion e. We use
983 * the equations (reordered from those in the spec). Note that,
984 * in a broadcast association, org has been set to the time of
985 * last reception. Note the computation of dispersion includes
--- 4 unchanged lines hidden (view full) ---
990 * d = (t2 - t3) - (t1 - t0)
991 * e = (org - rec) (seconds only)
992 */
993 t10 = p_xmt; /* compute t1 - t0 */
994 L_SUB(&t10, &peer->rec);
995 t23 = p_rec; /* compute t2 - t3 */
996 L_SUB(&t23, &p_org);
997 ci = t10;
998 p_disp = clock_phi * (peer->rec.l_ui - p_org.l_ui);
999
1000 /*
1001 * If running in a broadcast association, the clock offset is
1002 * (t1 - t0) corrected by the one-way delay, but we can't
1003 * measure that directly. Therefore, we start up in MODE_CLIENT
1004 * mode, set FLAG_MCAST and exchange eight messages to determine
1005 * the clock offset. When the last message is sent, we switch to
1006 * MODE_BCLIENT mode. The next broadcast message after that
1007 * computes the broadcast offset and clears FLAG_MCAST.
1008 */
1009 if (pmode == MODE_BROADCAST) {
1010 if (peer->flags & FLAG_MCAST) {
1011 LFPTOD(&ci, p_offset);
1012 peer->estbdelay = peer->offset - p_offset;
1013 if (peer->hmode == MODE_CLIENT)
1014 return;
1015
1016 peer->flags &= ~FLAG_MCAST;
1017 }
1018 DTOLFP(peer->estbdelay, &t10);
1019 L_ADD(&ci, &t10);
1020 p_del = peer->delay;
1021 } else {
1022 L_ADD(&ci, &t23);
1023 L_RSHIFT(&ci);
1024 L_SUB(&t23, &t10);
1025 LFPTOD(&t23, p_del);
1026 }
1027 p_del = max(p_del, LOGTOD(sys_precision));
1028 LFPTOD(&ci, p_offset);
1029 if ((peer->rootdelay + p_del) / 2. + peer->rootdispersion +
1030 p_disp >= MAXDISPERSE) /* 9 */
1031 peer->flash |= TEST9; /* bad peer distance */
1032
1033 /*
1034 * If any flasher bits remain set at this point, abandon ship.
1035 * Otherwise, forward to the clock filter.
1036 */
1037 if (peer->flash) {
1038#ifdef DEBUG
1039 if (debug)
1040 printf("packet: bad packet data %03x\n",
1041 peer->flash);
1042#endif
1043 return;
1044 }
1045 clock_filter(peer, p_offset, p_del, p_disp);
1046 clock_select();
1047 record_peer_stats(&peer->srcadr, ctlpeerstatus(peer),
1048 peer->offset, peer->delay, peer->disp,
1049 SQRT(peer->jitter));
1050}
1051
1052
1053/*
1054 * clock_update - Called at system process update intervals.
1055 */
1056static void
1057clock_update(void)
1058{
1059 u_char oleap;
1060 u_char ostratum;
1061
1062 /*
1063 * Reset/adjust the system clock. Do this only if there is a
1064 * system peer and we haven't seen that peer lately. Watch for
1065 * timewarps here.
1066 */
1067 if (sys_peer == NULL)
1068 return;
1069 if (sys_peer->pollsw == FALSE || sys_peer->burst > 0)
1070 return;
1071 sys_peer->pollsw = FALSE;
1072#ifdef DEBUG
1073 if (debug)
1074 printf("clock_update: at %ld assoc %d \n", current_time,
1075 peer_associations);
1076#endif
1077 oleap = sys_leap;
1078 ostratum = sys_stratum;
1079 switch (local_clock(sys_peer, sys_offset, sys_syserr)) {
1080
1081 /*
1082 * Clock is too screwed up. Just exit for now.
1083 */
1084 case -1:
1085 report_event(EVNT_SYSFAULT, (struct peer *)0);
1086 exit(1);
1087 /*NOTREACHED*/
1088
1089 /*
1090 * Clock was stepped. Flush all time values of all peers.
1091 */
1092 case 1:
1093 clear_all();
1094 sys_peer = NULL;
1095 sys_stratum = STRATUM_UNSPEC;
1096 sys_poll = NTP_MINPOLL;
1097 NLOG(NLOG_SYNCSTATUS)
1098 msyslog(LOG_INFO, "synchronisation lost");
1099 report_event(EVNT_CLOCKRESET, (struct peer *)0);
1100 break;
1101
1102 /*
1103 * Update the system stratum, leap bits, root delay, root
1104 * dispersion, reference ID and reference time. We also update
1105 * select dispersion and max frequency error. If the leap
1106 * changes, we gotta reroll the keys.
1107 */
1108 default:
1109 sys_stratum = sys_peer->stratum + 1;
1110 if (sys_stratum == 1)
1111 sys_refid = sys_peer->refid;
1112 else
1113 sys_refid = sys_peer->srcadr.sin_addr.s_addr;
1114 sys_reftime = sys_peer->rec;
1115 sys_rootdelay = sys_peer->rootdelay + sys_peer->delay;
1116 sys_leap = leap_consensus;
1117 }
1118 if (oleap == LEAP_NOTINSYNC) {
1119 report_event(EVNT_SYNCCHG, (struct peer *)0);
1120#ifdef AUTOKEY
1121 expire_all();
1122#endif /* AUTOKEY */
1123 }
1124 if (ostratum != sys_stratum)
1125 report_event(EVNT_PEERSTCHG, (struct peer *)0);
1126}
1127
1128
1129/*
1130 * poll_update - update peer poll interval
1131 */
1132void
1133poll_update(
1134 struct peer *peer,
1135 int hpoll
1136 )
1137{
1138#ifdef AUTOKEY
1139 int oldpoll;
1140#endif /* AUTOKEY */
1141
1142 /*
1143 * A little foxtrot to determine what controls the poll
1144 * interval. If the peer is reachable, but the last four polls
1145 * have not been answered, use the minimum. If declared
1146 * truechimer, use the system poll interval. This allows each
1147 * association to ramp up the poll interval for useless sources
1148 * and to clamp it to the minimum when first starting up.
1149 */
1150#ifdef AUTOKEY
1151 oldpoll = peer->kpoll;
1152#endif /* AUTOKEY */
1153 if (hpoll > peer->maxpoll)
1154 peer->hpoll = peer->maxpoll;
1155 else if (hpoll < peer->minpoll)
1156 peer->hpoll = peer->minpoll;
1157 else
1158 peer->hpoll = hpoll;
1159
1160 /*
1161 * Bit of adventure here. If during a burst and not timeout,
1162 * just slink away. If timeout, figure what the next timeout
1163 * should be. If IBURST or a reference clock, use one second. If
1164 * not and the dude was reachable during the previous poll
1165 * interval, randomize over 1-4 seconds; otherwise, randomize
1166 * over 15-18 seconds. This is to give time for a modem to
1167 * complete the call, for example. If not during a burst,
1168 * randomize over the poll interval -1 to +2 seconds.
1169 *
1170 * In case of manycast server, make the poll interval, which is
1171 * axtually the manycast beacon interval, eight times the system
1172 * poll interval. Normally when the host poll interval settles
1173 * up to 17.1 s, the beacon interval settles up to 2.3 hours.
1174 */
1175 if (peer->burst > 0) {
1176 if (peer->nextdate != current_time)
1177 return;
1178#ifdef REFCLOCK
1179 else if (peer->flags & FLAG_REFCLOCK)
1180 peer->nextdate++;
1181#endif
1182 else if (peer->reach & 0x1)
1183 peer->nextdate += RANDPOLL(BURST_INTERVAL2);
1184 else
1185 peer->nextdate += RANDPOLL(BURST_INTERVAL1);
1186 } else if (peer->cast_flags & MDF_ACAST) {
1187 if (sys_survivors < NTP_MINCLOCK)
1188 peer->kpoll = peer->hpoll;
1189 else
1190 peer->kpoll = peer->hpoll + 3;
1191 peer->nextdate = peer->outdate + RANDPOLL(peer->kpoll);
1192 } else {
1193 peer->kpoll = max(min(peer->ppoll, peer->hpoll),
1194 peer->minpoll);
1195 peer->nextdate = peer->outdate + RANDPOLL(peer->kpoll);
1196 }
1197 if (peer->nextdate < current_time)
1198 peer->nextdate = current_time;
1199#ifdef AUTOKEY
1200 /*
1201 * Bit of crass arrogance at this point. If the poll interval
1202 * has changed and we have a keylist, the lifetimes in the
1203 * keylist are probably bogus. In this case purge the keylist
1204 * and regenerate it later.
1205 */
1206 if (peer->kpoll != oldpoll)
1207 key_expire(peer);
1208#endif /* AUTOKEY */
1209#ifdef DEBUG
1210 if (debug > 1)
1211 printf("poll_update: at %lu %s flags %04x poll %d burst %d last %lu next %lu\n",
1212 current_time, ntoa(&peer->srcadr), peer->flags,
1213 peer->kpoll, peer->burst, peer->outdate,
1214 peer->nextdate);
1215#endif
1216}
1217
1218
1219/*
1220 * clear - clear peer filter registers. See Section 3.4.8 of the spec.
1221 */
1222void
1223peer_clear(
1224 register struct peer *peer
1225 )
1226{
1227 register int i;
1228 u_long u_rand;
1229
1230 /*
1231 * If cryptographic credentials have been acquired, toss them to
1232 * Valhalla. Note that autokeys are ephemeral, in that they are
1233 * tossed immediately upon use. Therefore, the keylist can be
1234 * purged anytime without needing to preserve random keys. Note
1235 * that, if the peer is purged, the cryptographic variables are
1236 * purged, too. This makes it much harder to sneak in some
1237 * unauthenticated data in the clock filter.
1238 */
1239#ifdef DEBUG
1240 if (debug)
1241 printf("peer_clear: at %ld assoc ID %d\n", current_time,
1242 peer->associd);
1243#endif
1244#ifdef AUTOKEY
1245 key_expire(peer);
1246#ifdef PUBKEY
1247 if (peer->keystr != NULL)
1248 free(peer->keystr);
1249 if (peer->pubkey.ptr != NULL)
1250 free(peer->pubkey.ptr);
1251 if (peer->certif.ptr != NULL)
1252 free(peer->certif.ptr);
1253#endif /* PUBKEY */
1254#endif /* AUTOKEY */
1255 memset(CLEAR_TO_ZERO(peer), 0, LEN_CLEAR_TO_ZERO);
1256
1257 /*
1258 * If he dies as a broadcast client, he comes back to life as
1259 * a broadcast client in client mode in order to recover the
1260 * initial autokey values. Note that there is no need to call
1261 * clock_select(), since the perp has already been voted off
1262 * the island at this point.
1263 */
1264 if (peer->cast_flags & MDF_BCLNT) {
1265 peer->flags |= FLAG_MCAST;
1266 peer->hmode = MODE_CLIENT;
1267 }
1268 peer->flags &= ~(FLAG_AUTOKEY | FLAG_ASSOC);
1269 peer->estbdelay = sys_bdelay;
1270 peer->hpoll = peer->kpoll = peer->minpoll;
1271 peer->ppoll = peer->maxpoll;
1272 peer->pollsw = FALSE;
1273 peer->jitter = MAXDISPERSE;
1274 peer->epoch = current_time;
1275#ifdef REFCLOCK
1276 if (!(peer->flags & FLAG_REFCLOCK)) {
1277 peer->leap = LEAP_NOTINSYNC;
1278 peer->stratum = STRATUM_UNSPEC;
1279 }
1280#endif
1281 for (i = 0; i < NTP_SHIFT; i++) {
1282 peer->filter_order[i] = i;
1283 peer->filter_disp[i] = MAXDISPERSE;
1284 peer->filter_epoch[i] = current_time;
1285 }
1286
1287 /*
1288 * Randomize the first poll over 1-16s to avoid bunching.
1289 */
1290 peer->update = peer->outdate = current_time;
1291 u_rand = RANDOM;
1292 peer->nextdate = current_time + (u_rand & ((1 <<
1293 BURST_INTERVAL1) - 1)) + 1;
1294}
1295
1296
1297/*
1298 * clock_filter - add incoming clock sample to filter register and run
1299 * the filter procedure to find the best sample.
1300 */
1301void
1302clock_filter(
1303 register struct peer *peer, /* peer structure pointer */
1304 double sample_offset, /* clock offset */
1305 double sample_delay, /* roundtrip delay */
1306 double sample_disp /* dispersion */
1307 )
1308{
1309 double dst[NTP_SHIFT]; /* distance vector */
1310 int ord[NTP_SHIFT]; /* index vector */
1311 register int i, j, k, m;
1312 double dsp, jit, dtemp, etemp;
1313
1314 /*
1315 * Shift the new sample into the register and discard the oldest
1316 * one. The new offset and delay come directly from the
1317 * timestamp calculations. The dispersion grows from the last
1318 * outbound packet or reference clock update to the present time
1319 * and increased by the sum of the peer precision and the system
1320 * precision. The delay can sometimes swing negative due to
1321 * frequency skew, so it is clamped non-negative.
1322 */
1323 dsp = min(LOGTOD(peer->precision) + LOGTOD(sys_precision) +
1324 sample_disp, MAXDISPERSE);
1325 j = peer->filter_nextpt;
1326 peer->filter_offset[j] = sample_offset;
1327 peer->filter_delay[j] = max(0, sample_delay);
1328 peer->filter_disp[j] = dsp;
1329 peer->filter_epoch[j] = current_time;
1330 j++; j %=NTP_SHIFT;
1331 peer->filter_nextpt = j;
1332
1333 /*
1334 * Update dispersions since the last update and at the same
1335 * time initialize the distance and index lists. The distance
1336 * list uses a compound metric. If the sample is valid and
1337 * younger than the minimum Allan intercept, use delay;
1338 * otherwise, use biased dispersion.
1339 */
1340 dtemp = clock_phi * (current_time - peer->update);
1341 peer->update = current_time;
1342 for (i = NTP_SHIFT - 1; i >= 0; i--) {
1343 if (i != 0) {
1344 peer->filter_disp[j] += dtemp;
1345 if (peer->filter_disp[j] > MAXDISPERSE)
1346 peer->filter_disp[j] = MAXDISPERSE;
1347 }
1348 if (peer->filter_disp[j] >= MAXDISPERSE)
1349 dst[i] = MAXDISPERSE;
1350 else if (peer->update - peer->filter_epoch[j] >
1351 allan_xpt)
1352 dst[i] = MAXDISTANCE + peer->filter_disp[j];
1353 else
1354 dst[i] = peer->filter_delay[j];
1355 ord[i] = j;
1356 j++; j %= NTP_SHIFT;
1357 }
1358
1359 /*
1360 * Sort the samples in both lists by distance.
1361 */
1362 for (i = 1; i < NTP_SHIFT; i++) {
1363 for (j = 0; j < i; j++) {
1364 if (dst[j] > dst[i]) {
1365 k = ord[j];
1366 ord[j] = ord[i];
1367 ord[i] = k;
1368 etemp = dst[j];
1369 dst[j] = dst[i];
1370 dst[i] = etemp;
1371 }
1372 }
1373 }
1374
1375 /*
1376 * Copy the index list to the association structure so ntpq
1377 * can see it later. Prune the distance list to samples less
1378 * than MAXDISTANCE, but keep at least two valid samples for
1379 * jitter calculation.
1380 */
1381 m = 0;
1382 for (i = 0; i < NTP_SHIFT; i++) {
1383 peer->filter_order[i] = ord[i];
1384 if (dst[i] >= MAXDISPERSE || (m >= 2 && dst[i] >=
1385 MAXDISTANCE))
1386 continue;
1387 m++;
1388 }
1389
1390 /*
1391 * Compute the dispersion and jitter squares. The dispersion
1392 * is weighted exponentially by NTP_FWEIGHT (0.5) so it is
1393 * normalized close to 1.0. The jitter is the mean of the square
1394 * differences relative to the lowest delay sample. If no
1395 * acceptable samples remain in the shift register, quietly
1396 * tiptoe home leaving only the
1397 * dispersion.
1398 */
1399 jit = 0;
1400 peer->disp = 0;
1401 k = ord[0];
1402 for (i = NTP_SHIFT - 1; i >= 0; i--) {
1403
1404 j = ord[i];
1405 peer->disp = NTP_FWEIGHT * (peer->disp +
1406 peer->filter_disp[j]);
1407 if (i < m)
1408 jit += DIFF(peer->filter_offset[j],
1409 peer->filter_offset[k]);
1410 }
1411
1412 /*
1413 * If no acceptable samples remain in the shift register,
1414 * quietly tiptoe home leaving only the dispersion. Otherwise,
1415 * save the offset, delay and jitter average. Note the jitter
1416 * must not be less than the system precision.
1417 */
1418 if (m == 0)
1419 return;
1420 etemp = peer->offset;
1421 peer->offset = peer->filter_offset[k];
1422 peer->delay = peer->filter_delay[k];
1423 if (m > 1)
1424 jit /= m - 1;
1425 peer->jitter = max(jit, SQUARE(LOGTOD(sys_precision)));
1426
1427 /*
1428 * A new sample is useful only if it is younger than the last
1429 * one used.
1430 */
1431 if (peer->filter_epoch[k] <= peer->epoch) {
1432#ifdef DEBUG
1433 if (debug)
1434 printf("clock_filter: discard %lu\n",
1435 peer->epoch - peer->filter_epoch[k]);
1436#endif
1437 return;
1438 }
1439
1440 /*
1441 * If the difference between the last offset and the current one
1442 * exceeds the jitter by CLOCK_SGATE (4) and the interval since
1443 * the last update is less than twice the system poll interval,
1444 * consider the update a popcorn spike and ignore it.
1445 */
1446 if (m > 1 && fabs(peer->offset - etemp) > SQRT(peer->jitter) *
1447 CLOCK_SGATE && peer->filter_epoch[k] - peer->epoch <
1448 (1 << (sys_poll + 1))) {
1449#ifdef DEBUG
1450 if (debug)
1451 printf("clock_filter: n %d popcorn spike %.6f jitter %.6f\n",
1452 m, peer->offset, SQRT(peer->jitter));
1453#endif
1454 return;
1455 }
1456
1457 /*
1458 * The mitigated sample statistics are saved for later
1459 * processing, but can be processed only once.
1460 */
1461 peer->epoch = peer->filter_epoch[k];
1462 peer->pollsw = TRUE;
1463#ifdef DEBUG
1464 if (debug)
1465 printf(
1466 "clock_filter: n %d off %.6f del %.6f dsp %.6f jit %.6f, age %lu\n",
1467 m, peer->offset, peer->delay, peer->disp,
1468 SQRT(peer->jitter), peer->update - peer->epoch);
1469#endif
1470}
1471
1472
1473/*
1474 * clock_select - find the pick-of-the-litter clock
1475 */
1476void
1477clock_select(void)
1478{
1479 register struct peer *peer;
1480 int i, j, k, n;
1481 int nreach, nlist, nl3;
1482 double d, e, f;
1483 int allow, found, sw;
1484 double high, low;
1485 double synch[NTP_MAXCLOCK], error[NTP_MAXCLOCK];
1486 struct peer *osys_peer;
1487 struct peer *typeacts = NULL;
1488 struct peer *typelocal = NULL;
1489 struct peer *typepps = NULL;
1490 struct peer *typesystem = NULL;
1491
1492 static int list_alloc = 0;
1493 static struct endpoint *endpoint = NULL;
1494 static int *indx = NULL;
1495 static struct peer **peer_list = NULL;
1496 static u_int endpoint_size = 0;
1497 static u_int indx_size = 0;
1498 static u_int peer_list_size = 0;
1499
1500 /*
1501 * Initialize and create endpoint, index and peer lists big
1502 * enough to handle all associations.
1503 */
1504 osys_peer = sys_peer;
1505 sys_peer = NULL;
1506 sys_prefer = NULL;
1507 nreach = nlist = 0;
1508 low = 1e9;
1509 high = -1e9;
1510 for (n = 0; n < HASH_SIZE; n++)
1511 nlist += peer_hash_count[n];
1512 if (nlist > list_alloc) {
1513 if (list_alloc > 0) {
1514 free(endpoint);
1515 free(indx);
1516 free(peer_list);
1517 }
1518 while (list_alloc < nlist) {
1519 list_alloc += 5;
1520 endpoint_size += 5 * 3 * sizeof(*endpoint);
1521 indx_size += 5 * 3 * sizeof(*indx);
1522 peer_list_size += 5 * sizeof(*peer_list);
1523 }
1524 endpoint = (struct endpoint *)emalloc(endpoint_size);
1525 indx = (int *)emalloc(indx_size);
1526 peer_list = (struct peer **)emalloc(peer_list_size);
1527 }
1528
1529 /*
1530 * Initially, we populate the island with all the rifraff peers
1531 * that happen to be lying around. Those with seriously
1532 * defective clocks are immediately booted off the island. Then,
1533 * the falsetickers are culled and put to sea. The truechimers
1534 * remaining are subject to repeated rounds where the most
1535 * unpopular at each round is kicked off. When the population
1536 * has dwindled to NTP_MINCLOCK (3), the survivors split a
1537 * million bucks and collectively crank the chimes.
1538 */
1539 nlist = nl3 = 0; /* none yet */
1540 for (n = 0; n < HASH_SIZE; n++) {
1541 for (peer = peer_hash[n]; peer != NULL; peer =
1542 peer->next) {
1543 peer->flags &= ~FLAG_SYSPEER;
1544 peer->status = CTL_PST_SEL_REJECT;
1545
1546 /*
1547 * A peer leaves the island immediately if
1548 * unreachable, synchronized to us or suffers
1549 * excessive root distance. Careful with the
1550 * root distance, since the poll interval can
1551 * increase to a day and a half.
1552 */
1553 if (!peer->reach || (peer->stratum > 1 &&
1554 peer->refid ==
1555 peer->dstadr->sin.sin_addr.s_addr) ||
1556 peer->stratum >= STRATUM_UNSPEC ||
1557 (root_distance(peer) >= MAXDISTANCE + 2 *
1558 clock_phi * ULOGTOD(sys_poll)))
1559 continue;
1560
1561 /*
1562 * Don't allow the local clock or modem drivers
1563 * in the kitchen at this point, unless the
1564 * prefer peer. Do that later, but only if
1565 * nobody else is around. These guys are all
1566 * configured, so we never throw them away.
1567 */
1568 if (peer->refclktype == REFCLK_LOCALCLOCK
1569#if defined(VMS) && defined(VMS_LOCALUNIT)
1570 /* wjm: local unit VMS_LOCALUNIT taken seriously */
1571 && REFCLOCKUNIT(&peer->srcadr) != VMS_LOCALUNIT
1572#endif /* VMS && VMS_LOCALUNIT */
1573 ) {
1574 typelocal = peer;
1575 if (!(peer->flags & FLAG_PREFER))
1576 continue; /* no local clock */
1577 }
1578 if (peer->sstclktype == CTL_SST_TS_TELEPHONE) {
1579 typeacts = peer;
1580 if (!(peer->flags & FLAG_PREFER))
1581 continue; /* no acts */
1582 }
1583
1584 /*
1585 * If we get this far, the peer can stay on the
1586 * island, but does not yet have the immunity
1587 * idol.
1588 */
1589 nreach++;
1590 peer->status = CTL_PST_SEL_SANE;
1591 peer_list[nlist++] = peer;
1592
1593 /*
1594 * Insert each interval endpoint on the sorted
1595 * list.
1596 */
1597 e = peer->offset; /* Upper end */
1598 f = root_distance(peer);
1599 e = e + f;
1600 for (i = nl3 - 1; i >= 0; i--) {
1601 if (e >= endpoint[indx[i]].val)
1602 break;
1603 indx[i + 3] = indx[i];
1604 }
1605 indx[i + 3] = nl3;
1606 endpoint[nl3].type = 1;
1607 endpoint[nl3++].val = e;
1608
1609 e = e - f; /* Center point */
1610 for ( ; i >= 0; i--) {
1611 if (e >= endpoint[indx[i]].val)
1612 break;
1613 indx[i + 2] = indx[i];
1614 }
1615 indx[i + 2] = nl3;
1616 endpoint[nl3].type = 0;
1617 endpoint[nl3++].val = e;
1618
1619 e = e - f; /* Lower end */
1620 for ( ; i >= 0; i--) {
1621 if (e >= endpoint[indx[i]].val)
1622 break;
1623 indx[i + 1] = indx[i];
1624 }
1625 indx[i + 1] = nl3;
1626 endpoint[nl3].type = -1;
1627 endpoint[nl3++].val = e;
1628 }
1629 }
1630#ifdef DEBUG
1631 if (debug > 2)
1632 for (i = 0; i < nl3; i++)
1633 printf("select: endpoint %2d %.6f\n",
1634 endpoint[indx[i]].type,
1635 endpoint[indx[i]].val);
1636#endif
1637 i = 0;
1638 j = nl3 - 1;
1639 allow = nlist; /* falsetickers assumed */
1640 found = 0;
1641 while (allow > 0) {
1642 allow--;
1643 for (n = 0; i <= j; i++) {
1644 n += endpoint[indx[i]].type;
1645 if (n < 0)
1646 break;
1647 if (endpoint[indx[i]].type == 0)
1648 found++;
1649 }
1650 for (n = 0; i <= j; j--) {
1651 n += endpoint[indx[j]].type;
1652 if (n > 0)
1653 break;
1654 if (endpoint[indx[j]].type == 0)
1655 found++;
1656 }
1657 if (found > allow)
1658 break;
1659 low = endpoint[indx[i++]].val;
1660 high = endpoint[indx[j--]].val;
1661 }
1662
1663 /*
1664 * If no survivors remain at this point, check if the local
1665 * clock or modem drivers have been found. If so, nominate one
1666 * of them as the only survivor. Otherwise, give up and declare
1667 * us unsynchronized.
1668 */
1669 if ((allow << 1) >= nlist) {
1670 if (typeacts != 0) {
1671 typeacts->status = CTL_PST_SEL_SANE;
1672 peer_list[0] = typeacts;
1673 nlist = 1;
1674 } else if (typelocal != 0) {
1675 typelocal->status = CTL_PST_SEL_SANE;
1676 peer_list[0] = typelocal;
1677 nlist = 1;
1678 } else {
1679 if (osys_peer != NULL) {
1680 sys_poll = NTP_MINPOLL;
1681 NLOG(NLOG_SYNCSTATUS)
1682 msyslog(LOG_INFO,
1683 "synchronisation lost");
1684 report_event(EVNT_PEERSTCHG,
1685 (struct peer *)0);
1686 }
1687 sys_survivors = 0;
1688#ifdef AUTOKEY
1689 resetmanycast();
1690#endif /* AUTOKEY */
1691 return;
1692 }
1693 }
1694#ifdef DEBUG
1695 if (debug > 2)
1696 printf("select: low %.6f high %.6f\n", low, high);
1697#endif
1698
1699 /*
1700 * Clustering algorithm. Construct candidate list in order first
1701 * by stratum then by root distance. If we have more than
1702 * MAXCLOCK peers, keep only the best MAXCLOCK of them. Scan the
1703 * list to find falsetickers, who leave the island immediately.
1704 * If a falseticker is not configured, his association raft is
1705 * drowned as well. We must leave at least one peer to collect
1706 * the million bucks.
1707 */
1708 j = 0;
1709 for (i = 0; i < nlist; i++) {
1710 peer = peer_list[i];
1711 if (nlist > 1 && (low >= peer->offset || peer->offset >=
1712 high)) {
1713 if (!(peer->flags & FLAG_CONFIG))
1714 unpeer(peer);
1715 continue;
1716 }
1717 peer->status = CTL_PST_SEL_DISTSYSPEER;
1718 d = root_distance(peer) + peer->stratum * MAXDISPERSE;
1719 if (j >= NTP_MAXCLOCK) {
1720 if (d >= synch[j - 1])
1721 continue;
1722 else
1723 j--;
1724 }
1725 for (k = j; k > 0; k--) {
1726 if (d >= synch[k - 1])
1727 break;
1728 peer_list[k] = peer_list[k - 1];
1729 error[k] = error[k - 1];
1730 synch[k] = synch[k - 1];
1731 }
1732 peer_list[k] = peer;
1733 error[k] = peer->jitter;
1734 synch[k] = d;
1735 j++;
1736 }
1737 nlist = j;
1738 for (i = 0; i < nlist; i++) {
1739 peer_list[i]->status = CTL_PST_SEL_SELCAND;
1740
1741#ifdef DEBUG
1742 if (debug > 2)
1743 printf("select: %s distance %.6f\n",
1744 ntoa(&peer_list[i]->srcadr), synch[i]);
1745#endif
1746 }
1747
1748 /*
1749 * Now, vote outlyers off the island by select jitter weighted
1750 * by root dispersion. Continue voting as long as there are more
1751 * than NTP_MINCLOCK survivors and the minimum select jitter
1752 * squared is greater than the maximum peer jitter squared. Stop
1753 * if we are about to discard a prefer peer, who of course has
1754 * the immunity idol.
1755 */
1756 while (1) {
1757 d = 1e9;
1758 e = -1e9;
1759 k = 0;
1760 for (i = 0; i < nlist; i++) {
1761
1762 if (error[i] < d)
1763 d = error[i];
1764 f = 0;
1765 if (nlist > 1) {
1766 for (j = 0; j < nlist; j++)
1767 f += DIFF(peer_list[j]->offset,
1768 peer_list[i]->offset);
1769 f /= nlist - 1;
1770 }
1771 f = max(f, SQUARE(LOGTOD(sys_precision)));
1772 if (f * synch[i] > e) {
1773 sys_selerr = f;
1774 e = f * synch[i];
1775 k = i;
1776 }
1777 }
1778
1779#ifdef DEBUG
1780 if (debug > 2)
1781 printf(
1782 "select: survivors %d select %.6f peer %.6f\n",
1783 k, SQRT(sys_selerr), SQRT(d));
1784#endif
1785 if (nlist <= NTP_MINCLOCK || sys_selerr <= d ||
1786 peer_list[k]->flags & FLAG_PREFER)
1787 break;
1788 if (!(peer_list[k]->flags & FLAG_CONFIG))
1789 unpeer(peer_list[k]);
1790 for (j = k + 1; j < nlist; j++) {
1791 peer_list[j - 1] = peer_list[j];
1792 error[j - 1] = error[j];
1793 }
1794 nlist--;
1795 }
1796
1797#ifdef AUTOKEY
1798 /*
1799 * In manycast client mode we may have spooked a sizeable number
1800 * of servers that we don't need. If there are at least
1801 * NTP_MINCLOCK of them, the manycast message will be turned
1802 * off. By the time we get here we nay be ready to prune some of
1803 * them back, but we want to make sure all the candicates have
1804 * had a chance. If they didn't pass the sanity and intersection
1805 * tests, they have already been voted off the island.
1806 */
1807 if (sys_survivors >= NTP_MINCLOCK && nlist < NTP_MINCLOCK)
1808 resetmanycast();
1809#endif /* AUTOKEY */
1810 sys_survivors = nlist;
1811
1812#ifdef DEBUG
1813 if (debug > 2) {
1814 for (i = 0; i < nlist; i++)
1815 printf(
1816 "select: %s offset %.6f, distance %.6f poll %d\n",
1817 ntoa(&peer_list[i]->srcadr),
1818 peer_list[i]->offset, synch[i],
1819 peer_list[i]->pollsw);
1820 }
1821#endif
1822
1823 /*
1824 * What remains is a list of not greater than NTP_MINCLOCK
1825 * peers. We want only a peer at the lowest stratum to become
1826 * the system peer, although all survivors are eligible for the
1827 * combining algorithm. First record their order, diddle the
1828 * flags and clamp the poll intervals. Then, consider the peers
1829 * at the lowest stratum. Of these, OR the leap bits on the
1830 * assumption that, if some of them honk nonzero bits, they must
1831 * know what they are doing. Also, check for prefer and pps
1832 * peers. If a prefer peer is found within clock_max, update the
1833 * pps switch. Of the other peers not at the lowest stratum,
1834 * check if the system peer is among them and, if found, zap
1835 * him. We note that the head of the list is at the lowest
1836 * stratum and that unsynchronized peers cannot survive this
1837 * far.
1838 *
1839 * Note that we go no further, unless the number of survivors is
1840 * a majority of the suckers that have been found reachable and
1841 * no prior source is available. This avoids the transient when
1842 * one of a flock of sources is out to lunch and just happens
1843 * to be the first survivor.
1844 */
1845 if (osys_peer == NULL && 2 * nlist < min(nreach, NTP_MINCLOCK))
1846 return;
1847 leap_consensus = 0;
1848 for (i = nlist - 1; i >= 0; i--) {
1849 peer = peer_list[i];
1850 peer->status = CTL_PST_SEL_SYNCCAND;
1851 peer->flags |= FLAG_SYSPEER;
1852 poll_update(peer, peer->hpoll);
1853 if (peer->stratum == peer_list[0]->stratum) {
1854 leap_consensus |= peer->leap;
1855 if (peer->refclktype == REFCLK_ATOM_PPS &&
1856 peer->stratum < STRATUM_UNSPEC)
1857 typepps = peer;
1858 if (peer == osys_peer)
1859 typesystem = peer;
1860 if (peer->flags & FLAG_PREFER)
1861 sys_prefer = peer;
1862 }
1863 }
1864
1865 /*
1866 * Mitigation rules of the game. There are several types of
1867 * peers that make a difference here: (1) prefer local peers
1868 * (type REFCLK_LOCALCLOCK with FLAG_PREFER) or prefer modem
1869 * peers (type REFCLK_NIST_ATOM etc with FLAG_PREFER), (2) pps
1870 * peers (type REFCLK_ATOM_PPS), (3) remaining prefer peers
1871 * (flag FLAG_PREFER), (4) the existing system peer, if any, (5)
1872 * the head of the survivor list. Note that only one peer can be
1873 * declared prefer. The order of preference is in the order
1874 * stated. Note that all of these must be at the lowest stratum,
1875 * i.e., the stratum of the head of the survivor list.
1876 */
1877 if (sys_prefer)
1878 sw = sys_prefer->refclktype == REFCLK_LOCALCLOCK ||
1879 sys_prefer->sstclktype == CTL_SST_TS_TELEPHONE ||
1880 !typepps;
1881 else
1882 sw = 0;
1883 if (sw) {
1884 sys_peer = sys_prefer;
1885 sys_peer->status = CTL_PST_SEL_SYSPEER;
1886 sys_offset = sys_peer->offset;
1887 sys_syserr = sys_peer->jitter;
1888#ifdef DEBUG
1889 if (debug > 1)
1890 printf("select: prefer offset %.6f\n",
1891 sys_offset);
1892#endif
1893 } else if (typepps) {
1894 sys_peer = typepps;
1895 sys_peer->status = CTL_PST_SEL_PPS;
1896 sys_offset = sys_peer->offset;
1897 sys_syserr = sys_peer->jitter;
1898 if (!pps_control)
1899 NLOG(NLOG_SYSEVENT)
1900 msyslog(LOG_INFO,
1901 "pps sync enabled");
1902 pps_control = current_time;
1903#ifdef DEBUG
1904 if (debug > 1)
1905 printf("select: pps offset %.6f\n",
1906 sys_offset);
1907#endif
1908 } else {
1909 if (typesystem)
1910 sys_peer = osys_peer;
1911 else
1912 sys_peer = peer_list[0];
1913 sys_peer->status = CTL_PST_SEL_SYSPEER;
1914 sys_offset = clock_combine(peer_list, nlist);
1915 sys_syserr = sys_peer->jitter + sys_selerr;
1916#ifdef DEBUG
1917 if (debug > 1)
1918 printf("select: combine offset %.6f\n",
1919 sys_offset);
1920#endif
1921 }
1922 if (osys_peer != sys_peer)
1923 report_event(EVNT_PEERSTCHG, (struct peer *)0);
--- 23 unchanged lines hidden (view full) ---
1947/*
1948 * root_distance - compute synchronization distance from peer to root
1949 */
1950static double
1951root_distance(
1952 struct peer *peer
1953 )
1954{
1955 /*
1956 * Careful squeak here. The value returned must be greater than
1957 * zero blamed on the peer jitter, which must be at least the
1958 * square of sys_precision.
1959 */
1960 return ((peer->rootdelay + peer->delay) / 2 +
1961 peer->rootdispersion + peer->disp + clock_phi *
1962 (current_time - peer->update) + SQRT(peer->jitter));
1963}
1964
1965/*
1966 * peer_xmit - send packet for persistent association.
1967 */
1968static void
1969peer_xmit(
1970 struct peer *peer /* peer structure pointer */
1971 )
1972{
1973 struct pkt xpkt; /* transmit packet */
1974 int sendlen, authlen;
1975 keyid_t xkeyid; /* transmit key ID */
1976 l_fp xmt_tx;
1977
1978 /*
1979 * Initialize transmit packet header fields.
1980 */
1981 xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap, peer->version,
1982 peer->hmode);
1983 xpkt.stratum = STRATUM_TO_PKT(sys_stratum);
1984 xpkt.ppoll = peer->hpoll;
1985 xpkt.precision = sys_precision;
1986 xpkt.rootdelay = HTONS_FP(DTOFP(sys_rootdelay));
1987 xpkt.rootdispersion = HTONS_FP(DTOUFP(sys_rootdispersion));
1988 xpkt.refid = sys_refid;
1989 HTONL_FP(&sys_reftime, &xpkt.reftime);
1990 HTONL_FP(&peer->org, &xpkt.org);
1991 HTONL_FP(&peer->rec, &xpkt.rec);
1992
1993 /*
1994 * If the received packet contains a MAC, the transmitted packet
1995 * is authenticated and contains a MAC. If not, the transmitted
1996 * packet is not authenticated.
1997 *
1998 * In the current I/O semantics the default interface is set
1999 * until after receiving a packet and setting the right
2000 * interface. So, the first packet goes out unauthenticated.
2001 * That's why the really icky test next is here.
2002 */
2003 sendlen = LEN_PKT_NOMAC;
2004 if (!(peer->flags & FLAG_AUTHENABLE)) {
2005 get_systime(&peer->xmt);
2006 HTONL_FP(&peer->xmt, &xpkt.xmt);
2007 sendpkt(&peer->srcadr, peer->dstadr, peer->ttl, &xpkt,
2008 sendlen);
2009 peer->sent++;
2010#ifdef DEBUG
2011 if (debug)
2012 printf("transmit: at %ld %s->%s mode %d\n",
2013 current_time, ntoa(&peer->dstadr->sin),
2014 ntoa(&peer->srcadr), peer->hmode);
2015#endif
2016 return;
2017 }
2018
2019 /*
2020 * The received packet contains a MAC, so the transmitted packet
2021 * must be authenticated. If autokey is enabled, fuss with the
2022 * various modes; otherwise, private key cryptography is used.
2023 */
2024#ifdef AUTOKEY
2025 if ((peer->flags & FLAG_SKEY)) {
2026 u_int cmmd;
2027
2028 /*
2029 * The Public Key Dance (PKD): Cryptographic credentials
2030 * are contained in extension fields, each including a
2031 * 4-octet length/code word followed by a 4-octet
2032 * association ID and optional additional data. Optional
2033 * data includes a 4-octet data length field followed by
2034 * the data itself. Request messages are sent from a
2035 * configured association; response messages can be sent
2036 * from a configured association or can take the fast
2037 * path without ever matching an association. Response
2038 * messages have the same code as the request, but have
2039 * a response bit and possibly an error bit set. In this
2040 * implementation, a message may contain no more than
2041 * one command and no more than one response.
2042 *
2043 * Cryptographic session keys include both a public and
2044 * a private componet. Request and response messages
2045 * using extension fields are always sent with the
2046 * private component set to zero. Packets without
2047 * extension fields indlude the private component when
2048 * the session key is generated.
2049 */
2050 while (1) {
2051
2052 /*
2053 * Allocate and initialize a keylist if not
2054 * already done. Then, use the list in inverse
2055 * order, discarding keys once used. Keep the
2056 * latest key around until the next one, so
2057 * clients can use client/server packets to
2058 * compute propagation delay.
2059 *
2060 * Note that once a key is used from the list,
2061 * it is retained in the key cache until the
2062 * next key is used. This is to allow a client
2063 * to retrieve the encrypted session key
2064 * identifier to verify authenticity.
2065 *
2066 * If for some reason a key is no longer in the
2067 * key cache, a birthday has happened and the
2068 * pseudo-random sequence is probably broken. In
2069 * that case, purge the keylist and regenerate
2070 * it.
2071 */
2072 if (peer->keynumber == 0)
2073 make_keylist(peer, peer->dstadr);
2074 else
2075 peer->keynumber--;
2076 xkeyid = peer->keylist[peer->keynumber];
2077 if (authistrusted(xkeyid))
2078 break;
2079 else
2080 key_expire(peer);
2081 }
2082 peer->keyid = xkeyid;
2083 switch (peer->hmode) {
2084
2085 /*
2086 * In broadcast mode the autokey values are required.
2087 * Send them when a new keylist is generated; otherwise,
2088 * send the association ID so the client can request
2089 * them at other times.
2090 */
2091 case MODE_BROADCAST:
2092 if (peer->flags & FLAG_ASSOC)
2093 cmmd = CRYPTO_AUTO | CRYPTO_RESP;
2094 else
2095 cmmd = CRYPTO_ASSOC | CRYPTO_RESP;
2096 sendlen += crypto_xmit((u_int32 *)&xpkt,
2097 sendlen, cmmd, 0, peer->associd);
2098 break;
2099
2100 /*
2101 * In symmetric modes the public key, leapsecond table,
2102 * agreement parameters and autokey values are required.
2103 *
2104 * 1. If a response is pending, always send it first.
2105 *
2106 * 2. Don't send anything except a public-key request
2107 * until the public key has been stored.
2108 *
2109 * 3. Once the public key has been stored, don't send
2110 * anything except an agreement parameter request
2111 * until the agreement parameters have been stored.
2112 *
2113 * 4. Once the argeement parameters have been stored,
2114 * don't send anything except a public value request
2115 * until the agreed key has been stored.
2116 *
2117 * 5. When the agreed key has been stored and the key
2118 * list is regenerated, send the autokey values
2119 * gratis unless they have already been sent.
2120 */
2121 case MODE_ACTIVE:
2122 case MODE_PASSIVE:
2123#ifdef PUBKEY
2124 if (peer->cmmd != 0)
2125 sendlen += crypto_xmit((u_int32 *)&xpkt,
2126 sendlen, (peer->cmmd >> 16) |
2127 CRYPTO_RESP, peer->hcookie,
2128 peer->associd);
2129 if (!peer->crypto)
2130 sendlen += crypto_xmit((u_int32 *)&xpkt,
2131 sendlen, CRYPTO_ASSOC,
2132 peer->hcookie, peer->assoc);
2133 else if (!crypto_flags &&
2134 peer->pcookie.tstamp == 0 && sys_leap !=
2135 LEAP_NOTINSYNC)
2136 sendlen += crypto_xmit((u_int32 *)&xpkt,
2137 sendlen, CRYPTO_PRIV, peer->hcookie,
2138 peer->assoc);
2139 else if (crypto_flags && peer->pubkey.ptr ==
2140 NULL)
2141 sendlen += crypto_xmit((u_int32 *)&xpkt,
2142 sendlen, CRYPTO_NAME, peer->hcookie,
2143 peer->assoc);
2144 else if (peer->crypto & CRYPTO_FLAG_CERT)
2145 sendlen += crypto_xmit((u_int32 *)&xpkt,
2146 sendlen, CRYPTO_CERT, peer->hcookie,
2147 peer->assoc);
2148 else if (crypto_flags && peer->crypto &
2149 CRYPTO_FLAG_DH && sys_leap !=
2150 LEAP_NOTINSYNC)
2151 sendlen += crypto_xmit((u_int32 *)&xpkt,
2152 sendlen, CRYPTO_DHPAR,
2153 peer->hcookie, peer->assoc);
2154 else if (crypto_flags && peer->pcookie.tstamp ==
2155 0 && sys_leap != LEAP_NOTINSYNC)
2156 sendlen += crypto_xmit((u_int32 *)&xpkt,
2157 sendlen, CRYPTO_DH, peer->hcookie,
2158 peer->assoc);
2159#else
2160 if (peer->cmmd != 0)
2161 sendlen += crypto_xmit((u_int32 *)&xpkt,
2162 sendlen, (peer->cmmd >> 16) |
2163 CRYPTO_RESP, peer->hcookie,
2164 peer->associd);
2165 if (peer->pcookie.tstamp == 0 && sys_leap !=
2166 LEAP_NOTINSYNC)
2167 sendlen += crypto_xmit((u_int32 *)&xpkt,
2168 sendlen, CRYPTO_PRIV, peer->hcookie,
2169 peer->assoc);
2170#endif /* PUBKEY */
2171 else if (!(peer->flags & FLAG_AUTOKEY))
2172 sendlen += crypto_xmit((u_int32 *)&xpkt,
2173 sendlen, CRYPTO_AUTO, peer->hcookie,
2174 peer->assoc);
2175 else if ((peer->flags & FLAG_ASSOC) &&
2176 (peer->cmmd >> 16) != CRYPTO_AUTO)
2177 sendlen += crypto_xmit((u_int32 *)&xpkt,
2178 sendlen, CRYPTO_AUTO | CRYPTO_RESP,
2179 peer->hcookie, peer->associd);
2180#ifdef PUBKEY
2181 else if (peer->crypto & CRYPTO_FLAG_TAI)
2182 sendlen += crypto_xmit((u_int32 *)&xpkt,
2183 sendlen, CRYPTO_TAI, peer->hcookie,
2184 peer->assoc);
2185#endif /* PUBKEY */
2186 peer->cmmd = 0;
2187 break;
2188
2189 /*
2190 * In client mode, the public key, host cookie and
2191 * autokey values are required. In broadcast client
2192 * mode, these values must be acquired during the
2193 * client/server exchange to avoid having to wait until
2194 * the next key list regeneration. Otherwise, the poor
2195 * dude may die a lingering death until becoming
2196 * unreachable and attempting rebirth. Note that we ask
2197 * for the cookie at each key list regeneration anyway.
2198 */
2199 case MODE_CLIENT:
2200 if (peer->cmmd != 0)
2201 sendlen += crypto_xmit((u_int32 *)&xpkt,
2202 sendlen, (peer->cmmd >> 16) |
2203 CRYPTO_RESP, peer->hcookie,
2204 peer->associd);
2205 if (!peer->crypto)
2206 sendlen += crypto_xmit((u_int32 *)&xpkt,
2207 sendlen, CRYPTO_ASSOC,
2208 peer->hcookie, peer->assoc);
2209#ifdef PUBKEY
2210 else if (crypto_flags && peer->pubkey.ptr ==
2211 NULL)
2212 sendlen += crypto_xmit((u_int32 *)&xpkt,
2213 sendlen, CRYPTO_NAME, peer->hcookie,
2214 peer->assoc);
2215 else if (peer->crypto & CRYPTO_FLAG_CERT)
2216 sendlen += crypto_xmit((u_int32 *)&xpkt,
2217 sendlen, CRYPTO_CERT, peer->hcookie,
2218 peer->assoc);
2219#endif /* PUBKEY */
2220 else if (peer->pcookie.tstamp == 0)
2221 sendlen += crypto_xmit((u_int32 *)&xpkt,
2222 sendlen, CRYPTO_PRIV, peer->hcookie,
2223 peer->assoc);
2224 else if (!(peer->flags & FLAG_AUTOKEY) &&
2225 (peer->cast_flags & MDF_BCLNT))
2226 sendlen += crypto_xmit((u_int32 *)&xpkt,
2227 sendlen, CRYPTO_AUTO, peer->hcookie,
2228 peer->assoc);
2229#ifdef PUBKEY
2230 else if (peer->crypto & CRYPTO_FLAG_TAI)
2231 sendlen += crypto_xmit((u_int32 *)&xpkt,
2232 sendlen, CRYPTO_TAI, peer->hcookie,
2233 peer->assoc);
2234#endif /* PUBKEY */
2235 peer->cmmd = 0;
2236 break;
2237 }
2238
2239 /*
2240 * If extension fields are present, we must use a
2241 * private value of zero and force min poll interval.
2242 * Most intricate.
2243 */
2244 if (sendlen > LEN_PKT_NOMAC)
2245 session_key(&peer->dstadr->sin, &peer->srcadr,
2246 xkeyid, 0, 2);
2247 }
2248#endif /* AUTOKEY */
2249 xkeyid = peer->keyid;
2250 get_systime(&peer->xmt);
2251 L_ADD(&peer->xmt, &sys_authdelay);
2252 HTONL_FP(&peer->xmt, &xpkt.xmt);
2253 authlen = authencrypt(xkeyid, (u_int32 *)&xpkt, sendlen);
2254 if (authlen == 0) {
2255 msyslog(LOG_NOTICE,
2256 "transmit: no encryption key found");
2257 peer->flash |= TEST4 | TEST5;
2258 return;
2259 }
2260 sendlen += authlen;
2261#ifdef AUTOKEY
2262 if (xkeyid > NTP_MAXKEY)
2263 authtrust(xkeyid, 0);
2264#endif /* AUTOKEY */
2265 get_systime(&xmt_tx);
2266 if (sendlen > sizeof(xpkt)) {
2267 msyslog(LOG_ERR, "buffer overflow %u", sendlen);
2268 exit(-1);
2269 }
2270 sendpkt(&peer->srcadr, peer->dstadr, peer->ttl, &xpkt, sendlen);
2271
2272 /*
2273 * Calculate the encryption delay. Keep the minimum over
2274 * the latest two samples.
2275 */
2276 L_SUB(&xmt_tx, &peer->xmt);
2277 L_ADD(&xmt_tx, &sys_authdelay);
2278 sys_authdly[1] = sys_authdly[0];
2279 sys_authdly[0] = xmt_tx.l_uf;
2280 if (sys_authdly[0] < sys_authdly[1])
2281 sys_authdelay.l_uf = sys_authdly[0];
2282 else
2283 sys_authdelay.l_uf = sys_authdly[1];
2284 peer->sent++;
2285#ifdef AUTOKEY
2286#ifdef DEBUG
2287 if (debug)
2288 printf(
2289 "transmit: at %ld %s->%s mode %d keyid %08x len %d mac %d index %d\n",
2290 current_time, ntoa(&peer->dstadr->sin),
2291 ntoa(&peer->srcadr), peer->hmode, xkeyid, sendlen,
2292 authlen, peer->keynumber);
2293#endif
2294#else
2295#ifdef DEBUG
2296 if (debug)
2297 printf(
2298 "transmit: at %ld %s->%s mode %d keyid %08x len %d mac %d\n",
2299 current_time, ntoa(&peer->dstadr->sin),
2300 ntoa(&peer->srcadr), peer->hmode, xkeyid, sendlen,
2301 authlen);
2302#endif
2303#endif /* AUTOKEY */
2304}
2305
2306
2307/*
2308 * fast_xmit - Send packet for nonpersistent association. Note that
2309 * neither the source or destination can be a broadcast address.
2310 */
2311static void
2312fast_xmit(
2313 struct recvbuf *rbufp, /* receive packet pointer */
2314 int xmode, /* transmit mode */
2315 keyid_t xkeyid, /* transmit key ID */
2316 int mask /* restrict mask */
2317 )
2318{
2319 struct pkt xpkt; /* transmit packet structure */
2320 struct pkt *rpkt; /* receive packet structure */
2321 l_fp xmt_ts; /* transmit timestamp */
2322 l_fp xmt_tx; /* transmit timestamp after authent */
2323 int sendlen, authlen;
2324
2325 /*
2326 * Initialize transmit packet header fields from the receive
2327 * buffer provided. We leave some fields intact as received. If
2328 * the gazinta was from a multicast address, the gazouta must go
2329 * out another way.
2330 */
2331 rpkt = &rbufp->recv_pkt;
2332 if (rbufp->dstadr->flags & INT_MULTICAST)
2333 rbufp->dstadr = findinterface(&rbufp->recv_srcadr);
2334
2335 /*
2336 * If the caller is restricted, return a kiss-of-death packet;
2337 * otherwise, smooch politely.
2338 */
2339 if (mask & (RES_DONTSERVE | RES_LIMITED)) {
2340 if (!(mask & RES_DEMOBILIZE)) {
2341 return;
2342 } else {
2343 xpkt.li_vn_mode =
2344 PKT_LI_VN_MODE(LEAP_NOTINSYNC,
2345 PKT_VERSION(rpkt->li_vn_mode), xmode);
2346 xpkt.stratum = STRATUM_UNSPEC;
2347 memcpy(&xpkt.refid, "DENY", 4);
2348 }
2349 } else {
2350 xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap,
2351 PKT_VERSION(rpkt->li_vn_mode), xmode);
2352 xpkt.stratum = STRATUM_TO_PKT(sys_stratum);
2353 xpkt.refid = sys_refid;
2354 }
2355 xpkt.ppoll = rpkt->ppoll;
2356 xpkt.precision = sys_precision;
2357 xpkt.rootdelay = HTONS_FP(DTOFP(sys_rootdelay));
2358 xpkt.rootdispersion =
2359 HTONS_FP(DTOUFP(sys_rootdispersion));
2360 HTONL_FP(&sys_reftime, &xpkt.reftime);
2361 xpkt.org = rpkt->xmt;
2362 HTONL_FP(&rbufp->recv_time, &xpkt.rec);
2363
2364 /*
2365 * If the received packet contains a MAC, the transmitted packet
2366 * is authenticated and contains a MAC. If not, the transmitted
2367 * packet is not authenticated.
2368 */
2369 sendlen = LEN_PKT_NOMAC;
2370 if (rbufp->recv_length == sendlen) {
2371 get_systime(&xmt_ts);
2372 HTONL_FP(&xmt_ts, &xpkt.xmt);
2373 sendpkt(&rbufp->recv_srcadr, rbufp->dstadr, 0, &xpkt,
2374 sendlen);
2375#ifdef DEBUG
2376 if (debug)
2377 printf("transmit: at %ld %s->%s mode %d\n",
2378 current_time, ntoa(&rbufp->dstadr->sin),
2379 ntoa(&rbufp->recv_srcadr), xmode);
2380#endif
2381 return;
2382 }
2383
2384 /*
2385 * The received packet contains a MAC, so the transmitted packet
2386 * must be authenticated. For private-key cryptography, use the
2387 * predefined private keys to generate the cryptosum. For
2388 * autokey cryptography, use the server private value to
2389 * generate the cookie, which is unique for every source-
2390 * destination-key ID combination.
2391 */
2392#ifdef AUTOKEY
2393 if (xkeyid > NTP_MAXKEY) {
2394 keyid_t cookie;
2395 u_int code, associd;
2396
2397 /*
2398 * The only way to get here is a reply to a legitimate
2399 * client request message, so the mode must be
2400 * MODE_SERVER. If an extension field is present, there
2401 * can be only one and that must be a command. Do what
2402 * needs, but with private value of zero so the poor
2403 * jerk can decode it. If no extension field is present,
2404 * use the cookie to generate the session key.
2405 */
2406 code = (htonl(rpkt->exten[0]) >> 16) | CRYPTO_RESP;
2407 cookie = session_key(&rbufp->recv_srcadr,
2408 &rbufp->dstadr->sin, 0, sys_private, 0);
2409 associd = htonl(rpkt->exten[1]);
2410 if (rbufp->recv_length >= sendlen + MAX_MAC_LEN + 2 *
2411 sizeof(u_int32)) {
2412 session_key(&rbufp->dstadr->sin,
2413 &rbufp->recv_srcadr, xkeyid, 0, 2);
2414 sendlen += crypto_xmit((u_int32 *)&xpkt,
2415 sendlen, code, cookie, associd);
2416 } else {
2417 session_key(&rbufp->dstadr->sin,
2418 &rbufp->recv_srcadr, xkeyid, cookie, 2);
2419 }
2420 }
2421#endif /* AUTOKEY */
2422 get_systime(&xmt_ts);
2423 L_ADD(&xmt_ts, &sys_authdelay);
2424 HTONL_FP(&xmt_ts, &xpkt.xmt);
2425 authlen = authencrypt(xkeyid, (u_int32 *)&xpkt, sendlen);
2426 sendlen += authlen;
2427#ifdef AUTOKEY
2428 if (xkeyid > NTP_MAXKEY)
2429 authtrust(xkeyid, 0);
2430#endif /* AUTOKEY */
2431 get_systime(&xmt_tx);
2432 if (sendlen > sizeof(xpkt)) {
2433 msyslog(LOG_ERR, "buffer overflow %u", sendlen);
2434 exit(-1);
2435 }
2436 sendpkt(&rbufp->recv_srcadr, rbufp->dstadr, 0, &xpkt, sendlen);
2437
2438 /*
2439 * Calculate the encryption delay. Keep the minimum over the
2440 * latest two samples.
2441 */
2442 L_SUB(&xmt_tx, &xmt_ts);
2443 L_ADD(&xmt_tx, &sys_authdelay);
2444 sys_authdly[1] = sys_authdly[0];
2445 sys_authdly[0] = xmt_tx.l_uf;
2446 if (sys_authdly[0] < sys_authdly[1])
2447 sys_authdelay.l_uf = sys_authdly[0];
2448 else
2449 sys_authdelay.l_uf = sys_authdly[1];
2450#ifdef DEBUG
2451 if (debug)
2452 printf(
2453 "transmit: at %ld %s->%s mode %d keyid %08x len %d mac %d\n",
2454 current_time, ntoa(&rbufp->dstadr->sin),
2455 ntoa(&rbufp->recv_srcadr), xmode, xkeyid, sendlen,
2456 authlen);
2457#endif
2458}
2459
2460
2461#ifdef AUTOKEY
2462/*
2463 * key_expire - purge the key list
2464 */
2465void
2466key_expire(
2467 struct peer *peer /* peer structure pointer */
2468 )
2469{
2470 int i;
2471
2472 if (peer->keylist != NULL) {
2473 for (i = 0; i <= peer->keynumber; i++)
2474 authtrust(peer->keylist[i], 0);
2475 free(peer->keylist);
2476 peer->keylist = NULL;
2477 }
2478 peer->keynumber = peer->sndauto.seq = 0;
2479#ifdef DEBUG
2480 if (debug)
2481 printf("key_expire: at %lu\n", current_time);
2482#endif
2483}
2484#endif /* AUTOKEY */
2485
2486/*
2487 * Find the precision of this particular machine
2488 */
2489#define DUSECS 1000000 /* us in a s */
2490#define HUSECS (1 << 20) /* approx DUSECS for shifting etc */
2491#define MINSTEP 5 /* minimum clock increment (us) */
2492#define MAXSTEP 20000 /* maximum clock increment (us) */
--- 103 unchanged lines hidden (view full) ---
2596
2597 /*
2598 * Fill in the sys_* stuff. Default is don't listen to
2599 * broadcasting, authenticate.
2600 */
2601 sys_leap = LEAP_NOTINSYNC;
2602 sys_stratum = STRATUM_UNSPEC;
2603 sys_precision = (s_char)default_get_precision();
2604 sys_jitter = LOGTOD(sys_precision);
2605 sys_rootdelay = 0;
2606 sys_rootdispersion = 0;
2607 sys_refid = 0;
2608 L_CLR(&sys_reftime);
2609 sys_peer = NULL;
2610 sys_survivors = 0;
2611 get_systime(&dummy);
2612 sys_bclient = 0;
2613 sys_bdelay = DEFBROADDELAY;
2614 sys_authenticate = 1;
2615 L_CLR(&sys_authdelay);
2616 sys_authdly[0] = sys_authdly[1] = 0;
2617 sys_stattime = 0;
2618 sys_badstratum = 0;
2619 sys_oldversionpkt = 0;
2620 sys_newversionpkt = 0;
2621 sys_badlength = 0;
2622 sys_unknownversion = 0;
2623 sys_processed = 0;
2624 sys_badauth = 0;
2625 sys_manycastserver = 0;
2626#ifdef AUTOKEY
2627 sys_automax = 1 << NTP_AUTOMAX;
2628#endif /* AUTOKEY */
2629
2630 /*
2631 * Default these to enable
2632 */
2633 ntp_enable = 1;
2634#ifndef KERNEL_FLL_BUG
2635 kern_enable = 1;
2636#endif
2637 pps_enable = 0;
2638 stats_control = 1;
2639
2640 /*
2641 * Some system clocks should only be adjusted in 10ms
2642 * increments.
2643 */
2644#if defined RELIANTUNIX_CLOCK
2645 systime_10ms_ticks = 1; /* Reliant UNIX */
2646#elif defined SCO5_CLOCK
2647 if (sys_precision >= (s_char)-10) /* pre-SCO OpenServer 5.0.6 */
2648 systime_10ms_ticks = 1;
2649#endif
2650 if (systime_10ms_ticks)
--- 89 unchanged lines hidden (view full) ---
2740 case PROTO_AUTHENTICATE:
2741
2742 /*
2743 * Specify the use of authenticated data
2744 */
2745 sys_authenticate = (int)value;
2746 break;
2747
2748 case PROTO_PPS:
2749
2750 /*
2751 * Turn on/off PPS discipline
2752 */
2753 pps_enable = (int)value;
2754 break;
2755
2756#ifdef REFCLOCK
2757 case PROTO_CAL:
2758
2759 /*
2760 * Turn on/off refclock calibrate
2761 */
2762 cal_enable = (int)value;
2763 break;
2764#endif
2765
2766 default:
2767
2768 /*
2769 * Log this error
2770 */
2771 msyslog(LOG_ERR,
2772 "proto_config: illegal item %d, value %ld",
2773 item, value);
--- 21 unchanged lines hidden ---
2 * ntp_proto.c - NTP version 4 protocol machinery
3 *
4 * $FreeBSD: head/contrib/ntp/ntpd/ntp_proto.c 82505 2001-08-29 15:15:59Z roberto $
5 */
6#ifdef HAVE_CONFIG_H
7#include <config.h>
8#endif
9
10#include "ntpd.h"
11#include "ntp_stdlib.h"
12#include "ntp_unixtime.h"
13#include "ntp_control.h"
14#include "ntp_string.h"
15#include "ntp_crypto.h"
16
17#include <stdio.h>
18
19#if defined(VMS) && defined(VMS_LOCALUNIT) /*wjm*/
20#include "ntp_refclock.h"
21#endif
22
23#if defined(__FreeBSD__) && __FreeBSD__ >= 3
24#include <sys/sysctl.h>
25#endif
26
27/*
28 * System variables are declared here. See Section 3.2 of the
29 * specification.
30 */
31u_char sys_leap; /* system leap indicator */
32u_char sys_stratum; /* stratum of system */
33s_char sys_precision; /* local clock precision */
34double sys_rootdelay; /* roundtrip delay to primary source */
35double sys_rootdispersion; /* dispersion to primary source */
36u_int32 sys_refid; /* reference source for local clock */
37static double sys_offset; /* current local clock offset */
38l_fp sys_reftime; /* time we were last updated */
39struct peer *sys_peer; /* our current peer */
40struct peer *sys_prefer; /* our cherished peer */
41#ifdef AUTOKEY
42u_long sys_automax; /* maximum session key lifetime */
43#endif /* AUTOKEY */
44
45/*
46 * Nonspecified system state variables.
47 */
48int sys_bclient; /* we set our time to broadcasts */
49double sys_bdelay; /* broadcast client default delay */
50int sys_authenticate; /* requre authentication for config */
51l_fp sys_authdelay; /* authentication delay */
52static u_long sys_authdly[2]; /* authentication delay shift reg */
53static u_char leap_consensus; /* consensus of survivor leap bits */
54static double sys_selerr; /* select error (squares) */
55static double sys_syserr; /* system error (squares) */
56keyid_t sys_private; /* private value for session seed */
57int sys_manycastserver; /* respond to manycast client pkts */
58u_int sys_survivors; /* truest of the truechimers */
59int peer_ntpdate; /* active peers in ntpdate mode */
60#ifdef AUTOKEY
61char *sys_hostname; /* gethostname() name */
62#endif /* AUTOKEY */
63
64/*
65 * Statistics counters
66 */
67u_long sys_stattime; /* time when we started recording */
68u_long sys_badstratum; /* packets with invalid stratum */
69u_long sys_oldversionpkt; /* old version packets received */
70u_long sys_newversionpkt; /* new version packets received */
71u_long sys_unknownversion; /* don't know version packets */
72u_long sys_badlength; /* packets with bad length */
73u_long sys_processed; /* packets processed */
74u_long sys_badauth; /* packets dropped because of auth */
75u_long sys_limitrejected; /* pkts rejected due to client count per net */
76
77static double root_distance P((struct peer *));
78static double clock_combine P((struct peer **, int));
79static void peer_xmit P((struct peer *));
80static void fast_xmit P((struct recvbuf *, int, keyid_t, int));
81static void clock_update P((void));
82int default_get_precision P((void));
83
84
85/*
86 * transmit - Transmit Procedure. See Section 3.4.2 of the
87 * specification.
88 */
89void
90transmit(
91 struct peer *peer /* peer structure pointer */
92 )
93{
94 int hpoll;
95
96 hpoll = peer->hpoll;
97 if (peer->burst == 0) {
98 u_char oreach;
99
100 /*
101 * The polling state machine. There are two kinds of
102 * machines, those that never expect a reply (broadcast
103 * and manycast server modes) and those that do (all
104 * other modes). The dance is intricate...
105 */
106 if (peer->cast_flags & (MDF_BCAST | MDF_MCAST)) {
107
108 /*
109 * In broadcast mode the poll interval is fixed
110 * at minpoll and the ttl at ttlmax.
111 */
112 hpoll = peer->minpoll;
113 peer->ttl = peer->ttlmax;
114#ifdef AUTOKEY
115 } else if (peer->cast_flags & MDF_ACAST) {
116
117 /*
118 * In manycast mode we start with the minpoll
119 * interval and ttl. However, the actual poll
120 * interval is eight times the nominal poll
121 * interval shown here. If fewer than three
122 * servers are found, the ttl is increased by
123 * one and we try again. If this continues to
124 * the max ttl, the poll interval is bumped by
125 * one and we try again. If at least three
126 * servers are found, the poll interval
127 * increases with the system poll interval to
128 * the max and we continue indefinately.
129 * However, about once per day when the
130 * agreement parameters are refreshed, the
131 * manycast clients are reset and we start from
132 * the beginning. This is to catch and clamp the
133 * ttl to the lowest practical value and avoid
134 * knocking on spurious doors.
135 */
136 if (sys_survivors < NTP_MINCLOCK && peer->ttl <
137 peer->ttlmax)
138 peer->ttl++;
139 hpoll = sys_poll;
140#endif /* AUTOKEY */
141 } else {
142
143 /*
144 * For associations expecting a reply, the
145 * watchdog counter is bumped by one if the peer
146 * has not been heard since the previous poll.
147 * If the counter reaches the max, the peer is
148 * demobilized if not configured and just
149 * cleared if it is, but in this case the poll
150 * interval is bumped by one.
151 */
152 if (peer->unreach < NTP_UNREACH) {
153 peer->unreach++;
154 } else if (!(peer->flags & FLAG_CONFIG)) {
155 unpeer(peer);
156 clock_select();
157 return;
158
159 } else {
160 peer_clear(peer);
161 hpoll++;
162 }
163 }
164 oreach = peer->reach;
165 peer->reach <<= 1;
166 if (peer->reach == 0) {
167
168 /*
169 * If this association has become unreachable,
170 * clear it and raise a trap.
171 */
172 if (oreach != 0) {
173 report_event(EVNT_UNREACH, peer);
174 peer->timereachable = current_time;
175 if (!(peer->flags & FLAG_CONFIG)) {
176 unpeer(peer);
177 clock_select();
178 return;
179 } else {
180 peer_clear(peer);
181 hpoll = peer->minpoll;
182 }
183 }
184 if (peer->flags & FLAG_IBURST)
185 peer->burst = NTP_SHIFT;
186 } else {
187
188 /*
189 * Here the peer is reachable. If it has not
190 * been heard for three consecutive polls, stuff
191 * the clock filter. Next, determine the poll
192 * interval. If the peer is a synchronization
193 * candidate, use the system poll interval. If
194 * the peer is not sane, increase it by one. If
195 * the number of valid updates is not greater
196 * than half the register size, clamp it to the
197 * minimum. This is to quickly recover the time
198 * variables when a noisy peer shows life.
199 */
200 if (!(peer->reach & 0x07)) {
201 clock_filter(peer, 0., 0., MAXDISPERSE);
202 clock_select();
203 }
204 if ((peer->stratum > 1 && peer->refid ==
205 peer->dstadr->sin.sin_addr.s_addr) ||
206 peer->stratum >= STRATUM_UNSPEC)
207 hpoll++;
208 else
209 hpoll = sys_poll;
210 if (peer->flags & FLAG_BURST)
211 peer->burst = NTP_SHIFT;
212 }
213 } else {
214 peer->burst--;
215 if (peer->burst == 0) {
216
217 /*
218 * If a broadcast client at this point, the
219 * burst has concluded, so we switch to client
220 * mode and purge the keylist, since no further
221 * transmissions will be made.
222 */
223 if (peer->cast_flags & MDF_BCLNT) {
224 peer->hmode = MODE_BCLIENT;
225#ifdef AUTOKEY
226 key_expire(peer);
227#endif /* AUTOKEY */
228 }
229 poll_update(peer, hpoll);
230 clock_select();
231
232 /*
233 * If ntpdate mode and the clock has not been
234 * set and all peers have completed the burst,
235 * we declare a successful failure.
236 */
237 if (mode_ntpdate) {
238 peer_ntpdate--;
239 if (peer_ntpdate > 0)
240 return;
241 NLOG(NLOG_SYNCEVENT | NLOG_SYSEVENT)
242 msyslog(LOG_NOTICE,
243 "no reply; clock not set");
244 printf(
245 "ntpd: no reply; clock not set\n");
246 exit(0);
247 }
248 return;
249
250 }
251 }
252 peer->outdate = current_time;
253 poll_update(peer, hpoll);
254
255 /*
256 * We need to be very careful about honking uncivilized time.
257 * Never transmit if in broadcast client mode or access denied.
258 * If in broadcast mode, transmit only if synchronized to a
259 * valid source.
260 */
261 if (peer->hmode == MODE_BCLIENT || peer->flash & TEST4) {
262 return;
263 } else if (peer->hmode == MODE_BROADCAST) {
264 if (sys_peer == NULL)
265 return;
266 }
267 peer_xmit(peer);
268}
269
270/*
271 * receive - Receive Procedure. See section 3.4.3 in the specification.
272 */
273void
274receive(
275 struct recvbuf *rbufp
276 )
277{
278 register struct peer *peer;
279 register struct pkt *pkt;
280 int hismode;
281 int oflags;
282 int restrict_mask;
283 int has_mac; /* length of MAC field */
284 int authlen; /* offset of MAC field */
285 int is_authentic; /* cryptosum ok */
286 keyid_t skeyid; /* cryptographic keys */
287 struct sockaddr_in *dstadr_sin; /* active runway */
288#ifdef AUTOKEY
289 keyid_t pkeyid, tkeyid; /* cryptographic keys */
290#endif /* AUTOKEY */
291 struct peer *peer2;
292 int retcode = AM_NOMATCH;
293
294 /*
295 * Monitor the packet and get restrictions. Note that the packet
296 * length for control and private mode packets must be checked
297 * by the service routines. Note that no statistics counters are
298 * recorded for restrict violations, since these counters are in
299 * the restriction routine. Note the careful distinctions here
300 * between a packet with a format error and a packet that is
301 * simply discarded without prejudice. Some restrictions have to
302 * be handled later in order to generate a kiss-of-death packet.
303 */
304 ntp_monitor(rbufp);
305 restrict_mask = restrictions(&rbufp->recv_srcadr);
306#ifdef DEBUG
307 if (debug > 2)
308 printf("receive: at %ld %s<-%s restrict %02x\n",
309 current_time, ntoa(&rbufp->dstadr->sin),
310 ntoa(&rbufp->recv_srcadr), restrict_mask);
311#endif
312 if (restrict_mask & RES_IGNORE)
313 return; /* no anything */
314 if (!(SRCPORT(&rbufp->recv_srcadr) == NTP_PORT ||
315 SRCPORT(&rbufp->recv_srcadr) >= IPPORT_RESERVED)) {
316 sys_badlength++;
317 return; /* invalid port */
318 }
319 pkt = &rbufp->recv_pkt;
320 if (PKT_VERSION(pkt->li_vn_mode) == NTP_VERSION) {
321 sys_newversionpkt++; /* new version */
322 } else if (!(restrict_mask & RES_VERSION) &&
323 PKT_VERSION(pkt->li_vn_mode) >= NTP_OLDVERSION) {
324 sys_oldversionpkt++; /* old version */
325 } else {
326 sys_unknownversion++;
327 return; /* invalid version */
328 }
329 if (PKT_MODE(pkt->li_vn_mode) == MODE_PRIVATE) {
330 if (restrict_mask & RES_NOQUERY)
331 return; /* no query private */
332 process_private(rbufp, ((restrict_mask &
333 RES_NOMODIFY) == 0));
334 return;
335 }
336 if (PKT_MODE(pkt->li_vn_mode) == MODE_CONTROL) {
337 if (restrict_mask & RES_NOQUERY)
338 return; /* no query control */
339 process_control(rbufp, restrict_mask);
340 return;
341 }
342 if (rbufp->recv_length < LEN_PKT_NOMAC) {
343 sys_badlength++;
344 return; /* runt packet */
345 }
346
347 /*
348 * Validate mode. Note that NTPv1 is no longer supported.
349 */
350 hismode = (int)PKT_MODE(pkt->li_vn_mode);
351 if (hismode == MODE_UNSPEC) {
352 sys_badlength++;
353 return; /* invalid mode */
354 }
355
356 /*
357 * Discard broadcast packets received on the wildcard interface
358 * or if not enabled as broadcast client.
359 */
360 if (PKT_MODE(pkt->li_vn_mode) == MODE_BROADCAST &&
361 (rbufp->dstadr == any_interface || !sys_bclient))
362 return;
363
364 /*
365 * Parse the extension field if present. We figure out whether
366 * an extension field is present by measuring the MAC size. If
367 * the number of words following the packet header is 0 or 1, no
368 * MAC is present and the packet is not authenticated. If 1, the
369 * packet is a reply to a previous request that failed to
370 * authenticate. If 3, the packet is authenticated with DES; if
371 * 5, the packet is authenticated with MD5. If greater than 5,
372 * an extension field is present. If 2 or 4, the packet is a
373 * runt and goes poof! with a brilliant flash.
374 */
375 skeyid = 0;
376#ifdef AUTOKEY
377 pkeyid = tkeyid = 0;
378#endif /* AUTOKEY */
379 authlen = LEN_PKT_NOMAC;
380 while ((has_mac = rbufp->recv_length - authlen) > 0) {
381 int temp;
382
383 if (has_mac % 4 != 0 || has_mac < 0) {
384 sys_badlength++;
385 return;
386 }
387 if (has_mac == 1 * 4 || has_mac == 3 * 4 || has_mac ==
388 MAX_MAC_LEN) {
389 skeyid = ntohl(((u_int32 *)pkt)[authlen / 4]);
390 break;
391
392 } else if (has_mac > MAX_MAC_LEN) {
393 temp = ntohl(((u_int32 *)pkt)[authlen / 4]) &
394 0xffff;
395 if (temp < 4 || temp % 4 != 0) {
396 sys_badlength++;
397 return;
398 }
399 authlen += temp;
400 } else {
401 sys_badlength++;
402 return;
403 }
404 }
405
406 /*
407 * We have tossed out as many buggy packets as possible early in
408 * the game to reduce the exposure to a clogging attack. Now we
409 * have to burn some cycles to find the association and
410 * authenticate the packet if required. Note that we burn only
411 * MD5 or DES cycles, again to reduce exposure. There may be no
412 * matching association and that's okay.
413 *
414 * More on the autokey mambo. Normally the local interface is
415 * found when the association was mobilized with respect to a
416 * designated remote address. We assume packets arriving from
417 * the remote address arrive via this interface and the local
418 * address used to construct the autokey is the unicast address
419 * of the interface. However, if the sender is a broadcaster,
420 * the interface broadcast address is used instead.
421 * Notwithstanding this technobabble, if the sender is a
422 * multicaster, the broadcast address is null, so we use the
423 * unicast address anyway. Don't ask.
424 */
425 peer = findpeer(&rbufp->recv_srcadr, rbufp->dstadr, rbufp->fd,
426 hismode, &retcode);
427 is_authentic = 0;
428 dstadr_sin = &rbufp->dstadr->sin;
429 if (has_mac == 0) {
430#ifdef DEBUG
431 if (debug)
432 printf("receive: at %ld %s<-%s mode %d code %d\n",
433 current_time, ntoa(&rbufp->dstadr->sin),
434 ntoa(&rbufp->recv_srcadr), hismode, retcode);
435#endif
436 } else {
437#ifdef AUTOKEY
438 /*
439 * For autokey modes, generate the session key
440 * and install in the key cache. Use the socket
441 * broadcast or unicast address as appropriate.
442 */
443 if (skeyid > NTP_MAXKEY) {
444
445 /*
446 * More on the autokey dance (AKD). A cookie is
447 * constructed from public and private values.
448 * For broadcast packets, the cookie is public
449 * (zero). For packets that match no
450 * association, the cookie is hashed from the
451 * addresses and private value. For server
452 * packets, the cookie was previously obtained
453 * from the server. For symmetric modes, the
454 * cookie was previously constructed using an
455 * agreement protocol; however, should PKI be
456 * unavailable, we construct a fake agreement as
457 * the EXOR of the peer and host cookies.
458 *
459 * hismode ephemeral persistent
460 * =======================================
461 * active 0 cookie#
462 * passive 0% cookie#
463 * client sys cookie 0%
464 * server 0% sys cookie
465 * broadcast 0 0
466 *
467 * # if unsync, 0
468 * % can't happen
469 */
470 if (hismode == MODE_BROADCAST) {
471
472 /*
473 * For broadcaster, use the interface
474 * broadcast address when available;
475 * otherwise, use the unicast address
476 * found when the association was
477 * mobilized.
478 */
479 pkeyid = 0;
480 if (rbufp->dstadr->bcast.sin_addr.s_addr
481 != 0)
482 dstadr_sin =
483 &rbufp->dstadr->bcast;
484 } else if (peer == NULL) {
485 pkeyid = session_key(
486 &rbufp->recv_srcadr, dstadr_sin, 0,
487 sys_private, 0);
488 } else {
489 pkeyid = peer->pcookie.key;
490 }
491
492 /*
493 * The session key includes both the public
494 * values and cookie. In case of an extension
495 * field, the cookie used for authentication
496 * purposes is zero. Note the hash is saved for
497 * use later in the autokey mambo.
498 */
499 if (authlen > LEN_PKT_NOMAC && pkeyid != 0) {
500 session_key(&rbufp->recv_srcadr,
501 dstadr_sin, skeyid, 0, 2);
502 tkeyid = session_key(
503 &rbufp->recv_srcadr, dstadr_sin,
504 skeyid, pkeyid, 0);
505 } else {
506 tkeyid = session_key(
507 &rbufp->recv_srcadr, dstadr_sin,
508 skeyid, pkeyid, 2);
509 }
510
511 }
512#endif /* AUTOKEY */
513
514 /*
515 * Compute the cryptosum. Note a clogging attack may
516 * succeed in bloating the key cache. If an autokey,
517 * purge it immediately, since we won't be needing it
518 * again.
519 */
520 if (authdecrypt(skeyid, (u_int32 *)pkt, authlen,
521 has_mac))
522 is_authentic = 1;
523 else
524 sys_badauth++;
525#ifdef AUTOKEY
526 if (skeyid > NTP_MAXKEY)
527 authtrust(skeyid, 0);
528#endif /* AUTOKEY */
529#ifdef DEBUG
530 if (debug)
531 printf(
532 "receive: at %ld %s<-%s mode %d code %d keyid %08x len %d mac %d auth %d\n",
533 current_time, ntoa(dstadr_sin),
534 ntoa(&rbufp->recv_srcadr), hismode, retcode,
535 skeyid, authlen, has_mac,
536 is_authentic);
537#endif
538 }
539
540 /*
541 * The association matching rules are implemented by a set of
542 * routines and a table in ntp_peer.c. A packet matching an
543 * association is processed by that association. If not and
544 * certain conditions prevail, then an ephemeral association is
545 * mobilized: a broadcast packet mobilizes a broadcast client
546 * aassociation; a server packet mobilizes a client association;
547 * a symmetric active packet mobilizes a symmetric passive
548 * association. And, the adventure continues...
549 */
550 switch (retcode) {
551 case AM_FXMIT:
552
553 /*
554 * This is a client mode packet not matching a known
555 * association. If from a manycast client we run a few
556 * sanity checks before deciding to send a unicast
557 * server response. Otherwise, it must be a client
558 * request, so send a server response and go home.
559 */
560 if (sys_manycastserver && (rbufp->dstadr->flags &
561 INT_MULTICAST)) {
562
563 /*
564 * We are picky about responding to a
565 * manycaster. There is no reason to respond to
566 * a request if our time is worse than the
567 * manycaster. We certainly don't reply if not
568 * synchronized to proventic time.
569 */
570 if (sys_peer == NULL)
571 return;
572
573 /*
574 * We don't reply if the our stratum is greater
575 * than the manycaster.
576 */
577 if (PKT_TO_STRATUM(pkt->stratum) < sys_stratum)
578 return;
579 }
580
581 /*
582 * Note that we don't require an authentication check
583 * here, since we can't set the system clock; but, we do
584 * set the key ID to zero to tell the caller about this.
585 */
586 if (is_authentic)
587 fast_xmit(rbufp, MODE_SERVER, skeyid,
588 restrict_mask);
589 else
590 fast_xmit(rbufp, MODE_SERVER, 0, restrict_mask);
591 return;
592
593 case AM_MANYCAST:
594
595 /*
596 * This is a server mode packet returned in response to
597 * a client mode packet sent to a multicast group
598 * address. The originate timestamp is a good nonce to
599 * reliably associate the reply with what was sent. If
600 * there is no match, that's curious and could be an
601 * intruder attempting to clog, so we just ignore it.
602 *
603 * First, make sure the packet is authentic. If so and
604 * the manycast association is found, we mobilize a
605 * client mode association, copy pertinent variables
606 * from the manycast to the client mode association and
607 * wind up the spring.
608 *
609 * There is an implosion hazard at the manycast client,
610 * since the manycast servers send the server packet
611 * immediately.
612 */
613 if ((restrict_mask & (RES_DONTSERVE | RES_LIMITED |
614 RES_NOPEER)) || (sys_authenticate &&
615 !is_authentic))
616 return;
617
618 peer2 = findmanycastpeer(rbufp);
619 if (peer2 == 0)
620 return;
621
622 peer = newpeer(&rbufp->recv_srcadr, rbufp->dstadr,
623 MODE_CLIENT, PKT_VERSION(pkt->li_vn_mode),
624 sys_minpoll, NTP_MAXDPOLL, FLAG_IBURST |
625 (peer2->flags & (FLAG_AUTHENABLE | FLAG_SKEY)),
626 MDF_UCAST, 0, skeyid);
627 if (peer == NULL)
628 return;
629 break;
630
631 case AM_NEWPASS:
632
633 /*
634 * This is the first packet received from a symmetric
635 * active peer. First, make sure the packet is
636 * authentic. If so, mobilize a symmetric passive
637 * association.
638 */
639 if ((restrict_mask & (RES_DONTSERVE | RES_LIMITED |
640 RES_NOPEER)) || (sys_authenticate &&
641 !is_authentic)) {
642 fast_xmit(rbufp, MODE_PASSIVE, 0,
643 restrict_mask);
644 return;
645 }
646 peer = newpeer(&rbufp->recv_srcadr, rbufp->dstadr,
647 MODE_PASSIVE, PKT_VERSION(pkt->li_vn_mode),
648 sys_minpoll, NTP_MAXDPOLL, sys_authenticate ?
649 FLAG_AUTHENABLE : 0, MDF_UCAST, 0, skeyid);
650 if (peer == NULL)
651 return;
652 break;
653
654 case AM_NEWBCL:
655
656 /*
657 * This is the first packet received from a broadcast
658 * server. First, make sure the packet is authentic, not
659 * restricted and that we are a broadcast or multicast
660 * client. If so, mobilize a broadcast client
661 * association.
662 */
663 if ((restrict_mask & (RES_DONTSERVE | RES_LIMITED |
664 RES_NOPEER)) || (sys_authenticate &&
665 !is_authentic) || !sys_bclient)
666 return;
667
668 peer = newpeer(&rbufp->recv_srcadr, rbufp->dstadr,
669 MODE_CLIENT, PKT_VERSION(pkt->li_vn_mode),
670 sys_minpoll, NTP_MAXDPOLL, FLAG_MCAST |
671 FLAG_IBURST | (sys_authenticate ?
672 FLAG_AUTHENABLE : 0), MDF_BCLNT, 0, skeyid);
673#ifdef AUTOKEY
674#ifdef PUBKEY
675 if (peer == NULL)
676 return;
677 if (peer->flags & FLAG_SKEY)
678 crypto_recv(peer, rbufp);
679#endif /* PUBKEY */
680#endif /* AUTOKEY */
681 return;
682
683 case AM_POSSBCL:
684 case AM_PROCPKT:
685
686 /*
687 * Happiness and nothing broke. Earn some revenue.
688 */
689 break;
690
691 default:
692
693 /*
694 * Invalid mode combination. Leave the island
695 * immediately.
696 */
697#ifdef DEBUG
698 if (debug)
699 printf("receive: bad protocol %d\n", retcode);
700#endif
701 return;
702 }
703
704 /*
705 * If the peer isn't configured, set his authenable and autokey
706 * status based on the packet. Once the status is set, it can't
707 * be unset. It seems like a silly idea to do this here, rather
708 * in the configuration routine, but in some goofy cases the
709 * first packet sent cannot be authenticated and we need a way
710 * for the dude to change his mind.
711 */
712 oflags = peer->flags;
713 peer->timereceived = current_time;
714 peer->received++;
715 if (!(peer->flags & FLAG_CONFIG) && has_mac) {
716 peer->flags |= FLAG_AUTHENABLE;
717#ifdef AUTOKEY
718 if (skeyid > NTP_MAXKEY)
719 peer->flags |= FLAG_SKEY;
720#endif /* AUTOKEY */
721 }
722
723 /*
724 * A valid packet must be from an authentic and allowed source.
725 * All packets must pass the authentication allowed tests.
726 * Autokey authenticated packets must pass additional tests and
727 * public-key authenticated packets must have the credentials
728 * verified. If all tests are passed, the packet is forwarded
729 * for processing. If not, the packet is discarded and the
730 * association demobilized if appropriate.
731 */
732 peer->flash = 0;
733 if (is_authentic) {
734 peer->flags |= FLAG_AUTHENTIC;
735 } else {
736 peer->flags &= ~FLAG_AUTHENTIC;
737 }
738 if (peer->hmode == MODE_BROADCAST &&
739 (restrict_mask & RES_DONTTRUST)) /* test 4 */
740 peer->flash |= TEST4; /* access denied */
741 if (peer->flags & FLAG_AUTHENABLE) {
742 if (!(peer->flags & FLAG_AUTHENTIC)) /* test 5 */
743 peer->flash |= TEST5; /* auth failed */
744 else if (!(oflags & FLAG_AUTHENABLE))
745 report_event(EVNT_PEERAUTH, peer);
746 }
747 if (peer->flash) {
748#ifdef DEBUG
749 if (debug)
750 printf("receive: bad auth %03x\n", peer->flash);
751#endif
752 return;
753 }
754
755#ifdef AUTOKEY
756 /*
757 * More autokey dance. The rules of the cha-cha are as follows:
758 *
759 * 1. If there is no key or the key is not auto, do nothing.
760 *
761 * 2. If an extension field contains a verified signature, it is
762 * self-authenticated and we sit the dance.
763 *
764 * 3. If this is a server reply, check only to see that the
765 * transmitted key ID matches the received key ID.
766 *
767 * 4. Check to see that one or more hashes of the current key ID
768 * matches the previous key ID or ultimate original key ID
769 * obtained from the broadcaster or symmetric peer. If no
770 * match, sit the dance and wait for timeout.
771 */
772 if (peer->flags & FLAG_SKEY) {
773 peer->flash |= TEST10;
774 crypto_recv(peer, rbufp);
775 poll_update(peer, peer->hpoll);
776 if (hismode == MODE_SERVER) {
777 if (skeyid == peer->keyid)
778 peer->flash &= ~TEST10;
779 } else if (!peer->flash & TEST10) {
780 peer->pkeyid = skeyid;
781 } else {
782 int i;
783
784 for (i = 0; ; i++) {
785 if (tkeyid == peer->pkeyid ||
786 tkeyid == peer->recauto.key) {
787 peer->flash &= ~TEST10;
788 peer->pkeyid = skeyid;
789 break;
790 }
791 if (i > peer->recauto.seq)
792 break;
793 tkeyid = session_key(
794 &rbufp->recv_srcadr, dstadr_sin,
795 tkeyid, pkeyid, 0);
796 }
797 }
798#ifdef PUBKEY
799
800 /*
801 * This is delicious. Ordinarily, we kick out all errors
802 * at this point; however, in symmetric mode and just
803 * warming up, an unsynchronized peer must inject the
804 * timestamps, even if it fails further up the road. So,
805 * let the dude by here, but only if the jerk is not yet
806 * reachable. After that, he's on his own.
807 */
808 if (!(peer->flags & FLAG_PROVEN))
809 peer->flash |= TEST11;
810 if (peer->flash && peer->reach) {
811#ifdef DEBUG
812 if (debug)
813 printf("packet: bad autokey %03x\n",
814 peer->flash);
815#endif
816 return;
817 }
818#endif /* PUBKEY */
819 }
820#endif /* AUTOKEY */
821
822 /*
823 * We have survived the gaunt. Forward to the packet routine. If
824 * a symmetric passive association has been mobilized and the
825 * association doesn't deserve to live, it will die in the
826 * transmit routine if not reachable after timeout.
827 */
828 process_packet(peer, pkt, &rbufp->recv_time);
829}
830
831
832/*
833 * process_packet - Packet Procedure, a la Section 3.4.4 of the
834 * specification. Or almost, at least. If we're in here we have a
835 * reasonable expectation that we will be having a long term
836 * relationship with this host.
837 */
838void
839process_packet(
840 register struct peer *peer,
841 register struct pkt *pkt,
842 l_fp *recv_ts
843 )
844{
845 l_fp t10, t23;
846 double p_offset, p_del, p_disp;
847 double dtemp;
848 l_fp p_rec, p_xmt, p_org, p_reftime;
849 l_fp ci;
850 int pmode, pleap, pstratum;
851
852 /*
853 * Swap header fields and keep the books. The books amount to
854 * the receive timestamp and poll interval in the header. We
855 * need these even if there are other problems in order to crank
856 * up the state machine.
857 */
858 sys_processed++;
859 peer->processed++;
860 p_del = FPTOD(NTOHS_FP(pkt->rootdelay));
861 p_disp = FPTOD(NTOHS_FP(pkt->rootdispersion));
862 NTOHL_FP(&pkt->reftime, &p_reftime);
863 NTOHL_FP(&pkt->rec, &p_rec);
864 NTOHL_FP(&pkt->xmt, &p_xmt);
865 if (PKT_MODE(pkt->li_vn_mode) != MODE_BROADCAST)
866 NTOHL_FP(&pkt->org, &p_org);
867 else
868 p_org = peer->rec;
869
870 /*
871 * Test for old, duplicate or unsynch packets (tests 1-3).
872 */
873 peer->rec = *recv_ts;
874 pmode = PKT_MODE(pkt->li_vn_mode);
875 pleap = PKT_LEAP(pkt->li_vn_mode);
876 pstratum = PKT_TO_STRATUM(pkt->stratum);
877 if (L_ISHIS(&peer->org, &p_xmt)) /* count old packets */
878 peer->oldpkt++;
879 if (L_ISEQU(&peer->org, &p_xmt)) /* 1 */
880 peer->flash |= TEST1; /* dupe */
881 if (pmode != MODE_BROADCAST) {
882 if (!L_ISEQU(&peer->xmt, &p_org)) /* 2 */
883 peer->flash |= TEST2; /* bogus */
884 if (L_ISZERO(&p_rec) || L_ISZERO(&p_org)) /* test 3 */
885 peer->flash |= TEST3; /* unsynch */
886 }
887 if (L_ISZERO(&p_xmt)) /* 3 */
888 peer->flash |= TEST3; /* unsynch */
889 peer->org = p_xmt;
890
891 /*
892 * If tests 1-3 fail, the packet is discarded leaving only the
893 * receive and origin timestamps and poll interval, which is
894 * enough to get the protocol started.
895 */
896 if (peer->flash) {
897#ifdef DEBUG
898 if (debug)
899 printf("packet: bad data %03x\n",
900 peer->flash);
901#endif
902 return;
903 }
904
905 /*
906 * A kiss-of-death (kod) packet is returned by a server in case
907 * the client is denied access. It consists of the client
908 * request packet with the leap bits indicating never
909 * synchronized, stratum zero and reference ID field the ASCII
910 * string "DENY". If the packet originate timestamp matches the
911 * association transmit timestamp the kod is legitimate. If the
912 * peer leap bits indicate never synchronized, this must be
913 * access deny and the association is disabled; otherwise this
914 * must be a limit reject. In either case a naughty message is
915 * forced to the system log.
916 */
917 if (pleap == LEAP_NOTINSYNC && pstratum >= STRATUM_UNSPEC &&
918 memcmp(&pkt->refid, "DENY", 4) == 0) {
919 if (peer->leap == LEAP_NOTINSYNC) {
920 peer->stratum = STRATUM_UNSPEC;
921 peer->flash |= TEST4;
922 memcpy(&peer->refid, &pkt->refid, 4);
923 msyslog(LOG_INFO, "access denied");
924 } else {
925 msyslog(LOG_INFO, "limit reject");
926 }
927 return;
928 }
929
930 /*
931 * Test for valid peer data (tests 6-8)
932 */
933 ci = p_xmt;
934 L_SUB(&ci, &p_reftime);
935 LFPTOD(&ci, dtemp);
936 if (pleap == LEAP_NOTINSYNC || /* 6 */
937 pstratum >= STRATUM_UNSPEC || dtemp < 0)
938 peer->flash |= TEST6; /* bad synch */
939 if (!(peer->flags & FLAG_CONFIG) && sys_peer != NULL) { /* 7 */
940 if (pstratum > sys_stratum && pmode != MODE_ACTIVE) {
941 peer->flash |= TEST7; /* bad stratum */
942 sys_badstratum++;
943 }
944 }
945 if (p_del < 0 || p_disp < 0 || p_del / /* 8 */
946 2 + p_disp >= MAXDISPERSE)
947 peer->flash |= TEST8; /* bad peer distance */
948 if (peer->flash) {
949#ifdef DEBUG
950 if (debug)
951 printf("packet: bad header %03x\n",
952 peer->flash);
953#endif
954 return;
955 }
956
957 /*
958 * The header is valid. Capture the remaining header values and
959 * mark as reachable.
960 */
961 record_raw_stats(&peer->srcadr, &peer->dstadr->sin, &p_org,
962 &p_rec, &p_xmt, &peer->rec);
963 peer->leap = pleap;
964 peer->pmode = pmode;
965 peer->stratum = pstratum;
966 peer->ppoll = pkt->ppoll;
967 peer->precision = pkt->precision;
968 peer->rootdelay = p_del;
969 peer->rootdispersion = p_disp;
970 peer->refid = pkt->refid;
971 peer->reftime = p_reftime;
972 if (!(peer->reach)) {
973 report_event(EVNT_REACH, peer);
974 peer->timereachable = current_time;
975 }
976 peer->reach |= 1;
977 peer->unreach = 0;
978 poll_update(peer, peer->hpoll);
979
980 /*
981 * If running in a client/server association, calculate the
982 * clock offset c, roundtrip delay d and dispersion e. We use
983 * the equations (reordered from those in the spec). Note that,
984 * in a broadcast association, org has been set to the time of
985 * last reception. Note the computation of dispersion includes
--- 4 unchanged lines hidden (view full) ---
990 * d = (t2 - t3) - (t1 - t0)
991 * e = (org - rec) (seconds only)
992 */
993 t10 = p_xmt; /* compute t1 - t0 */
994 L_SUB(&t10, &peer->rec);
995 t23 = p_rec; /* compute t2 - t3 */
996 L_SUB(&t23, &p_org);
997 ci = t10;
998 p_disp = clock_phi * (peer->rec.l_ui - p_org.l_ui);
999
1000 /*
1001 * If running in a broadcast association, the clock offset is
1002 * (t1 - t0) corrected by the one-way delay, but we can't
1003 * measure that directly. Therefore, we start up in MODE_CLIENT
1004 * mode, set FLAG_MCAST and exchange eight messages to determine
1005 * the clock offset. When the last message is sent, we switch to
1006 * MODE_BCLIENT mode. The next broadcast message after that
1007 * computes the broadcast offset and clears FLAG_MCAST.
1008 */
1009 if (pmode == MODE_BROADCAST) {
1010 if (peer->flags & FLAG_MCAST) {
1011 LFPTOD(&ci, p_offset);
1012 peer->estbdelay = peer->offset - p_offset;
1013 if (peer->hmode == MODE_CLIENT)
1014 return;
1015
1016 peer->flags &= ~FLAG_MCAST;
1017 }
1018 DTOLFP(peer->estbdelay, &t10);
1019 L_ADD(&ci, &t10);
1020 p_del = peer->delay;
1021 } else {
1022 L_ADD(&ci, &t23);
1023 L_RSHIFT(&ci);
1024 L_SUB(&t23, &t10);
1025 LFPTOD(&t23, p_del);
1026 }
1027 p_del = max(p_del, LOGTOD(sys_precision));
1028 LFPTOD(&ci, p_offset);
1029 if ((peer->rootdelay + p_del) / 2. + peer->rootdispersion +
1030 p_disp >= MAXDISPERSE) /* 9 */
1031 peer->flash |= TEST9; /* bad peer distance */
1032
1033 /*
1034 * If any flasher bits remain set at this point, abandon ship.
1035 * Otherwise, forward to the clock filter.
1036 */
1037 if (peer->flash) {
1038#ifdef DEBUG
1039 if (debug)
1040 printf("packet: bad packet data %03x\n",
1041 peer->flash);
1042#endif
1043 return;
1044 }
1045 clock_filter(peer, p_offset, p_del, p_disp);
1046 clock_select();
1047 record_peer_stats(&peer->srcadr, ctlpeerstatus(peer),
1048 peer->offset, peer->delay, peer->disp,
1049 SQRT(peer->jitter));
1050}
1051
1052
1053/*
1054 * clock_update - Called at system process update intervals.
1055 */
1056static void
1057clock_update(void)
1058{
1059 u_char oleap;
1060 u_char ostratum;
1061
1062 /*
1063 * Reset/adjust the system clock. Do this only if there is a
1064 * system peer and we haven't seen that peer lately. Watch for
1065 * timewarps here.
1066 */
1067 if (sys_peer == NULL)
1068 return;
1069 if (sys_peer->pollsw == FALSE || sys_peer->burst > 0)
1070 return;
1071 sys_peer->pollsw = FALSE;
1072#ifdef DEBUG
1073 if (debug)
1074 printf("clock_update: at %ld assoc %d \n", current_time,
1075 peer_associations);
1076#endif
1077 oleap = sys_leap;
1078 ostratum = sys_stratum;
1079 switch (local_clock(sys_peer, sys_offset, sys_syserr)) {
1080
1081 /*
1082 * Clock is too screwed up. Just exit for now.
1083 */
1084 case -1:
1085 report_event(EVNT_SYSFAULT, (struct peer *)0);
1086 exit(1);
1087 /*NOTREACHED*/
1088
1089 /*
1090 * Clock was stepped. Flush all time values of all peers.
1091 */
1092 case 1:
1093 clear_all();
1094 sys_peer = NULL;
1095 sys_stratum = STRATUM_UNSPEC;
1096 sys_poll = NTP_MINPOLL;
1097 NLOG(NLOG_SYNCSTATUS)
1098 msyslog(LOG_INFO, "synchronisation lost");
1099 report_event(EVNT_CLOCKRESET, (struct peer *)0);
1100 break;
1101
1102 /*
1103 * Update the system stratum, leap bits, root delay, root
1104 * dispersion, reference ID and reference time. We also update
1105 * select dispersion and max frequency error. If the leap
1106 * changes, we gotta reroll the keys.
1107 */
1108 default:
1109 sys_stratum = sys_peer->stratum + 1;
1110 if (sys_stratum == 1)
1111 sys_refid = sys_peer->refid;
1112 else
1113 sys_refid = sys_peer->srcadr.sin_addr.s_addr;
1114 sys_reftime = sys_peer->rec;
1115 sys_rootdelay = sys_peer->rootdelay + sys_peer->delay;
1116 sys_leap = leap_consensus;
1117 }
1118 if (oleap == LEAP_NOTINSYNC) {
1119 report_event(EVNT_SYNCCHG, (struct peer *)0);
1120#ifdef AUTOKEY
1121 expire_all();
1122#endif /* AUTOKEY */
1123 }
1124 if (ostratum != sys_stratum)
1125 report_event(EVNT_PEERSTCHG, (struct peer *)0);
1126}
1127
1128
1129/*
1130 * poll_update - update peer poll interval
1131 */
1132void
1133poll_update(
1134 struct peer *peer,
1135 int hpoll
1136 )
1137{
1138#ifdef AUTOKEY
1139 int oldpoll;
1140#endif /* AUTOKEY */
1141
1142 /*
1143 * A little foxtrot to determine what controls the poll
1144 * interval. If the peer is reachable, but the last four polls
1145 * have not been answered, use the minimum. If declared
1146 * truechimer, use the system poll interval. This allows each
1147 * association to ramp up the poll interval for useless sources
1148 * and to clamp it to the minimum when first starting up.
1149 */
1150#ifdef AUTOKEY
1151 oldpoll = peer->kpoll;
1152#endif /* AUTOKEY */
1153 if (hpoll > peer->maxpoll)
1154 peer->hpoll = peer->maxpoll;
1155 else if (hpoll < peer->minpoll)
1156 peer->hpoll = peer->minpoll;
1157 else
1158 peer->hpoll = hpoll;
1159
1160 /*
1161 * Bit of adventure here. If during a burst and not timeout,
1162 * just slink away. If timeout, figure what the next timeout
1163 * should be. If IBURST or a reference clock, use one second. If
1164 * not and the dude was reachable during the previous poll
1165 * interval, randomize over 1-4 seconds; otherwise, randomize
1166 * over 15-18 seconds. This is to give time for a modem to
1167 * complete the call, for example. If not during a burst,
1168 * randomize over the poll interval -1 to +2 seconds.
1169 *
1170 * In case of manycast server, make the poll interval, which is
1171 * axtually the manycast beacon interval, eight times the system
1172 * poll interval. Normally when the host poll interval settles
1173 * up to 17.1 s, the beacon interval settles up to 2.3 hours.
1174 */
1175 if (peer->burst > 0) {
1176 if (peer->nextdate != current_time)
1177 return;
1178#ifdef REFCLOCK
1179 else if (peer->flags & FLAG_REFCLOCK)
1180 peer->nextdate++;
1181#endif
1182 else if (peer->reach & 0x1)
1183 peer->nextdate += RANDPOLL(BURST_INTERVAL2);
1184 else
1185 peer->nextdate += RANDPOLL(BURST_INTERVAL1);
1186 } else if (peer->cast_flags & MDF_ACAST) {
1187 if (sys_survivors < NTP_MINCLOCK)
1188 peer->kpoll = peer->hpoll;
1189 else
1190 peer->kpoll = peer->hpoll + 3;
1191 peer->nextdate = peer->outdate + RANDPOLL(peer->kpoll);
1192 } else {
1193 peer->kpoll = max(min(peer->ppoll, peer->hpoll),
1194 peer->minpoll);
1195 peer->nextdate = peer->outdate + RANDPOLL(peer->kpoll);
1196 }
1197 if (peer->nextdate < current_time)
1198 peer->nextdate = current_time;
1199#ifdef AUTOKEY
1200 /*
1201 * Bit of crass arrogance at this point. If the poll interval
1202 * has changed and we have a keylist, the lifetimes in the
1203 * keylist are probably bogus. In this case purge the keylist
1204 * and regenerate it later.
1205 */
1206 if (peer->kpoll != oldpoll)
1207 key_expire(peer);
1208#endif /* AUTOKEY */
1209#ifdef DEBUG
1210 if (debug > 1)
1211 printf("poll_update: at %lu %s flags %04x poll %d burst %d last %lu next %lu\n",
1212 current_time, ntoa(&peer->srcadr), peer->flags,
1213 peer->kpoll, peer->burst, peer->outdate,
1214 peer->nextdate);
1215#endif
1216}
1217
1218
1219/*
1220 * clear - clear peer filter registers. See Section 3.4.8 of the spec.
1221 */
1222void
1223peer_clear(
1224 register struct peer *peer
1225 )
1226{
1227 register int i;
1228 u_long u_rand;
1229
1230 /*
1231 * If cryptographic credentials have been acquired, toss them to
1232 * Valhalla. Note that autokeys are ephemeral, in that they are
1233 * tossed immediately upon use. Therefore, the keylist can be
1234 * purged anytime without needing to preserve random keys. Note
1235 * that, if the peer is purged, the cryptographic variables are
1236 * purged, too. This makes it much harder to sneak in some
1237 * unauthenticated data in the clock filter.
1238 */
1239#ifdef DEBUG
1240 if (debug)
1241 printf("peer_clear: at %ld assoc ID %d\n", current_time,
1242 peer->associd);
1243#endif
1244#ifdef AUTOKEY
1245 key_expire(peer);
1246#ifdef PUBKEY
1247 if (peer->keystr != NULL)
1248 free(peer->keystr);
1249 if (peer->pubkey.ptr != NULL)
1250 free(peer->pubkey.ptr);
1251 if (peer->certif.ptr != NULL)
1252 free(peer->certif.ptr);
1253#endif /* PUBKEY */
1254#endif /* AUTOKEY */
1255 memset(CLEAR_TO_ZERO(peer), 0, LEN_CLEAR_TO_ZERO);
1256
1257 /*
1258 * If he dies as a broadcast client, he comes back to life as
1259 * a broadcast client in client mode in order to recover the
1260 * initial autokey values. Note that there is no need to call
1261 * clock_select(), since the perp has already been voted off
1262 * the island at this point.
1263 */
1264 if (peer->cast_flags & MDF_BCLNT) {
1265 peer->flags |= FLAG_MCAST;
1266 peer->hmode = MODE_CLIENT;
1267 }
1268 peer->flags &= ~(FLAG_AUTOKEY | FLAG_ASSOC);
1269 peer->estbdelay = sys_bdelay;
1270 peer->hpoll = peer->kpoll = peer->minpoll;
1271 peer->ppoll = peer->maxpoll;
1272 peer->pollsw = FALSE;
1273 peer->jitter = MAXDISPERSE;
1274 peer->epoch = current_time;
1275#ifdef REFCLOCK
1276 if (!(peer->flags & FLAG_REFCLOCK)) {
1277 peer->leap = LEAP_NOTINSYNC;
1278 peer->stratum = STRATUM_UNSPEC;
1279 }
1280#endif
1281 for (i = 0; i < NTP_SHIFT; i++) {
1282 peer->filter_order[i] = i;
1283 peer->filter_disp[i] = MAXDISPERSE;
1284 peer->filter_epoch[i] = current_time;
1285 }
1286
1287 /*
1288 * Randomize the first poll over 1-16s to avoid bunching.
1289 */
1290 peer->update = peer->outdate = current_time;
1291 u_rand = RANDOM;
1292 peer->nextdate = current_time + (u_rand & ((1 <<
1293 BURST_INTERVAL1) - 1)) + 1;
1294}
1295
1296
1297/*
1298 * clock_filter - add incoming clock sample to filter register and run
1299 * the filter procedure to find the best sample.
1300 */
1301void
1302clock_filter(
1303 register struct peer *peer, /* peer structure pointer */
1304 double sample_offset, /* clock offset */
1305 double sample_delay, /* roundtrip delay */
1306 double sample_disp /* dispersion */
1307 )
1308{
1309 double dst[NTP_SHIFT]; /* distance vector */
1310 int ord[NTP_SHIFT]; /* index vector */
1311 register int i, j, k, m;
1312 double dsp, jit, dtemp, etemp;
1313
1314 /*
1315 * Shift the new sample into the register and discard the oldest
1316 * one. The new offset and delay come directly from the
1317 * timestamp calculations. The dispersion grows from the last
1318 * outbound packet or reference clock update to the present time
1319 * and increased by the sum of the peer precision and the system
1320 * precision. The delay can sometimes swing negative due to
1321 * frequency skew, so it is clamped non-negative.
1322 */
1323 dsp = min(LOGTOD(peer->precision) + LOGTOD(sys_precision) +
1324 sample_disp, MAXDISPERSE);
1325 j = peer->filter_nextpt;
1326 peer->filter_offset[j] = sample_offset;
1327 peer->filter_delay[j] = max(0, sample_delay);
1328 peer->filter_disp[j] = dsp;
1329 peer->filter_epoch[j] = current_time;
1330 j++; j %=NTP_SHIFT;
1331 peer->filter_nextpt = j;
1332
1333 /*
1334 * Update dispersions since the last update and at the same
1335 * time initialize the distance and index lists. The distance
1336 * list uses a compound metric. If the sample is valid and
1337 * younger than the minimum Allan intercept, use delay;
1338 * otherwise, use biased dispersion.
1339 */
1340 dtemp = clock_phi * (current_time - peer->update);
1341 peer->update = current_time;
1342 for (i = NTP_SHIFT - 1; i >= 0; i--) {
1343 if (i != 0) {
1344 peer->filter_disp[j] += dtemp;
1345 if (peer->filter_disp[j] > MAXDISPERSE)
1346 peer->filter_disp[j] = MAXDISPERSE;
1347 }
1348 if (peer->filter_disp[j] >= MAXDISPERSE)
1349 dst[i] = MAXDISPERSE;
1350 else if (peer->update - peer->filter_epoch[j] >
1351 allan_xpt)
1352 dst[i] = MAXDISTANCE + peer->filter_disp[j];
1353 else
1354 dst[i] = peer->filter_delay[j];
1355 ord[i] = j;
1356 j++; j %= NTP_SHIFT;
1357 }
1358
1359 /*
1360 * Sort the samples in both lists by distance.
1361 */
1362 for (i = 1; i < NTP_SHIFT; i++) {
1363 for (j = 0; j < i; j++) {
1364 if (dst[j] > dst[i]) {
1365 k = ord[j];
1366 ord[j] = ord[i];
1367 ord[i] = k;
1368 etemp = dst[j];
1369 dst[j] = dst[i];
1370 dst[i] = etemp;
1371 }
1372 }
1373 }
1374
1375 /*
1376 * Copy the index list to the association structure so ntpq
1377 * can see it later. Prune the distance list to samples less
1378 * than MAXDISTANCE, but keep at least two valid samples for
1379 * jitter calculation.
1380 */
1381 m = 0;
1382 for (i = 0; i < NTP_SHIFT; i++) {
1383 peer->filter_order[i] = ord[i];
1384 if (dst[i] >= MAXDISPERSE || (m >= 2 && dst[i] >=
1385 MAXDISTANCE))
1386 continue;
1387 m++;
1388 }
1389
1390 /*
1391 * Compute the dispersion and jitter squares. The dispersion
1392 * is weighted exponentially by NTP_FWEIGHT (0.5) so it is
1393 * normalized close to 1.0. The jitter is the mean of the square
1394 * differences relative to the lowest delay sample. If no
1395 * acceptable samples remain in the shift register, quietly
1396 * tiptoe home leaving only the
1397 * dispersion.
1398 */
1399 jit = 0;
1400 peer->disp = 0;
1401 k = ord[0];
1402 for (i = NTP_SHIFT - 1; i >= 0; i--) {
1403
1404 j = ord[i];
1405 peer->disp = NTP_FWEIGHT * (peer->disp +
1406 peer->filter_disp[j]);
1407 if (i < m)
1408 jit += DIFF(peer->filter_offset[j],
1409 peer->filter_offset[k]);
1410 }
1411
1412 /*
1413 * If no acceptable samples remain in the shift register,
1414 * quietly tiptoe home leaving only the dispersion. Otherwise,
1415 * save the offset, delay and jitter average. Note the jitter
1416 * must not be less than the system precision.
1417 */
1418 if (m == 0)
1419 return;
1420 etemp = peer->offset;
1421 peer->offset = peer->filter_offset[k];
1422 peer->delay = peer->filter_delay[k];
1423 if (m > 1)
1424 jit /= m - 1;
1425 peer->jitter = max(jit, SQUARE(LOGTOD(sys_precision)));
1426
1427 /*
1428 * A new sample is useful only if it is younger than the last
1429 * one used.
1430 */
1431 if (peer->filter_epoch[k] <= peer->epoch) {
1432#ifdef DEBUG
1433 if (debug)
1434 printf("clock_filter: discard %lu\n",
1435 peer->epoch - peer->filter_epoch[k]);
1436#endif
1437 return;
1438 }
1439
1440 /*
1441 * If the difference between the last offset and the current one
1442 * exceeds the jitter by CLOCK_SGATE (4) and the interval since
1443 * the last update is less than twice the system poll interval,
1444 * consider the update a popcorn spike and ignore it.
1445 */
1446 if (m > 1 && fabs(peer->offset - etemp) > SQRT(peer->jitter) *
1447 CLOCK_SGATE && peer->filter_epoch[k] - peer->epoch <
1448 (1 << (sys_poll + 1))) {
1449#ifdef DEBUG
1450 if (debug)
1451 printf("clock_filter: n %d popcorn spike %.6f jitter %.6f\n",
1452 m, peer->offset, SQRT(peer->jitter));
1453#endif
1454 return;
1455 }
1456
1457 /*
1458 * The mitigated sample statistics are saved for later
1459 * processing, but can be processed only once.
1460 */
1461 peer->epoch = peer->filter_epoch[k];
1462 peer->pollsw = TRUE;
1463#ifdef DEBUG
1464 if (debug)
1465 printf(
1466 "clock_filter: n %d off %.6f del %.6f dsp %.6f jit %.6f, age %lu\n",
1467 m, peer->offset, peer->delay, peer->disp,
1468 SQRT(peer->jitter), peer->update - peer->epoch);
1469#endif
1470}
1471
1472
1473/*
1474 * clock_select - find the pick-of-the-litter clock
1475 */
1476void
1477clock_select(void)
1478{
1479 register struct peer *peer;
1480 int i, j, k, n;
1481 int nreach, nlist, nl3;
1482 double d, e, f;
1483 int allow, found, sw;
1484 double high, low;
1485 double synch[NTP_MAXCLOCK], error[NTP_MAXCLOCK];
1486 struct peer *osys_peer;
1487 struct peer *typeacts = NULL;
1488 struct peer *typelocal = NULL;
1489 struct peer *typepps = NULL;
1490 struct peer *typesystem = NULL;
1491
1492 static int list_alloc = 0;
1493 static struct endpoint *endpoint = NULL;
1494 static int *indx = NULL;
1495 static struct peer **peer_list = NULL;
1496 static u_int endpoint_size = 0;
1497 static u_int indx_size = 0;
1498 static u_int peer_list_size = 0;
1499
1500 /*
1501 * Initialize and create endpoint, index and peer lists big
1502 * enough to handle all associations.
1503 */
1504 osys_peer = sys_peer;
1505 sys_peer = NULL;
1506 sys_prefer = NULL;
1507 nreach = nlist = 0;
1508 low = 1e9;
1509 high = -1e9;
1510 for (n = 0; n < HASH_SIZE; n++)
1511 nlist += peer_hash_count[n];
1512 if (nlist > list_alloc) {
1513 if (list_alloc > 0) {
1514 free(endpoint);
1515 free(indx);
1516 free(peer_list);
1517 }
1518 while (list_alloc < nlist) {
1519 list_alloc += 5;
1520 endpoint_size += 5 * 3 * sizeof(*endpoint);
1521 indx_size += 5 * 3 * sizeof(*indx);
1522 peer_list_size += 5 * sizeof(*peer_list);
1523 }
1524 endpoint = (struct endpoint *)emalloc(endpoint_size);
1525 indx = (int *)emalloc(indx_size);
1526 peer_list = (struct peer **)emalloc(peer_list_size);
1527 }
1528
1529 /*
1530 * Initially, we populate the island with all the rifraff peers
1531 * that happen to be lying around. Those with seriously
1532 * defective clocks are immediately booted off the island. Then,
1533 * the falsetickers are culled and put to sea. The truechimers
1534 * remaining are subject to repeated rounds where the most
1535 * unpopular at each round is kicked off. When the population
1536 * has dwindled to NTP_MINCLOCK (3), the survivors split a
1537 * million bucks and collectively crank the chimes.
1538 */
1539 nlist = nl3 = 0; /* none yet */
1540 for (n = 0; n < HASH_SIZE; n++) {
1541 for (peer = peer_hash[n]; peer != NULL; peer =
1542 peer->next) {
1543 peer->flags &= ~FLAG_SYSPEER;
1544 peer->status = CTL_PST_SEL_REJECT;
1545
1546 /*
1547 * A peer leaves the island immediately if
1548 * unreachable, synchronized to us or suffers
1549 * excessive root distance. Careful with the
1550 * root distance, since the poll interval can
1551 * increase to a day and a half.
1552 */
1553 if (!peer->reach || (peer->stratum > 1 &&
1554 peer->refid ==
1555 peer->dstadr->sin.sin_addr.s_addr) ||
1556 peer->stratum >= STRATUM_UNSPEC ||
1557 (root_distance(peer) >= MAXDISTANCE + 2 *
1558 clock_phi * ULOGTOD(sys_poll)))
1559 continue;
1560
1561 /*
1562 * Don't allow the local clock or modem drivers
1563 * in the kitchen at this point, unless the
1564 * prefer peer. Do that later, but only if
1565 * nobody else is around. These guys are all
1566 * configured, so we never throw them away.
1567 */
1568 if (peer->refclktype == REFCLK_LOCALCLOCK
1569#if defined(VMS) && defined(VMS_LOCALUNIT)
1570 /* wjm: local unit VMS_LOCALUNIT taken seriously */
1571 && REFCLOCKUNIT(&peer->srcadr) != VMS_LOCALUNIT
1572#endif /* VMS && VMS_LOCALUNIT */
1573 ) {
1574 typelocal = peer;
1575 if (!(peer->flags & FLAG_PREFER))
1576 continue; /* no local clock */
1577 }
1578 if (peer->sstclktype == CTL_SST_TS_TELEPHONE) {
1579 typeacts = peer;
1580 if (!(peer->flags & FLAG_PREFER))
1581 continue; /* no acts */
1582 }
1583
1584 /*
1585 * If we get this far, the peer can stay on the
1586 * island, but does not yet have the immunity
1587 * idol.
1588 */
1589 nreach++;
1590 peer->status = CTL_PST_SEL_SANE;
1591 peer_list[nlist++] = peer;
1592
1593 /*
1594 * Insert each interval endpoint on the sorted
1595 * list.
1596 */
1597 e = peer->offset; /* Upper end */
1598 f = root_distance(peer);
1599 e = e + f;
1600 for (i = nl3 - 1; i >= 0; i--) {
1601 if (e >= endpoint[indx[i]].val)
1602 break;
1603 indx[i + 3] = indx[i];
1604 }
1605 indx[i + 3] = nl3;
1606 endpoint[nl3].type = 1;
1607 endpoint[nl3++].val = e;
1608
1609 e = e - f; /* Center point */
1610 for ( ; i >= 0; i--) {
1611 if (e >= endpoint[indx[i]].val)
1612 break;
1613 indx[i + 2] = indx[i];
1614 }
1615 indx[i + 2] = nl3;
1616 endpoint[nl3].type = 0;
1617 endpoint[nl3++].val = e;
1618
1619 e = e - f; /* Lower end */
1620 for ( ; i >= 0; i--) {
1621 if (e >= endpoint[indx[i]].val)
1622 break;
1623 indx[i + 1] = indx[i];
1624 }
1625 indx[i + 1] = nl3;
1626 endpoint[nl3].type = -1;
1627 endpoint[nl3++].val = e;
1628 }
1629 }
1630#ifdef DEBUG
1631 if (debug > 2)
1632 for (i = 0; i < nl3; i++)
1633 printf("select: endpoint %2d %.6f\n",
1634 endpoint[indx[i]].type,
1635 endpoint[indx[i]].val);
1636#endif
1637 i = 0;
1638 j = nl3 - 1;
1639 allow = nlist; /* falsetickers assumed */
1640 found = 0;
1641 while (allow > 0) {
1642 allow--;
1643 for (n = 0; i <= j; i++) {
1644 n += endpoint[indx[i]].type;
1645 if (n < 0)
1646 break;
1647 if (endpoint[indx[i]].type == 0)
1648 found++;
1649 }
1650 for (n = 0; i <= j; j--) {
1651 n += endpoint[indx[j]].type;
1652 if (n > 0)
1653 break;
1654 if (endpoint[indx[j]].type == 0)
1655 found++;
1656 }
1657 if (found > allow)
1658 break;
1659 low = endpoint[indx[i++]].val;
1660 high = endpoint[indx[j--]].val;
1661 }
1662
1663 /*
1664 * If no survivors remain at this point, check if the local
1665 * clock or modem drivers have been found. If so, nominate one
1666 * of them as the only survivor. Otherwise, give up and declare
1667 * us unsynchronized.
1668 */
1669 if ((allow << 1) >= nlist) {
1670 if (typeacts != 0) {
1671 typeacts->status = CTL_PST_SEL_SANE;
1672 peer_list[0] = typeacts;
1673 nlist = 1;
1674 } else if (typelocal != 0) {
1675 typelocal->status = CTL_PST_SEL_SANE;
1676 peer_list[0] = typelocal;
1677 nlist = 1;
1678 } else {
1679 if (osys_peer != NULL) {
1680 sys_poll = NTP_MINPOLL;
1681 NLOG(NLOG_SYNCSTATUS)
1682 msyslog(LOG_INFO,
1683 "synchronisation lost");
1684 report_event(EVNT_PEERSTCHG,
1685 (struct peer *)0);
1686 }
1687 sys_survivors = 0;
1688#ifdef AUTOKEY
1689 resetmanycast();
1690#endif /* AUTOKEY */
1691 return;
1692 }
1693 }
1694#ifdef DEBUG
1695 if (debug > 2)
1696 printf("select: low %.6f high %.6f\n", low, high);
1697#endif
1698
1699 /*
1700 * Clustering algorithm. Construct candidate list in order first
1701 * by stratum then by root distance. If we have more than
1702 * MAXCLOCK peers, keep only the best MAXCLOCK of them. Scan the
1703 * list to find falsetickers, who leave the island immediately.
1704 * If a falseticker is not configured, his association raft is
1705 * drowned as well. We must leave at least one peer to collect
1706 * the million bucks.
1707 */
1708 j = 0;
1709 for (i = 0; i < nlist; i++) {
1710 peer = peer_list[i];
1711 if (nlist > 1 && (low >= peer->offset || peer->offset >=
1712 high)) {
1713 if (!(peer->flags & FLAG_CONFIG))
1714 unpeer(peer);
1715 continue;
1716 }
1717 peer->status = CTL_PST_SEL_DISTSYSPEER;
1718 d = root_distance(peer) + peer->stratum * MAXDISPERSE;
1719 if (j >= NTP_MAXCLOCK) {
1720 if (d >= synch[j - 1])
1721 continue;
1722 else
1723 j--;
1724 }
1725 for (k = j; k > 0; k--) {
1726 if (d >= synch[k - 1])
1727 break;
1728 peer_list[k] = peer_list[k - 1];
1729 error[k] = error[k - 1];
1730 synch[k] = synch[k - 1];
1731 }
1732 peer_list[k] = peer;
1733 error[k] = peer->jitter;
1734 synch[k] = d;
1735 j++;
1736 }
1737 nlist = j;
1738 for (i = 0; i < nlist; i++) {
1739 peer_list[i]->status = CTL_PST_SEL_SELCAND;
1740
1741#ifdef DEBUG
1742 if (debug > 2)
1743 printf("select: %s distance %.6f\n",
1744 ntoa(&peer_list[i]->srcadr), synch[i]);
1745#endif
1746 }
1747
1748 /*
1749 * Now, vote outlyers off the island by select jitter weighted
1750 * by root dispersion. Continue voting as long as there are more
1751 * than NTP_MINCLOCK survivors and the minimum select jitter
1752 * squared is greater than the maximum peer jitter squared. Stop
1753 * if we are about to discard a prefer peer, who of course has
1754 * the immunity idol.
1755 */
1756 while (1) {
1757 d = 1e9;
1758 e = -1e9;
1759 k = 0;
1760 for (i = 0; i < nlist; i++) {
1761
1762 if (error[i] < d)
1763 d = error[i];
1764 f = 0;
1765 if (nlist > 1) {
1766 for (j = 0; j < nlist; j++)
1767 f += DIFF(peer_list[j]->offset,
1768 peer_list[i]->offset);
1769 f /= nlist - 1;
1770 }
1771 f = max(f, SQUARE(LOGTOD(sys_precision)));
1772 if (f * synch[i] > e) {
1773 sys_selerr = f;
1774 e = f * synch[i];
1775 k = i;
1776 }
1777 }
1778
1779#ifdef DEBUG
1780 if (debug > 2)
1781 printf(
1782 "select: survivors %d select %.6f peer %.6f\n",
1783 k, SQRT(sys_selerr), SQRT(d));
1784#endif
1785 if (nlist <= NTP_MINCLOCK || sys_selerr <= d ||
1786 peer_list[k]->flags & FLAG_PREFER)
1787 break;
1788 if (!(peer_list[k]->flags & FLAG_CONFIG))
1789 unpeer(peer_list[k]);
1790 for (j = k + 1; j < nlist; j++) {
1791 peer_list[j - 1] = peer_list[j];
1792 error[j - 1] = error[j];
1793 }
1794 nlist--;
1795 }
1796
1797#ifdef AUTOKEY
1798 /*
1799 * In manycast client mode we may have spooked a sizeable number
1800 * of servers that we don't need. If there are at least
1801 * NTP_MINCLOCK of them, the manycast message will be turned
1802 * off. By the time we get here we nay be ready to prune some of
1803 * them back, but we want to make sure all the candicates have
1804 * had a chance. If they didn't pass the sanity and intersection
1805 * tests, they have already been voted off the island.
1806 */
1807 if (sys_survivors >= NTP_MINCLOCK && nlist < NTP_MINCLOCK)
1808 resetmanycast();
1809#endif /* AUTOKEY */
1810 sys_survivors = nlist;
1811
1812#ifdef DEBUG
1813 if (debug > 2) {
1814 for (i = 0; i < nlist; i++)
1815 printf(
1816 "select: %s offset %.6f, distance %.6f poll %d\n",
1817 ntoa(&peer_list[i]->srcadr),
1818 peer_list[i]->offset, synch[i],
1819 peer_list[i]->pollsw);
1820 }
1821#endif
1822
1823 /*
1824 * What remains is a list of not greater than NTP_MINCLOCK
1825 * peers. We want only a peer at the lowest stratum to become
1826 * the system peer, although all survivors are eligible for the
1827 * combining algorithm. First record their order, diddle the
1828 * flags and clamp the poll intervals. Then, consider the peers
1829 * at the lowest stratum. Of these, OR the leap bits on the
1830 * assumption that, if some of them honk nonzero bits, they must
1831 * know what they are doing. Also, check for prefer and pps
1832 * peers. If a prefer peer is found within clock_max, update the
1833 * pps switch. Of the other peers not at the lowest stratum,
1834 * check if the system peer is among them and, if found, zap
1835 * him. We note that the head of the list is at the lowest
1836 * stratum and that unsynchronized peers cannot survive this
1837 * far.
1838 *
1839 * Note that we go no further, unless the number of survivors is
1840 * a majority of the suckers that have been found reachable and
1841 * no prior source is available. This avoids the transient when
1842 * one of a flock of sources is out to lunch and just happens
1843 * to be the first survivor.
1844 */
1845 if (osys_peer == NULL && 2 * nlist < min(nreach, NTP_MINCLOCK))
1846 return;
1847 leap_consensus = 0;
1848 for (i = nlist - 1; i >= 0; i--) {
1849 peer = peer_list[i];
1850 peer->status = CTL_PST_SEL_SYNCCAND;
1851 peer->flags |= FLAG_SYSPEER;
1852 poll_update(peer, peer->hpoll);
1853 if (peer->stratum == peer_list[0]->stratum) {
1854 leap_consensus |= peer->leap;
1855 if (peer->refclktype == REFCLK_ATOM_PPS &&
1856 peer->stratum < STRATUM_UNSPEC)
1857 typepps = peer;
1858 if (peer == osys_peer)
1859 typesystem = peer;
1860 if (peer->flags & FLAG_PREFER)
1861 sys_prefer = peer;
1862 }
1863 }
1864
1865 /*
1866 * Mitigation rules of the game. There are several types of
1867 * peers that make a difference here: (1) prefer local peers
1868 * (type REFCLK_LOCALCLOCK with FLAG_PREFER) or prefer modem
1869 * peers (type REFCLK_NIST_ATOM etc with FLAG_PREFER), (2) pps
1870 * peers (type REFCLK_ATOM_PPS), (3) remaining prefer peers
1871 * (flag FLAG_PREFER), (4) the existing system peer, if any, (5)
1872 * the head of the survivor list. Note that only one peer can be
1873 * declared prefer. The order of preference is in the order
1874 * stated. Note that all of these must be at the lowest stratum,
1875 * i.e., the stratum of the head of the survivor list.
1876 */
1877 if (sys_prefer)
1878 sw = sys_prefer->refclktype == REFCLK_LOCALCLOCK ||
1879 sys_prefer->sstclktype == CTL_SST_TS_TELEPHONE ||
1880 !typepps;
1881 else
1882 sw = 0;
1883 if (sw) {
1884 sys_peer = sys_prefer;
1885 sys_peer->status = CTL_PST_SEL_SYSPEER;
1886 sys_offset = sys_peer->offset;
1887 sys_syserr = sys_peer->jitter;
1888#ifdef DEBUG
1889 if (debug > 1)
1890 printf("select: prefer offset %.6f\n",
1891 sys_offset);
1892#endif
1893 } else if (typepps) {
1894 sys_peer = typepps;
1895 sys_peer->status = CTL_PST_SEL_PPS;
1896 sys_offset = sys_peer->offset;
1897 sys_syserr = sys_peer->jitter;
1898 if (!pps_control)
1899 NLOG(NLOG_SYSEVENT)
1900 msyslog(LOG_INFO,
1901 "pps sync enabled");
1902 pps_control = current_time;
1903#ifdef DEBUG
1904 if (debug > 1)
1905 printf("select: pps offset %.6f\n",
1906 sys_offset);
1907#endif
1908 } else {
1909 if (typesystem)
1910 sys_peer = osys_peer;
1911 else
1912 sys_peer = peer_list[0];
1913 sys_peer->status = CTL_PST_SEL_SYSPEER;
1914 sys_offset = clock_combine(peer_list, nlist);
1915 sys_syserr = sys_peer->jitter + sys_selerr;
1916#ifdef DEBUG
1917 if (debug > 1)
1918 printf("select: combine offset %.6f\n",
1919 sys_offset);
1920#endif
1921 }
1922 if (osys_peer != sys_peer)
1923 report_event(EVNT_PEERSTCHG, (struct peer *)0);
--- 23 unchanged lines hidden (view full) ---
1947/*
1948 * root_distance - compute synchronization distance from peer to root
1949 */
1950static double
1951root_distance(
1952 struct peer *peer
1953 )
1954{
1955 /*
1956 * Careful squeak here. The value returned must be greater than
1957 * zero blamed on the peer jitter, which must be at least the
1958 * square of sys_precision.
1959 */
1960 return ((peer->rootdelay + peer->delay) / 2 +
1961 peer->rootdispersion + peer->disp + clock_phi *
1962 (current_time - peer->update) + SQRT(peer->jitter));
1963}
1964
1965/*
1966 * peer_xmit - send packet for persistent association.
1967 */
1968static void
1969peer_xmit(
1970 struct peer *peer /* peer structure pointer */
1971 )
1972{
1973 struct pkt xpkt; /* transmit packet */
1974 int sendlen, authlen;
1975 keyid_t xkeyid; /* transmit key ID */
1976 l_fp xmt_tx;
1977
1978 /*
1979 * Initialize transmit packet header fields.
1980 */
1981 xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap, peer->version,
1982 peer->hmode);
1983 xpkt.stratum = STRATUM_TO_PKT(sys_stratum);
1984 xpkt.ppoll = peer->hpoll;
1985 xpkt.precision = sys_precision;
1986 xpkt.rootdelay = HTONS_FP(DTOFP(sys_rootdelay));
1987 xpkt.rootdispersion = HTONS_FP(DTOUFP(sys_rootdispersion));
1988 xpkt.refid = sys_refid;
1989 HTONL_FP(&sys_reftime, &xpkt.reftime);
1990 HTONL_FP(&peer->org, &xpkt.org);
1991 HTONL_FP(&peer->rec, &xpkt.rec);
1992
1993 /*
1994 * If the received packet contains a MAC, the transmitted packet
1995 * is authenticated and contains a MAC. If not, the transmitted
1996 * packet is not authenticated.
1997 *
1998 * In the current I/O semantics the default interface is set
1999 * until after receiving a packet and setting the right
2000 * interface. So, the first packet goes out unauthenticated.
2001 * That's why the really icky test next is here.
2002 */
2003 sendlen = LEN_PKT_NOMAC;
2004 if (!(peer->flags & FLAG_AUTHENABLE)) {
2005 get_systime(&peer->xmt);
2006 HTONL_FP(&peer->xmt, &xpkt.xmt);
2007 sendpkt(&peer->srcadr, peer->dstadr, peer->ttl, &xpkt,
2008 sendlen);
2009 peer->sent++;
2010#ifdef DEBUG
2011 if (debug)
2012 printf("transmit: at %ld %s->%s mode %d\n",
2013 current_time, ntoa(&peer->dstadr->sin),
2014 ntoa(&peer->srcadr), peer->hmode);
2015#endif
2016 return;
2017 }
2018
2019 /*
2020 * The received packet contains a MAC, so the transmitted packet
2021 * must be authenticated. If autokey is enabled, fuss with the
2022 * various modes; otherwise, private key cryptography is used.
2023 */
2024#ifdef AUTOKEY
2025 if ((peer->flags & FLAG_SKEY)) {
2026 u_int cmmd;
2027
2028 /*
2029 * The Public Key Dance (PKD): Cryptographic credentials
2030 * are contained in extension fields, each including a
2031 * 4-octet length/code word followed by a 4-octet
2032 * association ID and optional additional data. Optional
2033 * data includes a 4-octet data length field followed by
2034 * the data itself. Request messages are sent from a
2035 * configured association; response messages can be sent
2036 * from a configured association or can take the fast
2037 * path without ever matching an association. Response
2038 * messages have the same code as the request, but have
2039 * a response bit and possibly an error bit set. In this
2040 * implementation, a message may contain no more than
2041 * one command and no more than one response.
2042 *
2043 * Cryptographic session keys include both a public and
2044 * a private componet. Request and response messages
2045 * using extension fields are always sent with the
2046 * private component set to zero. Packets without
2047 * extension fields indlude the private component when
2048 * the session key is generated.
2049 */
2050 while (1) {
2051
2052 /*
2053 * Allocate and initialize a keylist if not
2054 * already done. Then, use the list in inverse
2055 * order, discarding keys once used. Keep the
2056 * latest key around until the next one, so
2057 * clients can use client/server packets to
2058 * compute propagation delay.
2059 *
2060 * Note that once a key is used from the list,
2061 * it is retained in the key cache until the
2062 * next key is used. This is to allow a client
2063 * to retrieve the encrypted session key
2064 * identifier to verify authenticity.
2065 *
2066 * If for some reason a key is no longer in the
2067 * key cache, a birthday has happened and the
2068 * pseudo-random sequence is probably broken. In
2069 * that case, purge the keylist and regenerate
2070 * it.
2071 */
2072 if (peer->keynumber == 0)
2073 make_keylist(peer, peer->dstadr);
2074 else
2075 peer->keynumber--;
2076 xkeyid = peer->keylist[peer->keynumber];
2077 if (authistrusted(xkeyid))
2078 break;
2079 else
2080 key_expire(peer);
2081 }
2082 peer->keyid = xkeyid;
2083 switch (peer->hmode) {
2084
2085 /*
2086 * In broadcast mode the autokey values are required.
2087 * Send them when a new keylist is generated; otherwise,
2088 * send the association ID so the client can request
2089 * them at other times.
2090 */
2091 case MODE_BROADCAST:
2092 if (peer->flags & FLAG_ASSOC)
2093 cmmd = CRYPTO_AUTO | CRYPTO_RESP;
2094 else
2095 cmmd = CRYPTO_ASSOC | CRYPTO_RESP;
2096 sendlen += crypto_xmit((u_int32 *)&xpkt,
2097 sendlen, cmmd, 0, peer->associd);
2098 break;
2099
2100 /*
2101 * In symmetric modes the public key, leapsecond table,
2102 * agreement parameters and autokey values are required.
2103 *
2104 * 1. If a response is pending, always send it first.
2105 *
2106 * 2. Don't send anything except a public-key request
2107 * until the public key has been stored.
2108 *
2109 * 3. Once the public key has been stored, don't send
2110 * anything except an agreement parameter request
2111 * until the agreement parameters have been stored.
2112 *
2113 * 4. Once the argeement parameters have been stored,
2114 * don't send anything except a public value request
2115 * until the agreed key has been stored.
2116 *
2117 * 5. When the agreed key has been stored and the key
2118 * list is regenerated, send the autokey values
2119 * gratis unless they have already been sent.
2120 */
2121 case MODE_ACTIVE:
2122 case MODE_PASSIVE:
2123#ifdef PUBKEY
2124 if (peer->cmmd != 0)
2125 sendlen += crypto_xmit((u_int32 *)&xpkt,
2126 sendlen, (peer->cmmd >> 16) |
2127 CRYPTO_RESP, peer->hcookie,
2128 peer->associd);
2129 if (!peer->crypto)
2130 sendlen += crypto_xmit((u_int32 *)&xpkt,
2131 sendlen, CRYPTO_ASSOC,
2132 peer->hcookie, peer->assoc);
2133 else if (!crypto_flags &&
2134 peer->pcookie.tstamp == 0 && sys_leap !=
2135 LEAP_NOTINSYNC)
2136 sendlen += crypto_xmit((u_int32 *)&xpkt,
2137 sendlen, CRYPTO_PRIV, peer->hcookie,
2138 peer->assoc);
2139 else if (crypto_flags && peer->pubkey.ptr ==
2140 NULL)
2141 sendlen += crypto_xmit((u_int32 *)&xpkt,
2142 sendlen, CRYPTO_NAME, peer->hcookie,
2143 peer->assoc);
2144 else if (peer->crypto & CRYPTO_FLAG_CERT)
2145 sendlen += crypto_xmit((u_int32 *)&xpkt,
2146 sendlen, CRYPTO_CERT, peer->hcookie,
2147 peer->assoc);
2148 else if (crypto_flags && peer->crypto &
2149 CRYPTO_FLAG_DH && sys_leap !=
2150 LEAP_NOTINSYNC)
2151 sendlen += crypto_xmit((u_int32 *)&xpkt,
2152 sendlen, CRYPTO_DHPAR,
2153 peer->hcookie, peer->assoc);
2154 else if (crypto_flags && peer->pcookie.tstamp ==
2155 0 && sys_leap != LEAP_NOTINSYNC)
2156 sendlen += crypto_xmit((u_int32 *)&xpkt,
2157 sendlen, CRYPTO_DH, peer->hcookie,
2158 peer->assoc);
2159#else
2160 if (peer->cmmd != 0)
2161 sendlen += crypto_xmit((u_int32 *)&xpkt,
2162 sendlen, (peer->cmmd >> 16) |
2163 CRYPTO_RESP, peer->hcookie,
2164 peer->associd);
2165 if (peer->pcookie.tstamp == 0 && sys_leap !=
2166 LEAP_NOTINSYNC)
2167 sendlen += crypto_xmit((u_int32 *)&xpkt,
2168 sendlen, CRYPTO_PRIV, peer->hcookie,
2169 peer->assoc);
2170#endif /* PUBKEY */
2171 else if (!(peer->flags & FLAG_AUTOKEY))
2172 sendlen += crypto_xmit((u_int32 *)&xpkt,
2173 sendlen, CRYPTO_AUTO, peer->hcookie,
2174 peer->assoc);
2175 else if ((peer->flags & FLAG_ASSOC) &&
2176 (peer->cmmd >> 16) != CRYPTO_AUTO)
2177 sendlen += crypto_xmit((u_int32 *)&xpkt,
2178 sendlen, CRYPTO_AUTO | CRYPTO_RESP,
2179 peer->hcookie, peer->associd);
2180#ifdef PUBKEY
2181 else if (peer->crypto & CRYPTO_FLAG_TAI)
2182 sendlen += crypto_xmit((u_int32 *)&xpkt,
2183 sendlen, CRYPTO_TAI, peer->hcookie,
2184 peer->assoc);
2185#endif /* PUBKEY */
2186 peer->cmmd = 0;
2187 break;
2188
2189 /*
2190 * In client mode, the public key, host cookie and
2191 * autokey values are required. In broadcast client
2192 * mode, these values must be acquired during the
2193 * client/server exchange to avoid having to wait until
2194 * the next key list regeneration. Otherwise, the poor
2195 * dude may die a lingering death until becoming
2196 * unreachable and attempting rebirth. Note that we ask
2197 * for the cookie at each key list regeneration anyway.
2198 */
2199 case MODE_CLIENT:
2200 if (peer->cmmd != 0)
2201 sendlen += crypto_xmit((u_int32 *)&xpkt,
2202 sendlen, (peer->cmmd >> 16) |
2203 CRYPTO_RESP, peer->hcookie,
2204 peer->associd);
2205 if (!peer->crypto)
2206 sendlen += crypto_xmit((u_int32 *)&xpkt,
2207 sendlen, CRYPTO_ASSOC,
2208 peer->hcookie, peer->assoc);
2209#ifdef PUBKEY
2210 else if (crypto_flags && peer->pubkey.ptr ==
2211 NULL)
2212 sendlen += crypto_xmit((u_int32 *)&xpkt,
2213 sendlen, CRYPTO_NAME, peer->hcookie,
2214 peer->assoc);
2215 else if (peer->crypto & CRYPTO_FLAG_CERT)
2216 sendlen += crypto_xmit((u_int32 *)&xpkt,
2217 sendlen, CRYPTO_CERT, peer->hcookie,
2218 peer->assoc);
2219#endif /* PUBKEY */
2220 else if (peer->pcookie.tstamp == 0)
2221 sendlen += crypto_xmit((u_int32 *)&xpkt,
2222 sendlen, CRYPTO_PRIV, peer->hcookie,
2223 peer->assoc);
2224 else if (!(peer->flags & FLAG_AUTOKEY) &&
2225 (peer->cast_flags & MDF_BCLNT))
2226 sendlen += crypto_xmit((u_int32 *)&xpkt,
2227 sendlen, CRYPTO_AUTO, peer->hcookie,
2228 peer->assoc);
2229#ifdef PUBKEY
2230 else if (peer->crypto & CRYPTO_FLAG_TAI)
2231 sendlen += crypto_xmit((u_int32 *)&xpkt,
2232 sendlen, CRYPTO_TAI, peer->hcookie,
2233 peer->assoc);
2234#endif /* PUBKEY */
2235 peer->cmmd = 0;
2236 break;
2237 }
2238
2239 /*
2240 * If extension fields are present, we must use a
2241 * private value of zero and force min poll interval.
2242 * Most intricate.
2243 */
2244 if (sendlen > LEN_PKT_NOMAC)
2245 session_key(&peer->dstadr->sin, &peer->srcadr,
2246 xkeyid, 0, 2);
2247 }
2248#endif /* AUTOKEY */
2249 xkeyid = peer->keyid;
2250 get_systime(&peer->xmt);
2251 L_ADD(&peer->xmt, &sys_authdelay);
2252 HTONL_FP(&peer->xmt, &xpkt.xmt);
2253 authlen = authencrypt(xkeyid, (u_int32 *)&xpkt, sendlen);
2254 if (authlen == 0) {
2255 msyslog(LOG_NOTICE,
2256 "transmit: no encryption key found");
2257 peer->flash |= TEST4 | TEST5;
2258 return;
2259 }
2260 sendlen += authlen;
2261#ifdef AUTOKEY
2262 if (xkeyid > NTP_MAXKEY)
2263 authtrust(xkeyid, 0);
2264#endif /* AUTOKEY */
2265 get_systime(&xmt_tx);
2266 if (sendlen > sizeof(xpkt)) {
2267 msyslog(LOG_ERR, "buffer overflow %u", sendlen);
2268 exit(-1);
2269 }
2270 sendpkt(&peer->srcadr, peer->dstadr, peer->ttl, &xpkt, sendlen);
2271
2272 /*
2273 * Calculate the encryption delay. Keep the minimum over
2274 * the latest two samples.
2275 */
2276 L_SUB(&xmt_tx, &peer->xmt);
2277 L_ADD(&xmt_tx, &sys_authdelay);
2278 sys_authdly[1] = sys_authdly[0];
2279 sys_authdly[0] = xmt_tx.l_uf;
2280 if (sys_authdly[0] < sys_authdly[1])
2281 sys_authdelay.l_uf = sys_authdly[0];
2282 else
2283 sys_authdelay.l_uf = sys_authdly[1];
2284 peer->sent++;
2285#ifdef AUTOKEY
2286#ifdef DEBUG
2287 if (debug)
2288 printf(
2289 "transmit: at %ld %s->%s mode %d keyid %08x len %d mac %d index %d\n",
2290 current_time, ntoa(&peer->dstadr->sin),
2291 ntoa(&peer->srcadr), peer->hmode, xkeyid, sendlen,
2292 authlen, peer->keynumber);
2293#endif
2294#else
2295#ifdef DEBUG
2296 if (debug)
2297 printf(
2298 "transmit: at %ld %s->%s mode %d keyid %08x len %d mac %d\n",
2299 current_time, ntoa(&peer->dstadr->sin),
2300 ntoa(&peer->srcadr), peer->hmode, xkeyid, sendlen,
2301 authlen);
2302#endif
2303#endif /* AUTOKEY */
2304}
2305
2306
2307/*
2308 * fast_xmit - Send packet for nonpersistent association. Note that
2309 * neither the source or destination can be a broadcast address.
2310 */
2311static void
2312fast_xmit(
2313 struct recvbuf *rbufp, /* receive packet pointer */
2314 int xmode, /* transmit mode */
2315 keyid_t xkeyid, /* transmit key ID */
2316 int mask /* restrict mask */
2317 )
2318{
2319 struct pkt xpkt; /* transmit packet structure */
2320 struct pkt *rpkt; /* receive packet structure */
2321 l_fp xmt_ts; /* transmit timestamp */
2322 l_fp xmt_tx; /* transmit timestamp after authent */
2323 int sendlen, authlen;
2324
2325 /*
2326 * Initialize transmit packet header fields from the receive
2327 * buffer provided. We leave some fields intact as received. If
2328 * the gazinta was from a multicast address, the gazouta must go
2329 * out another way.
2330 */
2331 rpkt = &rbufp->recv_pkt;
2332 if (rbufp->dstadr->flags & INT_MULTICAST)
2333 rbufp->dstadr = findinterface(&rbufp->recv_srcadr);
2334
2335 /*
2336 * If the caller is restricted, return a kiss-of-death packet;
2337 * otherwise, smooch politely.
2338 */
2339 if (mask & (RES_DONTSERVE | RES_LIMITED)) {
2340 if (!(mask & RES_DEMOBILIZE)) {
2341 return;
2342 } else {
2343 xpkt.li_vn_mode =
2344 PKT_LI_VN_MODE(LEAP_NOTINSYNC,
2345 PKT_VERSION(rpkt->li_vn_mode), xmode);
2346 xpkt.stratum = STRATUM_UNSPEC;
2347 memcpy(&xpkt.refid, "DENY", 4);
2348 }
2349 } else {
2350 xpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap,
2351 PKT_VERSION(rpkt->li_vn_mode), xmode);
2352 xpkt.stratum = STRATUM_TO_PKT(sys_stratum);
2353 xpkt.refid = sys_refid;
2354 }
2355 xpkt.ppoll = rpkt->ppoll;
2356 xpkt.precision = sys_precision;
2357 xpkt.rootdelay = HTONS_FP(DTOFP(sys_rootdelay));
2358 xpkt.rootdispersion =
2359 HTONS_FP(DTOUFP(sys_rootdispersion));
2360 HTONL_FP(&sys_reftime, &xpkt.reftime);
2361 xpkt.org = rpkt->xmt;
2362 HTONL_FP(&rbufp->recv_time, &xpkt.rec);
2363
2364 /*
2365 * If the received packet contains a MAC, the transmitted packet
2366 * is authenticated and contains a MAC. If not, the transmitted
2367 * packet is not authenticated.
2368 */
2369 sendlen = LEN_PKT_NOMAC;
2370 if (rbufp->recv_length == sendlen) {
2371 get_systime(&xmt_ts);
2372 HTONL_FP(&xmt_ts, &xpkt.xmt);
2373 sendpkt(&rbufp->recv_srcadr, rbufp->dstadr, 0, &xpkt,
2374 sendlen);
2375#ifdef DEBUG
2376 if (debug)
2377 printf("transmit: at %ld %s->%s mode %d\n",
2378 current_time, ntoa(&rbufp->dstadr->sin),
2379 ntoa(&rbufp->recv_srcadr), xmode);
2380#endif
2381 return;
2382 }
2383
2384 /*
2385 * The received packet contains a MAC, so the transmitted packet
2386 * must be authenticated. For private-key cryptography, use the
2387 * predefined private keys to generate the cryptosum. For
2388 * autokey cryptography, use the server private value to
2389 * generate the cookie, which is unique for every source-
2390 * destination-key ID combination.
2391 */
2392#ifdef AUTOKEY
2393 if (xkeyid > NTP_MAXKEY) {
2394 keyid_t cookie;
2395 u_int code, associd;
2396
2397 /*
2398 * The only way to get here is a reply to a legitimate
2399 * client request message, so the mode must be
2400 * MODE_SERVER. If an extension field is present, there
2401 * can be only one and that must be a command. Do what
2402 * needs, but with private value of zero so the poor
2403 * jerk can decode it. If no extension field is present,
2404 * use the cookie to generate the session key.
2405 */
2406 code = (htonl(rpkt->exten[0]) >> 16) | CRYPTO_RESP;
2407 cookie = session_key(&rbufp->recv_srcadr,
2408 &rbufp->dstadr->sin, 0, sys_private, 0);
2409 associd = htonl(rpkt->exten[1]);
2410 if (rbufp->recv_length >= sendlen + MAX_MAC_LEN + 2 *
2411 sizeof(u_int32)) {
2412 session_key(&rbufp->dstadr->sin,
2413 &rbufp->recv_srcadr, xkeyid, 0, 2);
2414 sendlen += crypto_xmit((u_int32 *)&xpkt,
2415 sendlen, code, cookie, associd);
2416 } else {
2417 session_key(&rbufp->dstadr->sin,
2418 &rbufp->recv_srcadr, xkeyid, cookie, 2);
2419 }
2420 }
2421#endif /* AUTOKEY */
2422 get_systime(&xmt_ts);
2423 L_ADD(&xmt_ts, &sys_authdelay);
2424 HTONL_FP(&xmt_ts, &xpkt.xmt);
2425 authlen = authencrypt(xkeyid, (u_int32 *)&xpkt, sendlen);
2426 sendlen += authlen;
2427#ifdef AUTOKEY
2428 if (xkeyid > NTP_MAXKEY)
2429 authtrust(xkeyid, 0);
2430#endif /* AUTOKEY */
2431 get_systime(&xmt_tx);
2432 if (sendlen > sizeof(xpkt)) {
2433 msyslog(LOG_ERR, "buffer overflow %u", sendlen);
2434 exit(-1);
2435 }
2436 sendpkt(&rbufp->recv_srcadr, rbufp->dstadr, 0, &xpkt, sendlen);
2437
2438 /*
2439 * Calculate the encryption delay. Keep the minimum over the
2440 * latest two samples.
2441 */
2442 L_SUB(&xmt_tx, &xmt_ts);
2443 L_ADD(&xmt_tx, &sys_authdelay);
2444 sys_authdly[1] = sys_authdly[0];
2445 sys_authdly[0] = xmt_tx.l_uf;
2446 if (sys_authdly[0] < sys_authdly[1])
2447 sys_authdelay.l_uf = sys_authdly[0];
2448 else
2449 sys_authdelay.l_uf = sys_authdly[1];
2450#ifdef DEBUG
2451 if (debug)
2452 printf(
2453 "transmit: at %ld %s->%s mode %d keyid %08x len %d mac %d\n",
2454 current_time, ntoa(&rbufp->dstadr->sin),
2455 ntoa(&rbufp->recv_srcadr), xmode, xkeyid, sendlen,
2456 authlen);
2457#endif
2458}
2459
2460
2461#ifdef AUTOKEY
2462/*
2463 * key_expire - purge the key list
2464 */
2465void
2466key_expire(
2467 struct peer *peer /* peer structure pointer */
2468 )
2469{
2470 int i;
2471
2472 if (peer->keylist != NULL) {
2473 for (i = 0; i <= peer->keynumber; i++)
2474 authtrust(peer->keylist[i], 0);
2475 free(peer->keylist);
2476 peer->keylist = NULL;
2477 }
2478 peer->keynumber = peer->sndauto.seq = 0;
2479#ifdef DEBUG
2480 if (debug)
2481 printf("key_expire: at %lu\n", current_time);
2482#endif
2483}
2484#endif /* AUTOKEY */
2485
2486/*
2487 * Find the precision of this particular machine
2488 */
2489#define DUSECS 1000000 /* us in a s */
2490#define HUSECS (1 << 20) /* approx DUSECS for shifting etc */
2491#define MINSTEP 5 /* minimum clock increment (us) */
2492#define MAXSTEP 20000 /* maximum clock increment (us) */
--- 103 unchanged lines hidden (view full) ---
2596
2597 /*
2598 * Fill in the sys_* stuff. Default is don't listen to
2599 * broadcasting, authenticate.
2600 */
2601 sys_leap = LEAP_NOTINSYNC;
2602 sys_stratum = STRATUM_UNSPEC;
2603 sys_precision = (s_char)default_get_precision();
2604 sys_jitter = LOGTOD(sys_precision);
2605 sys_rootdelay = 0;
2606 sys_rootdispersion = 0;
2607 sys_refid = 0;
2608 L_CLR(&sys_reftime);
2609 sys_peer = NULL;
2610 sys_survivors = 0;
2611 get_systime(&dummy);
2612 sys_bclient = 0;
2613 sys_bdelay = DEFBROADDELAY;
2614 sys_authenticate = 1;
2615 L_CLR(&sys_authdelay);
2616 sys_authdly[0] = sys_authdly[1] = 0;
2617 sys_stattime = 0;
2618 sys_badstratum = 0;
2619 sys_oldversionpkt = 0;
2620 sys_newversionpkt = 0;
2621 sys_badlength = 0;
2622 sys_unknownversion = 0;
2623 sys_processed = 0;
2624 sys_badauth = 0;
2625 sys_manycastserver = 0;
2626#ifdef AUTOKEY
2627 sys_automax = 1 << NTP_AUTOMAX;
2628#endif /* AUTOKEY */
2629
2630 /*
2631 * Default these to enable
2632 */
2633 ntp_enable = 1;
2634#ifndef KERNEL_FLL_BUG
2635 kern_enable = 1;
2636#endif
2637 pps_enable = 0;
2638 stats_control = 1;
2639
2640 /*
2641 * Some system clocks should only be adjusted in 10ms
2642 * increments.
2643 */
2644#if defined RELIANTUNIX_CLOCK
2645 systime_10ms_ticks = 1; /* Reliant UNIX */
2646#elif defined SCO5_CLOCK
2647 if (sys_precision >= (s_char)-10) /* pre-SCO OpenServer 5.0.6 */
2648 systime_10ms_ticks = 1;
2649#endif
2650 if (systime_10ms_ticks)
--- 89 unchanged lines hidden (view full) ---
2740 case PROTO_AUTHENTICATE:
2741
2742 /*
2743 * Specify the use of authenticated data
2744 */
2745 sys_authenticate = (int)value;
2746 break;
2747
2748 case PROTO_PPS:
2749
2750 /*
2751 * Turn on/off PPS discipline
2752 */
2753 pps_enable = (int)value;
2754 break;
2755
2756#ifdef REFCLOCK
2757 case PROTO_CAL:
2758
2759 /*
2760 * Turn on/off refclock calibrate
2761 */
2762 cal_enable = (int)value;
2763 break;
2764#endif
2765
2766 default:
2767
2768 /*
2769 * Log this error
2770 */
2771 msyslog(LOG_ERR,
2772 "proto_config: illegal item %d, value %ld",
2773 item, value);
--- 21 unchanged lines hidden ---