1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109#include "libbb.h"
110#include <math.h>
111#include <netinet/ip.h>
112#include <sys/timex.h>
113#ifndef IPTOS_DSCP_AF21
114# define IPTOS_DSCP_AF21 0x48
115#endif
116
117
118
119
120
121
122#define MAX_VERBOSE 3
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166#define INITIAL_SAMPLES 4
167#define MIN_FREQHOLD 12
168#define BAD_DELAY_GROWTH 4
169
170#define RETRY_INTERVAL 32
171#define NOREPLY_INTERVAL 512
172#define RESPONSE_INTERVAL 16
173#define HOSTNAME_INTERVAL 4
174#define DNS_ERRORS_CAP 0x3f
175
176
177
178#define STEP_THRESHOLD 1
179
180
181
182#define SLEW_THRESHOLD 0.5
183
184
185
186
187
188
189
190
191
192
193
194
195#define BIGOFF STEP_THRESHOLD
196#define BIGOFF_INTERVAL (1 << 7)
197
198#define FREQ_TOLERANCE 0.000015
199#define BURSTPOLL 0
200#define MINPOLL 5
201
202
203
204
205#define BIGPOLL 9
206#define MAXPOLL 12
207
208
209
210
211
212
213#define MINDISP 0.01
214#define MAXDISP 16
215#define MAXSTRAT 16
216#define MAXDIST 1
217#define MIN_SELECTED 1
218#define MIN_CLUSTERED 3
219
220#define MAXDRIFT 0.000500
221
222
223
224
225
226
227
228
229#define POLLADJ_LIMIT 40
230
231
232
233
234#define POLLADJ_GATE 4
235#define TIMECONST_HACK_GATE 2
236
237#define ALLAN 512
238
239#define PLL 65536
240
241#define FLL (MAXPOLL + 1)
242
243#define AVG 4
244
245#define MAX_KEY_NUMBER 65535
246#define KEYID_SIZE sizeof(uint32_t)
247
248enum {
249 NTP_VERSION = 4,
250 NTP_MAXSTRATUM = 15,
251
252 NTP_MD5_DIGESTSIZE = 16,
253 NTP_MSGSIZE_NOAUTH = 48,
254 NTP_MSGSIZE_MD5_AUTH = NTP_MSGSIZE_NOAUTH + KEYID_SIZE + NTP_MD5_DIGESTSIZE,
255 NTP_SHA1_DIGESTSIZE = 20,
256 NTP_MSGSIZE_SHA1_AUTH = NTP_MSGSIZE_NOAUTH + KEYID_SIZE + NTP_SHA1_DIGESTSIZE,
257
258
259 MODE_MASK = (7 << 0),
260 VERSION_MASK = (7 << 3),
261 VERSION_SHIFT = 3,
262 LI_MASK = (3 << 6),
263
264
265 LI_NOWARNING = (0 << 6),
266 LI_PLUSSEC = (1 << 6),
267 LI_MINUSSEC = (2 << 6),
268 LI_ALARM = (3 << 6),
269
270
271 MODE_RES0 = 0,
272 MODE_SYM_ACT = 1,
273 MODE_SYM_PAS = 2,
274 MODE_CLIENT = 3,
275 MODE_SERVER = 4,
276 MODE_BROADCAST = 5,
277 MODE_RES1 = 6,
278 MODE_RES2 = 7,
279};
280
281
282#define OFFSET_1900_1970 2208988800UL
283
284#define NUM_DATAPOINTS 8
285
286typedef struct {
287 uint32_t int_partl;
288 uint32_t fractionl;
289} l_fixedpt_t;
290
291typedef struct {
292 uint16_t int_parts;
293 uint16_t fractions;
294} s_fixedpt_t;
295
296typedef struct {
297 uint8_t m_status;
298 uint8_t m_stratum;
299 uint8_t m_ppoll;
300 int8_t m_precision_exp;
301 s_fixedpt_t m_rootdelay;
302 s_fixedpt_t m_rootdisp;
303 uint32_t m_refid;
304 l_fixedpt_t m_reftime;
305 l_fixedpt_t m_orgtime;
306 l_fixedpt_t m_rectime;
307 l_fixedpt_t m_xmttime;
308 uint32_t m_keyid;
309 uint8_t m_digest[ENABLE_FEATURE_NTP_AUTH ? NTP_SHA1_DIGESTSIZE : NTP_MD5_DIGESTSIZE];
310} msg_t;
311
312typedef struct {
313 double d_offset;
314 double d_recv_time;
315 double d_dispersion;
316} datapoint_t;
317
318#if ENABLE_FEATURE_NTP_AUTH
319enum {
320 HASH_MD5,
321 HASH_SHA1,
322};
323typedef struct {
324 unsigned id;
325 smalluint type;
326 smalluint msg_size;
327 smalluint key_length;
328 char key[0];
329} key_entry_t;
330#endif
331
332typedef struct {
333 len_and_sockaddr *p_lsa;
334 char *p_dotted;
335#if ENABLE_FEATURE_NTP_AUTH
336 key_entry_t *key_entry;
337#endif
338 int p_fd;
339 int datapoint_idx;
340 uint32_t lastpkt_refid;
341 uint8_t lastpkt_status;
342 uint8_t lastpkt_stratum;
343 uint8_t reachable_bits;
344 uint8_t dns_errors;
345
346
347 double next_action_time;
348 double p_xmttime;
349 double p_raw_delay;
350
351
352 double lastpkt_recv_time;
353 double lastpkt_delay;
354 double lastpkt_rootdelay;
355 double lastpkt_rootdisp;
356
357 double filter_offset;
358 double filter_dispersion;
359 double filter_jitter;
360 datapoint_t filter_datapoint[NUM_DATAPOINTS];
361
362 msg_t p_xmt_msg;
363 char p_hostname[1];
364} peer_t;
365
366
367#define USING_KERNEL_PLL_LOOP 1
368#define USING_INITIAL_FREQ_ESTIMATION 0
369
370enum {
371 OPT_n = (1 << 0),
372 OPT_q = (1 << 1),
373 OPT_N = (1 << 2),
374 OPT_x = (1 << 3),
375 OPT_k = (1 << 4) * ENABLE_FEATURE_NTP_AUTH,
376
377
378 OPT_w = (1 << (4+ENABLE_FEATURE_NTP_AUTH)),
379 OPT_p = (1 << (5+ENABLE_FEATURE_NTP_AUTH)),
380 OPT_S = (1 << (6+ENABLE_FEATURE_NTP_AUTH)),
381 OPT_l = (1 << (7+ENABLE_FEATURE_NTP_AUTH)) * ENABLE_FEATURE_NTPD_SERVER,
382 OPT_I = (1 << (8+ENABLE_FEATURE_NTP_AUTH)) * ENABLE_FEATURE_NTPD_SERVER,
383
384 OPT_qq = (1 << 31),
385};
386
387struct globals {
388 double cur_time;
389
390 double rootdelay;
391
392 double reftime;
393
394 double rootdisp;
395
396 double last_script_run;
397 char *script_name;
398 llist_t *ntp_peers;
399#if ENABLE_FEATURE_NTPD_SERVER
400 int listen_fd;
401 char *if_name;
402# define G_listen_fd (G.listen_fd)
403#else
404# define G_listen_fd (-1)
405#endif
406 unsigned verbose;
407 unsigned peer_cnt;
408
409
410
411
412
413
414
415
416 uint32_t refid;
417 uint8_t ntp_status;
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444#define G_precision_exp -9
445
446
447
448
449
450
451#define G_precision_sec 0.002
452 uint8_t stratum;
453
454#define STATE_NSET 0
455
456
457
458#define STATE_SYNC 4
459 uint8_t discipline_state;
460 uint8_t poll_exp;
461 int polladj_count;
462 int FREQHOLD_cnt;
463 long kernel_freq_drift;
464 peer_t *last_update_peer;
465 double last_update_offset;
466 double last_update_recv_time;
467 double discipline_jitter;
468
469
470
471 unsigned offset_to_jitter_ratio;
472
473
474#if !USING_KERNEL_PLL_LOOP
475 double discipline_freq_drift;
476
477 double discipline_wander;
478#endif
479};
480#define G (*ptr_to_globals)
481
482
483#define VERB1 if (MAX_VERBOSE && G.verbose)
484#define VERB2 if (MAX_VERBOSE >= 2 && G.verbose >= 2)
485#define VERB3 if (MAX_VERBOSE >= 3 && G.verbose >= 3)
486#define VERB4 if (MAX_VERBOSE >= 4 && G.verbose >= 4)
487#define VERB5 if (MAX_VERBOSE >= 5 && G.verbose >= 5)
488#define VERB6 if (MAX_VERBOSE >= 6 && G.verbose >= 6)
489
490
491static double LOG2D(int a)
492{
493 if (a < 0)
494 return 1.0 / (1UL << -a);
495 return 1UL << a;
496}
497static ALWAYS_INLINE double SQUARE(double x)
498{
499 return x * x;
500}
501static ALWAYS_INLINE double MAXD(double a, double b)
502{
503 if (a > b)
504 return a;
505 return b;
506}
507static ALWAYS_INLINE double MIND(double a, double b)
508{
509 if (a < b)
510 return a;
511 return b;
512}
513static NOINLINE double my_SQRT(double X)
514{
515 union {
516 float f;
517 int32_t i;
518 } v;
519 double invsqrt;
520 double Xhalf = X * 0.5;
521
522
523 v.f = X;
524
525 v.i = 0x5f375a86 - (v.i >> 1);
526 invsqrt = v.f;
527
528
529
530
531
532
533
534 invsqrt = invsqrt * (1.5 - Xhalf * invsqrt * invsqrt);
535
536
537
538
539
540
541 return X * invsqrt;
542}
543static ALWAYS_INLINE double SQRT(double X)
544{
545
546 if (sizeof(float) != 4)
547 return sqrt(X);
548
549
550 return my_SQRT(X);
551}
552
553static double
554gettime1900d(void)
555{
556 struct timeval tv;
557 gettimeofday(&tv, NULL);
558 G.cur_time = tv.tv_sec + (1.0e-6 * tv.tv_usec) + OFFSET_1900_1970;
559 return G.cur_time;
560}
561
562static void
563d_to_tv(double d, struct timeval *tv)
564{
565 tv->tv_sec = (long)d;
566 tv->tv_usec = (d - tv->tv_sec) * 1000000;
567}
568
569static double
570lfp_to_d(l_fixedpt_t lfp)
571{
572 double ret;
573 lfp.int_partl = ntohl(lfp.int_partl);
574 lfp.fractionl = ntohl(lfp.fractionl);
575 ret = (double)lfp.int_partl + ((double)lfp.fractionl / UINT_MAX);
576 return ret;
577}
578static double
579sfp_to_d(s_fixedpt_t sfp)
580{
581 double ret;
582 sfp.int_parts = ntohs(sfp.int_parts);
583 sfp.fractions = ntohs(sfp.fractions);
584 ret = (double)sfp.int_parts + ((double)sfp.fractions / USHRT_MAX);
585 return ret;
586}
587#if ENABLE_FEATURE_NTPD_SERVER
588static l_fixedpt_t
589d_to_lfp(double d)
590{
591 l_fixedpt_t lfp;
592 lfp.int_partl = (uint32_t)d;
593 lfp.fractionl = (uint32_t)((d - lfp.int_partl) * UINT_MAX);
594 lfp.int_partl = htonl(lfp.int_partl);
595 lfp.fractionl = htonl(lfp.fractionl);
596 return lfp;
597}
598static s_fixedpt_t
599d_to_sfp(double d)
600{
601 s_fixedpt_t sfp;
602 sfp.int_parts = (uint16_t)d;
603 sfp.fractions = (uint16_t)((d - sfp.int_parts) * USHRT_MAX);
604 sfp.int_parts = htons(sfp.int_parts);
605 sfp.fractions = htons(sfp.fractions);
606 return sfp;
607}
608#endif
609
610static double
611dispersion(const datapoint_t *dp)
612{
613 return dp->d_dispersion + FREQ_TOLERANCE * (G.cur_time - dp->d_recv_time);
614}
615
616static double
617root_distance(peer_t *p)
618{
619
620
621
622
623
624 return MAXD(MINDISP, p->lastpkt_rootdelay + p->lastpkt_delay) / 2
625 + p->lastpkt_rootdisp
626 + p->filter_dispersion
627 + FREQ_TOLERANCE * (G.cur_time - p->lastpkt_recv_time)
628 + p->filter_jitter;
629}
630
631static void
632set_next(peer_t *p, unsigned t)
633{
634 p->next_action_time = G.cur_time + t;
635}
636
637
638
639
640static void
641filter_datapoints(peer_t *p)
642{
643 int i, idx;
644 double sum, wavg;
645 datapoint_t *fdp;
646
647#if 0
648
649
650
651
652
653 int got_newest;
654 double minoff, maxoff, w;
655 double x = x;
656 double oldest_off = oldest_off;
657 double oldest_age = oldest_age;
658 double newest_off = newest_off;
659 double newest_age = newest_age;
660
661 fdp = p->filter_datapoint;
662
663 minoff = maxoff = fdp[0].d_offset;
664 for (i = 1; i < NUM_DATAPOINTS; i++) {
665 if (minoff > fdp[i].d_offset)
666 minoff = fdp[i].d_offset;
667 if (maxoff < fdp[i].d_offset)
668 maxoff = fdp[i].d_offset;
669 }
670
671 idx = p->datapoint_idx;
672
673
674
675
676
677
678 wavg = 0;
679 w = 0.5;
680
681
682
683
684
685
686
687 got_newest = 0;
688 sum = 0;
689 for (i = 0; i < NUM_DATAPOINTS; i++) {
690 VERB5 {
691 bb_error_msg("datapoint[%d]: off:%f disp:%f(%f) age:%f%s",
692 i,
693 fdp[idx].d_offset,
694 fdp[idx].d_dispersion, dispersion(&fdp[idx]),
695 G.cur_time - fdp[idx].d_recv_time,
696 (minoff == fdp[idx].d_offset || maxoff == fdp[idx].d_offset)
697 ? " (outlier by offset)" : ""
698 );
699 }
700
701 sum += dispersion(&fdp[idx]) / (2 << i);
702
703 if (minoff == fdp[idx].d_offset) {
704 minoff -= 1;
705 } else
706 if (maxoff == fdp[idx].d_offset) {
707 maxoff += 1;
708 } else {
709 oldest_off = fdp[idx].d_offset;
710 oldest_age = G.cur_time - fdp[idx].d_recv_time;
711 if (!got_newest) {
712 got_newest = 1;
713 newest_off = oldest_off;
714 newest_age = oldest_age;
715 }
716 x = oldest_off * w;
717 wavg += x;
718 w /= 2;
719 }
720
721 idx = (idx - 1) & (NUM_DATAPOINTS - 1);
722 }
723 p->filter_dispersion = sum;
724 wavg += x;
725
726
727
728
729
730
731
732
733 x = oldest_age - newest_age;
734 if (x != 0) {
735 x = newest_age / x;
736 if (x < 1) {
737 x = (newest_off - oldest_off) * x;
738 wavg += x;
739 }
740 }
741 p->filter_offset = wavg;
742
743#else
744
745 fdp = p->filter_datapoint;
746 idx = p->datapoint_idx;
747
748
749 p->filter_offset = fdp[idx].d_offset;
750
751
752
753
754
755
756
757
758 wavg = 0;
759 sum = 0;
760 for (i = 0; i < NUM_DATAPOINTS; i++) {
761 sum += dispersion(&fdp[idx]) / (2 << i);
762 wavg += fdp[idx].d_offset;
763 idx = (idx - 1) & (NUM_DATAPOINTS - 1);
764 }
765 wavg /= NUM_DATAPOINTS;
766 p->filter_dispersion = sum;
767#endif
768
769
770
771
772
773
774
775
776
777
778
779
780 sum = 0;
781 for (i = 0; i < NUM_DATAPOINTS; i++) {
782 sum += SQUARE(wavg - fdp[i].d_offset);
783 }
784 sum = SQRT(sum / NUM_DATAPOINTS);
785 p->filter_jitter = sum > G_precision_sec ? sum : G_precision_sec;
786
787 VERB4 bb_error_msg("filter offset:%+f disp:%f jitter:%f",
788 p->filter_offset,
789 p->filter_dispersion,
790 p->filter_jitter);
791}
792
793static void
794reset_peer_stats(peer_t *p, double offset)
795{
796 int i;
797 bool small_ofs = fabs(offset) < STEP_THRESHOLD;
798
799
800
801
802
803
804
805
806
807
808
809
810
811 for (i = 0; i < NUM_DATAPOINTS; i++) {
812 if (small_ofs) {
813 p->filter_datapoint[i].d_recv_time += offset;
814 if (p->filter_datapoint[i].d_offset != 0) {
815 p->filter_datapoint[i].d_offset -= offset;
816
817
818
819
820 }
821 } else {
822 p->filter_datapoint[i].d_recv_time = G.cur_time;
823 p->filter_datapoint[i].d_offset = 0;
824
825 }
826 }
827 if (small_ofs) {
828 p->lastpkt_recv_time += offset;
829 } else {
830
831 p->lastpkt_recv_time = G.cur_time;
832 }
833 filter_datapoints(p);
834 VERB6 bb_error_msg("%s->lastpkt_recv_time=%f", p->p_dotted, p->lastpkt_recv_time);
835}
836
837static len_and_sockaddr*
838resolve_peer_hostname(peer_t *p)
839{
840 len_and_sockaddr *lsa = host2sockaddr(p->p_hostname, 123);
841 if (lsa) {
842 free(p->p_lsa);
843 free(p->p_dotted);
844 p->p_lsa = lsa;
845 p->p_dotted = xmalloc_sockaddr2dotted_noport(&lsa->u.sa);
846 VERB1 if (strcmp(p->p_hostname, p->p_dotted) != 0)
847 bb_error_msg("'%s' is %s", p->p_hostname, p->p_dotted);
848 p->dns_errors = 0;
849 return lsa;
850 }
851 p->dns_errors = ((p->dns_errors << 1) | 1) & DNS_ERRORS_CAP;
852 return lsa;
853}
854
855#if !ENABLE_FEATURE_NTP_AUTH
856#define add_peers(s, key_entry) \
857 add_peers(s)
858#endif
859static void
860add_peers(const char *s, key_entry_t *key_entry)
861{
862 llist_t *item;
863 peer_t *p;
864
865 p = xzalloc(sizeof(*p) + strlen(s));
866 strcpy(p->p_hostname, s);
867 p->p_fd = -1;
868 p->p_xmt_msg.m_status = MODE_CLIENT | (NTP_VERSION << 3);
869 p->next_action_time = G.cur_time;
870 reset_peer_stats(p, STEP_THRESHOLD);
871
872
873
874
875
876 if (resolve_peer_hostname(p)) {
877 for (item = G.ntp_peers; item != NULL; item = item->link) {
878 peer_t *pp = (peer_t *) item->data;
879 if (pp->p_dotted && strcmp(p->p_dotted, pp->p_dotted) == 0) {
880 bb_error_msg("duplicate peer %s (%s)", s, p->p_dotted);
881 free(p->p_lsa);
882 free(p->p_dotted);
883 free(p);
884 return;
885 }
886 }
887 }
888
889 IF_FEATURE_NTP_AUTH(p->key_entry = key_entry;)
890 llist_add_to(&G.ntp_peers, p);
891 G.peer_cnt++;
892}
893
894static int
895do_sendto(int fd,
896 const struct sockaddr *from, const struct sockaddr *to, socklen_t addrlen,
897 msg_t *msg, ssize_t len)
898{
899 ssize_t ret;
900
901 errno = 0;
902 if (!from) {
903 ret = sendto(fd, msg, len, MSG_DONTWAIT, to, addrlen);
904 } else {
905 ret = send_to_from(fd, msg, len, MSG_DONTWAIT, to, from, addrlen);
906 }
907 if (ret != len) {
908 bb_perror_msg("send failed");
909 return -1;
910 }
911 return 0;
912}
913
914#if ENABLE_FEATURE_NTP_AUTH
915static void
916hash(key_entry_t *key_entry, const msg_t *msg, uint8_t *output)
917{
918 union {
919 md5_ctx_t m;
920 sha1_ctx_t s;
921 } ctx;
922 unsigned hash_size = sizeof(*msg) - sizeof(msg->m_keyid) - sizeof(msg->m_digest);
923
924 switch (key_entry->type) {
925 case HASH_MD5:
926 md5_begin(&ctx.m);
927 md5_hash(&ctx.m, key_entry->key, key_entry->key_length);
928 md5_hash(&ctx.m, msg, hash_size);
929 md5_end(&ctx.m, output);
930 break;
931 default:
932 sha1_begin(&ctx.s);
933 sha1_hash(&ctx.s, key_entry->key, key_entry->key_length);
934 sha1_hash(&ctx.s, msg, hash_size);
935 sha1_end(&ctx.s, output);
936 break;
937 }
938}
939
940static void
941hash_peer(peer_t *p)
942{
943 p->p_xmt_msg.m_keyid = htonl(p->key_entry->id);
944 hash(p->key_entry, &p->p_xmt_msg, p->p_xmt_msg.m_digest);
945}
946
947static int
948hashes_differ(peer_t *p, const msg_t *msg)
949{
950 uint8_t digest[NTP_SHA1_DIGESTSIZE];
951 hash(p->key_entry, msg, digest);
952 return memcmp(digest, msg->m_digest, p->key_entry->msg_size - NTP_MSGSIZE_NOAUTH - KEYID_SIZE);
953}
954#endif
955
956static void
957send_query_to_peer(peer_t *p)
958{
959 if (!p->p_lsa)
960 return;
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978#define PROBE_LOCAL_ADDR
979
980 if (p->p_fd == -1) {
981 int fd, family;
982 len_and_sockaddr *local_lsa;
983
984 family = p->p_lsa->u.sa.sa_family;
985 p->p_fd = fd = xsocket_type(&local_lsa, family, SOCK_DGRAM);
986
987
988
989
990
991 PROBE_LOCAL_ADDR
992 xbind(fd, &local_lsa->u.sa, local_lsa->len);
993 PROBE_LOCAL_ADDR
994#if ENABLE_FEATURE_IPV6
995 if (family == AF_INET)
996#endif
997 setsockopt_int(fd, IPPROTO_IP, IP_TOS, IPTOS_DSCP_AF21);
998 free(local_lsa);
999 }
1000
1001
1002
1003
1004
1005 VERB1 bb_error_msg("sending query to %s", p->p_dotted);
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020 p->p_xmt_msg.m_xmttime.int_partl = rand();
1021 p->p_xmt_msg.m_xmttime.fractionl = rand();
1022 p->p_xmttime = gettime1900d();
1023
1024
1025
1026
1027
1028
1029
1030 p->reachable_bits <<= 1;
1031
1032#if ENABLE_FEATURE_NTP_AUTH
1033 if (p->key_entry)
1034 hash_peer(p);
1035 if (do_sendto(p->p_fd, NULL, &p->p_lsa->u.sa, p->p_lsa->len,
1036 &p->p_xmt_msg, !p->key_entry ? NTP_MSGSIZE_NOAUTH : p->key_entry->msg_size) == -1
1037 )
1038#else
1039 if (do_sendto(p->p_fd, NULL, &p->p_lsa->u.sa, p->p_lsa->len,
1040 &p->p_xmt_msg, NTP_MSGSIZE_NOAUTH) == -1
1041 )
1042#endif
1043 {
1044 close(p->p_fd);
1045 p->p_fd = -1;
1046
1047
1048
1049
1050
1051 set_next(p, RETRY_INTERVAL);
1052 return;
1053 }
1054
1055 set_next(p, RESPONSE_INTERVAL);
1056}
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066static void run_script(const char *action, double offset)
1067{
1068 char *argv[3];
1069 char *env1, *env2, *env3, *env4;
1070
1071 G.last_script_run = G.cur_time;
1072
1073 if (!G.script_name)
1074 return;
1075
1076 argv[0] = (char*) G.script_name;
1077 argv[1] = (char*) action;
1078 argv[2] = NULL;
1079
1080 VERB1 bb_error_msg("executing '%s %s'", G.script_name, action);
1081
1082 env1 = xasprintf("%s=%u", "stratum", G.stratum);
1083 putenv(env1);
1084 env2 = xasprintf("%s=%ld", "freq_drift_ppm", G.kernel_freq_drift);
1085 putenv(env2);
1086 env3 = xasprintf("%s=%u", "poll_interval", 1 << G.poll_exp);
1087 putenv(env3);
1088 env4 = xasprintf("%s=%f", "offset", offset);
1089 putenv(env4);
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099 spawn(argv);
1100
1101 unsetenv("stratum");
1102 unsetenv("freq_drift_ppm");
1103 unsetenv("poll_interval");
1104 unsetenv("offset");
1105 free(env1);
1106 free(env2);
1107 free(env3);
1108 free(env4);
1109}
1110
1111static NOINLINE void
1112step_time(double offset)
1113{
1114 llist_t *item;
1115 double dtime;
1116 struct timeval tvc, tvn;
1117 char buf[sizeof("yyyy-mm-dd hh:mm:ss") + 4];
1118 time_t tval;
1119
1120 gettimeofday(&tvc, NULL);
1121 dtime = tvc.tv_sec + (1.0e-6 * tvc.tv_usec) + offset;
1122 d_to_tv(dtime, &tvn);
1123 if (settimeofday(&tvn, NULL) == -1)
1124 bb_perror_msg_and_die("settimeofday");
1125
1126 VERB2 {
1127 tval = tvc.tv_sec;
1128 strftime_YYYYMMDDHHMMSS(buf, sizeof(buf), &tval);
1129 bb_error_msg("current time is %s.%06u", buf, (unsigned)tvc.tv_usec);
1130 }
1131 tval = tvn.tv_sec;
1132 strftime_YYYYMMDDHHMMSS(buf, sizeof(buf), &tval);
1133 bb_info_msg("setting time to %s.%06u (offset %+fs)", buf, (unsigned)tvn.tv_usec, offset);
1134
1135
1136
1137
1138
1139 G.cur_time += offset;
1140 G.last_update_recv_time += offset;
1141 G.last_script_run += offset;
1142
1143
1144 for (item = G.ntp_peers; item != NULL; item = item->link) {
1145 peer_t *pp = (peer_t *) item->data;
1146 reset_peer_stats(pp, offset);
1147
1148
1149 pp->next_action_time += offset;
1150 if (pp->p_fd >= 0) {
1151
1152
1153
1154
1155 close(pp->p_fd);
1156 pp->p_fd = -1;
1157 set_next(pp, RETRY_INTERVAL);
1158 }
1159 }
1160}
1161
1162static void clamp_pollexp_and_set_MAXSTRAT(void)
1163{
1164 if (G.poll_exp < MINPOLL)
1165 G.poll_exp = MINPOLL;
1166 if (G.poll_exp > BIGPOLL)
1167 G.poll_exp = BIGPOLL;
1168 G.polladj_count = 0;
1169 G.stratum = MAXSTRAT;
1170}
1171
1172
1173
1174
1175
1176typedef struct {
1177 peer_t *p;
1178 int type;
1179 double edge;
1180 double opt_rd;
1181} point_t;
1182static int
1183compare_point_edge(const void *aa, const void *bb)
1184{
1185 const point_t *a = aa;
1186 const point_t *b = bb;
1187 if (a->edge < b->edge) {
1188 return -1;
1189 }
1190 return (a->edge > b->edge);
1191}
1192typedef struct {
1193 peer_t *p;
1194 double metric;
1195} survivor_t;
1196static int
1197compare_survivor_metric(const void *aa, const void *bb)
1198{
1199 const survivor_t *a = aa;
1200 const survivor_t *b = bb;
1201 if (a->metric < b->metric) {
1202 return -1;
1203 }
1204 return (a->metric > b->metric);
1205}
1206static int
1207fit(peer_t *p, double rd)
1208{
1209 if ((p->reachable_bits & (p->reachable_bits-1)) == 0) {
1210
1211 VERB4 bb_error_msg("peer %s unfit for selection: "
1212 "unreachable", p->p_dotted);
1213 return 0;
1214 }
1215#if 0
1216 if ((p->lastpkt_status & LI_ALARM) == LI_ALARM
1217 || p->lastpkt_stratum >= MAXSTRAT
1218 ) {
1219 VERB4 bb_error_msg("peer %s unfit for selection: "
1220 "bad status/stratum", p->p_dotted);
1221 return 0;
1222 }
1223#endif
1224
1225 if (rd > MAXDIST + FREQ_TOLERANCE * (1 << G.poll_exp)) {
1226 VERB3 bb_error_msg("peer %s unfit for selection: "
1227 "root distance %f too high, jitter:%f",
1228 p->p_dotted, rd, p->filter_jitter
1229 );
1230 return 0;
1231 }
1232
1233
1234
1235
1236 return 1;
1237}
1238static peer_t*
1239select_and_cluster(void)
1240{
1241 peer_t *p;
1242 llist_t *item;
1243 int i, j;
1244 int size = 3 * G.peer_cnt;
1245
1246 point_t point[size];
1247 unsigned num_points, num_candidates;
1248 double low, high;
1249 unsigned num_falsetickers;
1250
1251 survivor_t survivor[size];
1252 unsigned num_survivors;
1253
1254
1255
1256 num_points = 0;
1257 item = G.ntp_peers;
1258 while (item != NULL) {
1259 double rd, offset;
1260
1261 p = (peer_t *) item->data;
1262 rd = root_distance(p);
1263 offset = p->filter_offset;
1264 if (!fit(p, rd)) {
1265 item = item->link;
1266 continue;
1267 }
1268
1269 VERB5 bb_error_msg("interval: [%f %f %f] %s",
1270 offset - rd,
1271 offset,
1272 offset + rd,
1273 p->p_dotted
1274 );
1275 point[num_points].p = p;
1276 point[num_points].type = -1;
1277 point[num_points].edge = offset - rd;
1278 point[num_points].opt_rd = rd;
1279 num_points++;
1280 point[num_points].p = p;
1281 point[num_points].type = 0;
1282 point[num_points].edge = offset;
1283 point[num_points].opt_rd = rd;
1284 num_points++;
1285 point[num_points].p = p;
1286 point[num_points].type = 1;
1287 point[num_points].edge = offset + rd;
1288 point[num_points].opt_rd = rd;
1289 num_points++;
1290 item = item->link;
1291 }
1292 num_candidates = num_points / 3;
1293 if (num_candidates == 0) {
1294 VERB3 bb_error_msg("no valid datapoints%s", ", no peer selected");
1295 return NULL;
1296 }
1297
1298 qsort(point, num_points, sizeof(point[0]), compare_point_edge);
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310 num_falsetickers = 0;
1311 while (1) {
1312 int c;
1313 unsigned num_midpoints = 0;
1314
1315 low = 1 << 9;
1316 high = - (1 << 9);
1317 c = 0;
1318 for (i = 0; i < num_points; i++) {
1319
1320
1321
1322
1323
1324 c -= point[i].type;
1325 if (c >= num_candidates - num_falsetickers) {
1326
1327 low = point[i].edge;
1328 break;
1329 }
1330 if (point[i].type == 0)
1331 num_midpoints++;
1332 }
1333 c = 0;
1334 for (i = num_points-1; i >= 0; i--) {
1335 c += point[i].type;
1336 if (c >= num_candidates - num_falsetickers) {
1337 high = point[i].edge;
1338 break;
1339 }
1340 if (point[i].type == 0)
1341 num_midpoints++;
1342 }
1343
1344
1345
1346
1347
1348 if (num_midpoints <= num_falsetickers && low < high)
1349 break;
1350 num_falsetickers++;
1351 if (num_falsetickers * 2 >= num_candidates) {
1352 VERB3 bb_error_msg("falsetickers:%d, candidates:%d%s",
1353 num_falsetickers, num_candidates,
1354 ", no peer selected");
1355 return NULL;
1356 }
1357 }
1358 VERB4 bb_error_msg("selected interval: [%f, %f]; candidates:%d falsetickers:%d",
1359 low, high, num_candidates, num_falsetickers);
1360
1361
1362
1363
1364
1365
1366
1367
1368 num_survivors = 0;
1369 for (i = 0; i < num_points; i++) {
1370 if (point[i].edge < low || point[i].edge > high)
1371 continue;
1372 p = point[i].p;
1373 survivor[num_survivors].p = p;
1374
1375 survivor[num_survivors].metric = MAXDIST * p->lastpkt_stratum + point[i].opt_rd;
1376 VERB5 bb_error_msg("survivor[%d] metric:%f peer:%s",
1377 num_survivors, survivor[num_survivors].metric, p->p_dotted);
1378 num_survivors++;
1379 }
1380
1381
1382
1383
1384
1385 if (num_survivors < MIN_SELECTED) {
1386 VERB3 bb_error_msg("survivors:%d%s",
1387 num_survivors,
1388 ", no peer selected");
1389 return NULL;
1390 }
1391
1392
1393
1394 qsort(survivor, num_survivors, sizeof(survivor[0]), compare_survivor_metric);
1395
1396
1397
1398
1399
1400
1401
1402 while (1) {
1403 unsigned max_idx = max_idx;
1404 double max_selection_jitter = max_selection_jitter;
1405 double min_jitter = min_jitter;
1406
1407 if (num_survivors <= MIN_CLUSTERED) {
1408 VERB4 bb_error_msg("num_survivors %d <= %d, not discarding more",
1409 num_survivors, MIN_CLUSTERED);
1410 break;
1411 }
1412
1413
1414
1415
1416
1417
1418 for (i = 0; i < num_survivors; i++) {
1419 double selection_jitter_sq;
1420
1421 p = survivor[i].p;
1422 if (i == 0 || p->filter_jitter < min_jitter)
1423 min_jitter = p->filter_jitter;
1424
1425 selection_jitter_sq = 0;
1426 for (j = 0; j < num_survivors; j++) {
1427 peer_t *q = survivor[j].p;
1428 selection_jitter_sq += SQUARE(p->filter_offset - q->filter_offset);
1429 }
1430 if (i == 0 || selection_jitter_sq > max_selection_jitter) {
1431 max_selection_jitter = selection_jitter_sq;
1432 max_idx = i;
1433 }
1434 VERB6 bb_error_msg("survivor %d selection_jitter^2:%f",
1435 i, selection_jitter_sq);
1436 }
1437 max_selection_jitter = SQRT(max_selection_jitter / num_survivors);
1438 VERB5 bb_error_msg("max_selection_jitter (at %d):%f min_jitter:%f",
1439 max_idx, max_selection_jitter, min_jitter);
1440
1441
1442
1443
1444
1445
1446 if (max_selection_jitter < min_jitter) {
1447 VERB4 bb_error_msg("max_selection_jitter:%f < min_jitter:%f, num_survivors:%d, not discarding more",
1448 max_selection_jitter, min_jitter, num_survivors);
1449 break;
1450 }
1451
1452
1453
1454
1455 VERB6 bb_error_msg("dropping survivor %d", max_idx);
1456 num_survivors--;
1457 while (max_idx < num_survivors) {
1458 survivor[max_idx] = survivor[max_idx + 1];
1459 max_idx++;
1460 }
1461 }
1462
1463 if (0) {
1464
1465
1466
1467
1468
1469
1470
1471
1472 double x, y, z, w;
1473 y = z = w = 0;
1474 for (i = 0; i < num_survivors; i++) {
1475 p = survivor[i].p;
1476 x = root_distance(p);
1477 y += 1 / x;
1478 z += p->filter_offset / x;
1479 w += SQUARE(p->filter_offset - survivor[0].p->filter_offset) / x;
1480 }
1481
1482
1483 }
1484
1485
1486
1487
1488
1489
1490 p = survivor[0].p;
1491 if (G.last_update_peer
1492 && G.last_update_peer->lastpkt_stratum <= p->lastpkt_stratum
1493 ) {
1494
1495 for (i = 1; i < num_survivors; i++) {
1496 if (G.last_update_peer == survivor[i].p) {
1497 VERB5 bb_error_msg("keeping old synced peer");
1498 p = G.last_update_peer;
1499 goto keep_old;
1500 }
1501 }
1502 }
1503 G.last_update_peer = p;
1504 keep_old:
1505 VERB4 bb_error_msg("selected peer %s filter_offset:%+f age:%f",
1506 p->p_dotted,
1507 p->filter_offset,
1508 G.cur_time - p->lastpkt_recv_time
1509 );
1510 return p;
1511}
1512
1513
1514
1515
1516
1517static void
1518set_new_values(int disc_state, double offset, double recv_time)
1519{
1520
1521
1522
1523
1524 VERB4 bb_error_msg("disc_state=%d last update offset=%f recv_time=%f",
1525 disc_state, offset, recv_time);
1526 G.discipline_state = disc_state;
1527 G.last_update_offset = offset;
1528 G.last_update_recv_time = recv_time;
1529}
1530
1531static NOINLINE int
1532update_local_clock(peer_t *p)
1533{
1534 int rc;
1535 struct timex tmx;
1536
1537 double offset = p->filter_offset;
1538 double recv_time = p->lastpkt_recv_time;
1539 double abs_offset;
1540#if !USING_KERNEL_PLL_LOOP
1541 double freq_drift;
1542#endif
1543#if !USING_KERNEL_PLL_LOOP || USING_INITIAL_FREQ_ESTIMATION
1544 double since_last_update;
1545#endif
1546 double etemp, dtemp;
1547
1548 abs_offset = fabs(offset);
1549
1550#if 0
1551
1552
1553
1554 if (abs_offset > PANIC_THRESHOLD) {
1555 bb_error_msg_and_die("offset %f far too big, exiting", offset);
1556 }
1557#endif
1558
1559
1560
1561
1562
1563 if (recv_time <= G.last_update_recv_time) {
1564 VERB3 bb_error_msg("update from %s: same or older datapoint, not using it",
1565 p->p_dotted);
1566 return 0;
1567 }
1568
1569
1570
1571
1572
1573#if !USING_KERNEL_PLL_LOOP || USING_INITIAL_FREQ_ESTIMATION
1574 since_last_update = recv_time - G.reftime;
1575#endif
1576#if !USING_KERNEL_PLL_LOOP
1577 freq_drift = 0;
1578#endif
1579#if USING_INITIAL_FREQ_ESTIMATION
1580 if (G.discipline_state == STATE_FREQ) {
1581
1582 if (since_last_update < WATCH_THRESHOLD) {
1583 VERB4 bb_error_msg("measuring drift, datapoint ignored, %f sec remains",
1584 WATCH_THRESHOLD - since_last_update);
1585 return 0;
1586 }
1587# if !USING_KERNEL_PLL_LOOP
1588 freq_drift = (offset - G.last_update_offset) / since_last_update;
1589# endif
1590 }
1591#endif
1592
1593
1594
1595
1596 if (abs_offset > STEP_THRESHOLD) {
1597#if 0
1598 double remains;
1599
1600
1601
1602
1603
1604
1605
1606 switch (G.discipline_state) {
1607 case STATE_SYNC:
1608
1609 VERB3 bb_error_msg("update from %s: offset:%+f, spike%s",
1610 p->p_dotted, offset,
1611 "");
1612 G.discipline_state = STATE_SPIK;
1613 return -1;
1614
1615 case STATE_SPIK:
1616
1617
1618
1619 remains = WATCH_THRESHOLD - since_last_update;
1620 if (remains > 0) {
1621 VERB3 bb_error_msg("update from %s: offset:%+f, spike%s",
1622 p->p_dotted, offset,
1623 ", datapoint ignored");
1624 return -1;
1625 }
1626
1627 }
1628#endif
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651 VERB4 bb_error_msg("stepping time by %+f; poll_exp=MINPOLL", offset);
1652 step_time(offset);
1653 if (option_mask32 & OPT_q) {
1654
1655 exit(0);
1656 }
1657
1658 clamp_pollexp_and_set_MAXSTRAT();
1659
1660 run_script("step", offset);
1661
1662 recv_time += offset;
1663
1664#if USING_INITIAL_FREQ_ESTIMATION
1665 if (G.discipline_state == STATE_NSET) {
1666 set_new_values(STATE_FREQ, 0, recv_time);
1667 return 1;
1668 }
1669#endif
1670 abs_offset = offset = 0;
1671 set_new_values(STATE_SYNC, offset, recv_time);
1672 } else {
1673
1674
1675
1676
1677 G.offset_to_jitter_ratio = abs_offset / G.discipline_jitter;
1678
1679
1680
1681
1682 etemp = SQUARE(G.discipline_jitter);
1683 dtemp = SQUARE(offset - G.last_update_offset);
1684 G.discipline_jitter = SQRT(etemp + (dtemp - etemp) / AVG);
1685 if (G.discipline_jitter < G_precision_sec)
1686 G.discipline_jitter = G_precision_sec;
1687
1688 switch (G.discipline_state) {
1689 case STATE_NSET:
1690 if (option_mask32 & OPT_q) {
1691
1692
1693
1694 exit(0);
1695 }
1696#if USING_INITIAL_FREQ_ESTIMATION
1697
1698
1699
1700
1701 set_new_values(STATE_FREQ, offset, recv_time);
1702#else
1703 set_new_values(STATE_SYNC, offset, recv_time);
1704#endif
1705 VERB4 bb_error_msg("transitioning to FREQ, datapoint ignored");
1706 return 0;
1707
1708#if 0
1709 case STATE_FSET:
1710
1711
1712
1713
1714 set_new_values(STATE_SYNC, offset, recv_time);
1715
1716 break;
1717#endif
1718
1719#if USING_INITIAL_FREQ_ESTIMATION
1720 case STATE_FREQ:
1721
1722
1723
1724
1725 set_new_values(STATE_SYNC, offset, recv_time);
1726 break;
1727#endif
1728
1729 default:
1730#if !USING_KERNEL_PLL_LOOP
1731
1732
1733
1734
1735
1736
1737
1738
1739 if ((1 << G.poll_exp) > ALLAN / 2) {
1740 etemp = FLL - G.poll_exp;
1741 if (etemp < AVG)
1742 etemp = AVG;
1743 freq_drift += (offset - G.last_update_offset) / (MAXD(since_last_update, ALLAN) * etemp);
1744 }
1745
1746
1747
1748
1749
1750 etemp = MIND(since_last_update, (1 << G.poll_exp));
1751 dtemp = (4 * PLL) << G.poll_exp;
1752 freq_drift += offset * etemp / SQUARE(dtemp);
1753#endif
1754 set_new_values(STATE_SYNC, offset, recv_time);
1755 break;
1756 }
1757 if (G.stratum != p->lastpkt_stratum + 1) {
1758 G.stratum = p->lastpkt_stratum + 1;
1759 run_script("stratum", offset);
1760 }
1761 }
1762
1763 G.reftime = G.cur_time;
1764 G.ntp_status = p->lastpkt_status;
1765 G.refid = p->lastpkt_refid;
1766 G.rootdelay = p->lastpkt_rootdelay + p->lastpkt_delay;
1767 dtemp = p->filter_jitter;
1768 dtemp += MAXD(p->filter_dispersion + FREQ_TOLERANCE * (G.cur_time - p->lastpkt_recv_time) + abs_offset, MINDISP);
1769 G.rootdisp = p->lastpkt_rootdisp + dtemp;
1770 VERB4 bb_error_msg("updating leap/refid/reftime/rootdisp from peer %s", p->p_dotted);
1771
1772
1773
1774
1775
1776
1777#if !USING_KERNEL_PLL_LOOP
1778
1779
1780
1781
1782
1783
1784 dtemp = G.discipline_freq_drift + freq_drift;
1785 G.discipline_freq_drift = MAXD(MIND(MAXDRIFT, dtemp), -MAXDRIFT);
1786 etemp = SQUARE(G.discipline_wander);
1787 dtemp = SQUARE(dtemp);
1788 G.discipline_wander = SQRT(etemp + (dtemp - etemp) / AVG);
1789
1790 VERB4 bb_error_msg("discipline freq_drift=%.9f(int:%ld corr:%e) wander=%f",
1791 G.discipline_freq_drift,
1792 (long)(G.discipline_freq_drift * 65536e6),
1793 freq_drift,
1794 G.discipline_wander);
1795#endif
1796 VERB4 {
1797 memset(&tmx, 0, sizeof(tmx));
1798 if (adjtimex(&tmx) < 0)
1799 bb_perror_msg_and_die("adjtimex");
1800 bb_error_msg("p adjtimex freq:%ld offset:%+ld status:0x%x tc:%ld",
1801 tmx.freq, tmx.offset, tmx.status, tmx.constant);
1802 }
1803
1804 memset(&tmx, 0, sizeof(tmx));
1805#if 0
1806
1807
1808
1809
1810 tmx.modes = ADJ_FREQUENCY | ADJ_OFFSET;
1811
1812 tmx.freq = G.discipline_freq_drift * 65536e6;
1813#endif
1814 tmx.modes = ADJ_OFFSET | ADJ_STATUS | ADJ_TIMECONST;
1815
1816 tmx.offset = (long)(offset * 1000000);
1817 if (SLEW_THRESHOLD < STEP_THRESHOLD) {
1818 if (tmx.offset > (long)(SLEW_THRESHOLD * 1000000)) {
1819 tmx.offset = (long)(SLEW_THRESHOLD * 1000000);
1820 }
1821 if (tmx.offset < -(long)(SLEW_THRESHOLD * 1000000)) {
1822 tmx.offset = -(long)(SLEW_THRESHOLD * 1000000);
1823 }
1824 }
1825
1826 tmx.status = STA_PLL;
1827 if (G.FREQHOLD_cnt != 0) {
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840 if (G.FREQHOLD_cnt < 0) {
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879 G.FREQHOLD_cnt = 1 + MIN_FREQHOLD + ((unsigned)(abs(tmx.offset)) >> 16);
1880 }
1881 G.FREQHOLD_cnt--;
1882 tmx.status |= STA_FREQHOLD;
1883 }
1884 if (G.ntp_status & LI_PLUSSEC)
1885 tmx.status |= STA_INS;
1886 if (G.ntp_status & LI_MINUSSEC)
1887 tmx.status |= STA_DEL;
1888
1889 tmx.constant = (int)G.poll_exp - 4;
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900 if (G.offset_to_jitter_ratio >= TIMECONST_HACK_GATE)
1901 tmx.constant--;
1902 if (tmx.constant < 0)
1903 tmx.constant = 0;
1904
1905
1906
1907 rc = adjtimex(&tmx);
1908 if (rc < 0)
1909 bb_perror_msg_and_die("adjtimex");
1910
1911
1912
1913 VERB4 bb_error_msg("adjtimex:%d freq:%ld offset:%+ld status:0x%x",
1914 rc, tmx.freq, tmx.offset, tmx.status);
1915 G.kernel_freq_drift = tmx.freq / 65536;
1916 VERB2 bb_error_msg("update from:%s offset:%+f delay:%f jitter:%f clock drift:%+.3fppm tc:%d",
1917 p->p_dotted,
1918 offset,
1919 p->p_raw_delay,
1920 G.discipline_jitter,
1921 (double)tmx.freq / 65536,
1922 (int)tmx.constant
1923 );
1924
1925 return 1;
1926}
1927
1928
1929
1930
1931
1932
1933static unsigned
1934poll_interval(int upper_bound)
1935{
1936 unsigned interval, r, mask;
1937 interval = 1 << G.poll_exp;
1938 if (interval > upper_bound)
1939 interval = upper_bound;
1940 mask = ((interval-1) >> 4) | 1;
1941 r = rand();
1942 interval += r & mask;
1943 VERB4 bb_error_msg("chose poll interval:%u (poll_exp:%d)", interval, G.poll_exp);
1944 return interval;
1945}
1946static void
1947adjust_poll(int count)
1948{
1949 G.polladj_count += count;
1950 if (G.polladj_count > POLLADJ_LIMIT) {
1951 G.polladj_count = 0;
1952 if (G.poll_exp < MAXPOLL) {
1953 G.poll_exp++;
1954 VERB4 bb_error_msg("polladj: discipline_jitter:%f ++poll_exp=%d",
1955 G.discipline_jitter, G.poll_exp);
1956 }
1957 } else if (G.polladj_count < -POLLADJ_LIMIT || (count < 0 && G.poll_exp > BIGPOLL)) {
1958 G.polladj_count = 0;
1959 if (G.poll_exp > MINPOLL) {
1960 llist_t *item;
1961
1962 G.poll_exp--;
1963
1964
1965
1966
1967
1968
1969 for (item = G.ntp_peers; item != NULL; item = item->link) {
1970 peer_t *pp = (peer_t *) item->data;
1971 if (pp->p_fd < 0)
1972 pp->next_action_time -= (1 << G.poll_exp);
1973 }
1974 VERB4 bb_error_msg("polladj: discipline_jitter:%f --poll_exp=%d",
1975 G.discipline_jitter, G.poll_exp);
1976 }
1977 } else {
1978 VERB4 bb_error_msg("polladj: count:%d", G.polladj_count);
1979 }
1980}
1981static NOINLINE void
1982recv_and_process_peer_pkt(peer_t *p)
1983{
1984 int rc;
1985 ssize_t size;
1986 msg_t msg;
1987 double T1, T2, T3, T4;
1988 double offset;
1989 double prev_delay, delay;
1990 unsigned interval;
1991 datapoint_t *datapoint;
1992 peer_t *q;
1993
1994 offset = 0;
1995
1996
1997
1998
1999
2000 recv_again:
2001 size = recv(p->p_fd, &msg, sizeof(msg), MSG_DONTWAIT);
2002 if (size < 0) {
2003 if (errno == EINTR)
2004
2005 goto recv_again;
2006 if (errno == EAGAIN)
2007
2008
2009
2010
2011 return;
2012
2013
2014
2015
2016 bb_perror_msg_and_die("recv(%s) error", p->p_dotted);
2017 }
2018
2019#if ENABLE_FEATURE_NTP_AUTH
2020 if (size != NTP_MSGSIZE_NOAUTH && size != NTP_MSGSIZE_MD5_AUTH && size != NTP_MSGSIZE_SHA1_AUTH) {
2021 bb_error_msg("malformed packet received from %s", p->p_dotted);
2022 return;
2023 }
2024 if (p->key_entry && hashes_differ(p, &msg)) {
2025 bb_error_msg("invalid cryptographic hash received from %s", p->p_dotted);
2026 return;
2027 }
2028#else
2029 if (size != NTP_MSGSIZE_NOAUTH && size != NTP_MSGSIZE_MD5_AUTH) {
2030 bb_error_msg("malformed packet received from %s", p->p_dotted);
2031 return;
2032 }
2033#endif
2034
2035 if (msg.m_orgtime.int_partl != p->p_xmt_msg.m_xmttime.int_partl
2036 || msg.m_orgtime.fractionl != p->p_xmt_msg.m_xmttime.fractionl
2037 ) {
2038
2039 return;
2040 }
2041
2042
2043
2044
2045
2046 close(p->p_fd);
2047 p->p_fd = -1;
2048
2049 if ((msg.m_status & LI_ALARM) == LI_ALARM
2050 || msg.m_stratum == 0
2051 || msg.m_stratum > NTP_MAXSTRATUM
2052 ) {
2053 bb_error_msg("reply from %s: peer is unsynced", p->p_dotted);
2054
2055
2056
2057
2058
2059
2060 if (G.poll_exp < BIGPOLL)
2061 goto increase_interval;
2062 goto pick_normal_interval;
2063 }
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083 T1 = p->p_xmttime;
2084 T2 = lfp_to_d(msg.m_rectime);
2085 T3 = lfp_to_d(msg.m_xmttime);
2086 T4 = G.cur_time;
2087 delay = (T4 - T1) - (T3 - T2);
2088
2089
2090
2091
2092
2093 prev_delay = p->p_raw_delay;
2094 p->p_raw_delay = (delay < 0 ? 0.0 : delay);
2095 if (p->reachable_bits
2096 && delay > prev_delay * BAD_DELAY_GROWTH
2097 && delay > 1.0 / (8 * 1024)
2098 ) {
2099 bb_error_msg("reply from %s: delay %f is too high, ignoring", p->p_dotted, delay);
2100 goto pick_normal_interval;
2101 }
2102
2103
2104
2105
2106
2107
2108
2109 if (delay < G_precision_sec)
2110 delay = G_precision_sec;
2111 p->lastpkt_delay = delay;
2112 p->lastpkt_recv_time = T4;
2113 VERB6 bb_error_msg("%s->lastpkt_recv_time=%f", p->p_dotted, p->lastpkt_recv_time);
2114 p->lastpkt_status = msg.m_status;
2115 p->lastpkt_stratum = msg.m_stratum;
2116 p->lastpkt_rootdelay = sfp_to_d(msg.m_rootdelay);
2117 p->lastpkt_rootdisp = sfp_to_d(msg.m_rootdisp);
2118 p->lastpkt_refid = msg.m_refid;
2119
2120 p->datapoint_idx = p->reachable_bits ? (p->datapoint_idx + 1) % NUM_DATAPOINTS : 0;
2121 datapoint = &p->filter_datapoint[p->datapoint_idx];
2122 datapoint->d_recv_time = T4;
2123 datapoint->d_offset = offset = ((T2 - T1) + (T3 - T4)) / 2;
2124 datapoint->d_dispersion = LOG2D(msg.m_precision_exp) + G_precision_sec;
2125 if (!p->reachable_bits) {
2126
2127 int i;
2128 for (i = 0; i < NUM_DATAPOINTS; i++) {
2129 p->filter_datapoint[i].d_offset = offset;
2130 }
2131 }
2132
2133 p->reachable_bits |= 1;
2134 if ((MAX_VERBOSE && G.verbose) || (option_mask32 & OPT_w)) {
2135 bb_info_msg("reply from %s: offset:%+f delay:%f status:0x%02x strat:%d refid:0x%08x rootdelay:%f reach:0x%02x",
2136 p->p_dotted,
2137 offset,
2138 p->p_raw_delay,
2139 p->lastpkt_status,
2140 p->lastpkt_stratum,
2141 p->lastpkt_refid,
2142 p->lastpkt_rootdelay,
2143 p->reachable_bits
2144
2145
2146
2147 );
2148 }
2149
2150
2151 filter_datapoints(p);
2152 q = select_and_cluster();
2153 rc = 0;
2154 if (q) {
2155 if (!(option_mask32 & OPT_w)) {
2156 rc = update_local_clock(q);
2157#if 0
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169 if (fabs(q->filter_offset) >= POLLDOWN_OFFSET) {
2170 VERB4 bb_error_msg("offset:%+f > POLLDOWN_OFFSET", q->filter_offset);
2171 adjust_poll(-POLLADJ_LIMIT * 3);
2172 rc = 0;
2173 }
2174#endif
2175 }
2176 } else {
2177
2178
2179
2180 if (G.poll_exp < BIGPOLL)
2181 goto increase_interval;
2182 }
2183
2184 if (rc != 0) {
2185
2186
2187
2188
2189
2190
2191 if (rc > 0 && G.offset_to_jitter_ratio <= POLLADJ_GATE) {
2192
2193
2194 increase_interval:
2195 adjust_poll(MINPOLL);
2196 } else {
2197 VERB3 if (rc > 0)
2198 bb_error_msg("want smaller interval: offset/jitter = %u",
2199 G.offset_to_jitter_ratio);
2200 adjust_poll(-G.poll_exp * 2);
2201 }
2202 }
2203
2204
2205 pick_normal_interval:
2206 interval = poll_interval(INT_MAX);
2207 if (fabs(offset) >= BIGOFF && interval > BIGOFF_INTERVAL) {
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219 interval = BIGOFF_INTERVAL;
2220 }
2221
2222 set_next(p, interval);
2223}
2224
2225#if ENABLE_FEATURE_NTPD_SERVER
2226static NOINLINE void
2227recv_and_process_client_pkt(void )
2228{
2229 ssize_t size;
2230
2231 len_and_sockaddr *to;
2232 struct sockaddr *from;
2233 msg_t msg;
2234 uint8_t query_status;
2235 l_fixedpt_t query_xmttime;
2236
2237 to = get_sock_lsa(G_listen_fd);
2238 from = xzalloc(to->len);
2239
2240 size = recv_from_to(G_listen_fd, &msg, sizeof(msg), MSG_DONTWAIT, from, &to->u.sa, to->len);
2241#if ENABLE_FEATURE_NTP_AUTH
2242 if (size != NTP_MSGSIZE_NOAUTH && size != NTP_MSGSIZE_MD5_AUTH && size != NTP_MSGSIZE_SHA1_AUTH)
2243#else
2244 if (size != NTP_MSGSIZE_NOAUTH && size != NTP_MSGSIZE_MD5_AUTH)
2245#endif
2246 {
2247 char *addr;
2248 if (size < 0) {
2249 if (errno == EAGAIN)
2250 goto bail;
2251 bb_perror_msg_and_die("recv");
2252 }
2253 addr = xmalloc_sockaddr2dotted_noport(from);
2254 bb_error_msg("malformed packet received from %s: size %u", addr, (int)size);
2255 free(addr);
2256 goto bail;
2257 }
2258
2259
2260 if ((msg.m_status & MODE_MASK) != MODE_CLIENT
2261 && (msg.m_status & MODE_MASK) != MODE_SYM_ACT
2262 ) {
2263 goto bail;
2264 }
2265
2266 query_status = msg.m_status;
2267 query_xmttime = msg.m_xmttime;
2268
2269
2270 memset(&msg, 0, sizeof(msg));
2271 msg.m_status = G.stratum < MAXSTRAT ? (G.ntp_status & LI_MASK) : LI_ALARM;
2272 msg.m_status |= (query_status & VERSION_MASK);
2273 msg.m_status |= ((query_status & MODE_MASK) == MODE_CLIENT) ?
2274 MODE_SERVER : MODE_SYM_PAS;
2275 msg.m_stratum = G.stratum;
2276 msg.m_ppoll = G.poll_exp;
2277 msg.m_precision_exp = G_precision_exp;
2278
2279 msg.m_rectime = d_to_lfp(G.cur_time);
2280 msg.m_xmttime = d_to_lfp(gettime1900d());
2281 if (G.peer_cnt == 0) {
2282
2283 G.reftime = G.cur_time;
2284 }
2285 msg.m_reftime = d_to_lfp(G.reftime);
2286 msg.m_orgtime = query_xmttime;
2287 msg.m_rootdelay = d_to_sfp(G.rootdelay);
2288
2289 msg.m_rootdisp = d_to_sfp(G.rootdisp);
2290
2291 msg.m_refid = G.refid;
2292
2293
2294
2295 do_sendto(G_listen_fd,
2296 &to->u.sa, from, to->len,
2297 &msg, size);
2298
2299 bail:
2300 free(to);
2301 free(from);
2302}
2303#endif
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389#if ENABLE_FEATURE_NTP_AUTH
2390static key_entry_t *
2391find_key_entry(llist_t *key_entries, unsigned id)
2392{
2393 while (key_entries) {
2394 key_entry_t *cur = (key_entry_t*) key_entries->data;
2395 if (cur->id == id)
2396 return cur;
2397 key_entries = key_entries->link;
2398 }
2399 bb_error_msg_and_die("key %u is not defined", id);
2400}
2401#endif
2402
2403
2404
2405
2406static NOINLINE void ntp_init(char **argv)
2407{
2408 unsigned opts;
2409 llist_t *peers;
2410#if ENABLE_FEATURE_NTP_AUTH
2411 llist_t *key_entries;
2412 char *key_file_path;
2413#endif
2414
2415 srand(getpid());
2416
2417 if (getuid())
2418 bb_error_msg_and_die(bb_msg_you_must_be_root);
2419
2420
2421 G.discipline_jitter = G_precision_sec;
2422 G.stratum = MAXSTRAT;
2423 if (BURSTPOLL != 0)
2424 G.poll_exp = BURSTPOLL;
2425 G.last_script_run = G.reftime = G.last_update_recv_time = gettime1900d();
2426 G.FREQHOLD_cnt = -1;
2427
2428
2429 peers = NULL;
2430 IF_FEATURE_NTP_AUTH(key_entries = NULL;)
2431 opts = getopt32(argv, "^"
2432 "nqNx"
2433 IF_FEATURE_NTP_AUTH("k:")
2434 "wp:*S:"IF_FEATURE_NTPD_SERVER("l")
2435 IF_FEATURE_NTPD_SERVER("I:")
2436 "d"
2437 "46aAbgL"
2438 "\0"
2439 "dd:wn"
2440 IF_FEATURE_NTPD_SERVER(":Il")
2441 IF_FEATURE_NTP_AUTH(, &key_file_path)
2442 , &peers, &G.script_name
2443 IF_FEATURE_NTPD_SERVER(, &G.if_name)
2444 , &G.verbose
2445 );
2446
2447
2448
2449
2450#if ENABLE_FEATURE_NTPD_SERVER
2451 G_listen_fd = -1;
2452 if (opts & OPT_l) {
2453 G_listen_fd = create_and_bind_dgram_or_die(NULL, 123);
2454 if (G.if_name) {
2455 if (setsockopt_bindtodevice(G_listen_fd, G.if_name))
2456 xfunc_die();
2457 }
2458 socket_want_pktinfo(G_listen_fd);
2459 setsockopt_int(G_listen_fd, IPPROTO_IP, IP_TOS, IPTOS_DSCP_AF21);
2460 }
2461#endif
2462
2463 if (opts & OPT_N)
2464 setpriority(PRIO_PROCESS, 0, -15);
2465
2466 if (!(opts & OPT_n)) {
2467 bb_daemonize_or_rexec(DAEMON_DEVNULL_STDIO, argv);
2468 logmode = LOGMODE_NONE;
2469 }
2470
2471#if ENABLE_FEATURE_NTP_AUTH
2472 if (opts & OPT_k) {
2473 char *tokens[4];
2474 parser_t *parser;
2475
2476 parser = config_open(key_file_path);
2477 while (config_read(parser, tokens, 4, 3, "# \t", PARSE_NORMAL | PARSE_MIN_DIE) == 3) {
2478 key_entry_t *key_entry;
2479 char buffer[40];
2480 smalluint hash_type;
2481 smalluint msg_size;
2482 smalluint key_length;
2483 char *key;
2484
2485 if ((tokens[1][0] | 0x20) == 'm')
2486
2487 hash_type = HASH_MD5;
2488 else
2489 if (strncasecmp(tokens[1], "sha", 3) == 0)
2490
2491 hash_type = HASH_SHA1;
2492 else
2493 bb_error_msg_and_die("only MD5 and SHA1 keys supported");
2494
2495
2496
2497
2498
2499
2500
2501
2502 key_length = strnlen(tokens[2], sizeof(buffer)+1);
2503 if (key_length >= sizeof(buffer)+1) {
2504 err:
2505 bb_error_msg_and_die("malformed key at line %u", parser->lineno);
2506 }
2507 if (hash_type == HASH_MD5) {
2508 key = tokens[2];
2509 msg_size = NTP_MSGSIZE_MD5_AUTH;
2510 } else
2511 if (!(key_length & 1)) {
2512 key_length >>= 1;
2513 if (!hex2bin(buffer, tokens[2], key_length))
2514 goto err;
2515 key = buffer;
2516 msg_size = NTP_MSGSIZE_SHA1_AUTH;
2517 } else {
2518 goto err;
2519 }
2520 key_entry = xzalloc(sizeof(*key_entry) + key_length);
2521 key_entry->type = hash_type;
2522 key_entry->msg_size = msg_size;
2523 key_entry->key_length = key_length;
2524 memcpy(key_entry->key, key, key_length);
2525 key_entry->id = xatou_range(tokens[0], 1, MAX_KEY_NUMBER);
2526 llist_add_to(&key_entries, key_entry);
2527 }
2528 config_close(parser);
2529 }
2530#endif
2531 if (peers) {
2532#if ENABLE_FEATURE_NTP_AUTH
2533 while (peers) {
2534 char *peer = llist_pop(&peers);
2535 key_entry_t *key_entry = NULL;
2536 if (strncmp(peer, "keyno:", 6) == 0) {
2537 char *end;
2538 int key_id;
2539 peer += 6;
2540 end = strchr(peer, ':');
2541 if (!end) bb_show_usage();
2542 *end = '\0';
2543 key_id = xatou_range(peer, 1, MAX_KEY_NUMBER);
2544 *end = ':';
2545 key_entry = find_key_entry(key_entries, key_id);
2546 peer = end + 1;
2547 }
2548 add_peers(peer, key_entry);
2549 }
2550#else
2551 while (peers)
2552 add_peers(llist_pop(&peers), NULL);
2553#endif
2554 }
2555#if ENABLE_FEATURE_NTPD_CONF
2556 else {
2557 parser_t *parser;
2558 char *token[3 + 2*ENABLE_FEATURE_NTP_AUTH];
2559
2560 parser = config_open("/etc/ntp.conf");
2561 while (config_read(parser, token, 3 + 2*ENABLE_FEATURE_NTP_AUTH, 1, "# \t", PARSE_NORMAL)) {
2562 if (strcmp(token[0], "server") == 0 && token[1]) {
2563# if ENABLE_FEATURE_NTP_AUTH
2564 key_entry_t *key_entry = NULL;
2565 if (token[2] && token[3] && strcmp(token[2], "key") == 0) {
2566 unsigned key_id = xatou_range(token[3], 1, MAX_KEY_NUMBER);
2567 key_entry = find_key_entry(key_entries, key_id);
2568 }
2569 add_peers(token[1], key_entry);
2570# else
2571 add_peers(token[1], NULL);
2572# endif
2573 continue;
2574 }
2575 bb_error_msg("skipping %s:%u: unimplemented command '%s'",
2576 "/etc/ntp.conf", parser->lineno, token[0]
2577 );
2578 }
2579 config_close(parser);
2580 }
2581#endif
2582 if (G.peer_cnt == 0) {
2583 if (!(opts & OPT_l))
2584 bb_show_usage();
2585
2586 G.stratum = 1;
2587 }
2588
2589 if (!(opts & OPT_n))
2590 write_pidfile_std_path_and_ext("ntpd");
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601 if (opts & OPT_q) {
2602 option_mask32 |= OPT_qq;
2603 alarm(10);
2604 }
2605
2606 bb_signals(0
2607 | (1 << SIGTERM)
2608 | (1 << SIGINT)
2609 | (1 << SIGALRM)
2610 , record_signo
2611 );
2612 bb_signals(0
2613 | (1 << SIGPIPE)
2614 | (1 << SIGCHLD)
2615 , SIG_IGN
2616 );
2617
2618}
2619
2620int ntpd_main(int argc UNUSED_PARAM, char **argv) MAIN_EXTERNALLY_VISIBLE;
2621int ntpd_main(int argc UNUSED_PARAM, char **argv)
2622{
2623#undef G
2624 struct globals G;
2625 struct pollfd *pfd;
2626 peer_t **idx2peer;
2627 unsigned cnt;
2628
2629 memset(&G, 0, sizeof(G));
2630 SET_PTR_TO_GLOBALS(&G);
2631
2632 ntp_init(argv);
2633
2634
2635 cnt = G.peer_cnt + ENABLE_FEATURE_NTPD_SERVER;
2636 idx2peer = xzalloc(sizeof(idx2peer[0]) * cnt);
2637 pfd = xzalloc(sizeof(pfd[0]) * cnt);
2638
2639
2640
2641
2642
2643
2644
2645
2646 cnt = G.peer_cnt * (INITIAL_SAMPLES + 1);
2647
2648 while (!bb_got_signal) {
2649 llist_t *item;
2650 unsigned i, j;
2651 int nfds, timeout;
2652 double nextaction;
2653
2654
2655
2656 nextaction = G.last_script_run + (11*60);
2657 if (nextaction < G.cur_time + 1)
2658 nextaction = G.cur_time + 1;
2659
2660 i = 0;
2661#if ENABLE_FEATURE_NTPD_SERVER
2662 if (G_listen_fd != -1) {
2663 pfd[0].fd = G_listen_fd;
2664 pfd[0].events = POLLIN;
2665 i++;
2666 }
2667#endif
2668
2669 for (item = G.ntp_peers; item != NULL; item = item->link) {
2670 peer_t *p = (peer_t *) item->data;
2671
2672 if (p->next_action_time <= G.cur_time) {
2673 if (p->p_fd == -1) {
2674
2675 if (--cnt == 0) {
2676 VERB4 bb_error_msg("disabling burst mode");
2677 G.polladj_count = 0;
2678 G.poll_exp = MINPOLL;
2679 }
2680 send_query_to_peer(p);
2681 } else {
2682
2683 close(p->p_fd);
2684 p->p_fd = -1;
2685
2686 if (G.poll_exp < BIGPOLL)
2687 adjust_poll(MINPOLL);
2688 timeout = poll_interval(NOREPLY_INTERVAL);
2689 bb_error_msg("timed out waiting for %s, reach 0x%02x, next query in %us",
2690 p->p_dotted, p->reachable_bits, timeout);
2691
2692
2693 if (p->reachable_bits == 0)
2694 resolve_peer_hostname(p);
2695
2696 set_next(p, timeout);
2697 }
2698 }
2699
2700 if (p->next_action_time < nextaction)
2701 nextaction = p->next_action_time;
2702
2703 if (p->p_fd >= 0) {
2704
2705 pfd[i].fd = p->p_fd;
2706 pfd[i].events = POLLIN;
2707 idx2peer[i] = p;
2708 i++;
2709 }
2710 }
2711
2712 timeout = nextaction - G.cur_time;
2713 if (timeout < 0)
2714 timeout = 0;
2715 timeout++;
2716
2717
2718 VERB2 {
2719 if (i > (ENABLE_FEATURE_NTPD_SERVER && G_listen_fd != -1)) {
2720
2721
2722
2723
2724
2725 nfds = poll(pfd, i, 1000);
2726 if (nfds != 0)
2727 goto did_poll;
2728 if (--timeout <= 0)
2729 goto did_poll;
2730 }
2731 bb_error_msg("poll:%us sockets:%u interval:%us", timeout, i, 1 << G.poll_exp);
2732 }
2733 nfds = poll(pfd, i, timeout * 1000);
2734 did_poll:
2735 gettime1900d();
2736 if (nfds <= 0) {
2737 double ct;
2738 int dns_error;
2739
2740 if (bb_got_signal)
2741 break;
2742
2743 if (G.cur_time - G.last_script_run > 11*60) {
2744
2745 run_script("periodic", G.last_update_offset);
2746 gettime1900d();
2747 }
2748
2749
2750
2751
2752
2753
2754 dns_error = 0;
2755 ct = G.cur_time;
2756 for (item = G.ntp_peers; item != NULL; item = item->link) {
2757 peer_t *p = (peer_t *) item->data;
2758 if (p->next_action_time <= ct && !p->p_lsa) {
2759
2760 dns_error |= (!resolve_peer_hostname(p));
2761 }
2762 }
2763 if (!dns_error)
2764 goto check_unsync;
2765
2766 gettime1900d();
2767 for (item = G.ntp_peers; item != NULL; item = item->link) {
2768 peer_t *p = (peer_t *) item->data;
2769 if (p->next_action_time <= ct && !p->p_lsa) {
2770 set_next(p, HOSTNAME_INTERVAL * p->dns_errors);
2771 }
2772 }
2773 goto check_unsync;
2774 }
2775
2776
2777 j = 0;
2778#if ENABLE_FEATURE_NTPD_SERVER
2779 if (G.listen_fd != -1) {
2780 if (pfd[0].revents ) {
2781 nfds--;
2782 recv_and_process_client_pkt();
2783 gettime1900d();
2784 }
2785 j = 1;
2786 }
2787#endif
2788 for (; nfds != 0 && j < i; j++) {
2789 if (pfd[j].revents ) {
2790
2791
2792
2793
2794
2795 if (option_mask32 & OPT_qq) {
2796 option_mask32 &= ~OPT_qq;
2797 alarm(50);
2798 }
2799 nfds--;
2800 recv_and_process_peer_pkt(idx2peer[j]);
2801 gettime1900d();
2802 }
2803 }
2804
2805 check_unsync:
2806 if (G.ntp_peers && G.stratum != MAXSTRAT) {
2807 for (item = G.ntp_peers; item != NULL; item = item->link) {
2808 peer_t *p = (peer_t *) item->data;
2809 if (p->reachable_bits)
2810 goto have_reachable_peer;
2811 }
2812
2813 clamp_pollexp_and_set_MAXSTRAT();
2814 run_script("unsync", 0.0);
2815 have_reachable_peer: ;
2816 }
2817 }
2818
2819 remove_pidfile_std_path_and_ext("ntpd");
2820 kill_myself_with_sig(bb_got_signal);
2821}
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832#if 0
2833static double
2834direct_freq(double fp_offset)
2835{
2836#ifdef KERNEL_PLL
2837
2838
2839
2840
2841 if (pll_control && kern_enable) {
2842 memset(&ntv, 0, sizeof(ntv));
2843 ntp_adjtime(&ntv);
2844#ifdef STA_NANO
2845 clock_offset = ntv.offset / 1e9;
2846#else
2847 clock_offset = ntv.offset / 1e6;
2848#endif
2849 drift_comp = FREQTOD(ntv.freq);
2850 }
2851#endif
2852 set_freq((fp_offset - clock_offset) / (current_time - clock_epoch) + drift_comp);
2853 wander_resid = 0;
2854 return drift_comp;
2855}
2856
2857static void
2858set_freq(double freq)
2859{
2860 char tbuf[80];
2861
2862 drift_comp = freq;
2863
2864#ifdef KERNEL_PLL
2865
2866
2867
2868 if (pll_control && kern_enable) {
2869 memset(&ntv, 0, sizeof(ntv));
2870 ntv.modes = MOD_FREQUENCY;
2871 ntv.freq = DTOFREQ(drift_comp);
2872 ntp_adjtime(&ntv);
2873 snprintf(tbuf, sizeof(tbuf), "kernel %.3f PPM", drift_comp * 1e6);
2874 report_event(EVNT_FSET, NULL, tbuf);
2875 } else {
2876 snprintf(tbuf, sizeof(tbuf), "ntpd %.3f PPM", drift_comp * 1e6);
2877 report_event(EVNT_FSET, NULL, tbuf);
2878 }
2879#else
2880 snprintf(tbuf, sizeof(tbuf), "ntpd %.3f PPM", drift_comp * 1e6);
2881 report_event(EVNT_FSET, NULL, tbuf);
2882#endif
2883}
2884
2885...
2886...
2887...
2888
2889#ifdef KERNEL_PLL
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905 if (pll_control && kern_enable) {
2906
2907#define MOD_BITS (MOD_OFFSET | MOD_MAXERROR | MOD_ESTERROR | MOD_STATUS | MOD_TIMECONST)
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920 memset(&ntv, 0, sizeof(ntv));
2921 if (ext_enable) {
2922 ntv.modes = MOD_STATUS;
2923 } else {
2924#ifdef STA_NANO
2925 ntv.modes = MOD_BITS | MOD_NANO;
2926#else
2927 ntv.modes = MOD_BITS;
2928#endif
2929 if (clock_offset < 0)
2930 dtemp = -.5;
2931 else
2932 dtemp = .5;
2933#ifdef STA_NANO
2934 ntv.offset = (int32)(clock_offset * 1e9 + dtemp);
2935 ntv.constant = sys_poll;
2936#else
2937 ntv.offset = (int32)(clock_offset * 1e6 + dtemp);
2938 ntv.constant = sys_poll - 4;
2939#endif
2940 ntv.esterror = (u_int32)(clock_jitter * 1e6);
2941 ntv.maxerror = (u_int32)((sys_rootdelay / 2 + sys_rootdisp) * 1e6);
2942 ntv.status = STA_PLL;
2943
2944
2945
2946
2947 if (pps_enable) {
2948 if (!(pll_status & STA_PPSTIME))
2949 report_event(EVNT_KERN,
2950 NULL, "PPS enabled");
2951 ntv.status |= STA_PPSTIME | STA_PPSFREQ;
2952 } else {
2953 if (pll_status & STA_PPSTIME)
2954 report_event(EVNT_KERN,
2955 NULL, "PPS disabled");
2956 ntv.status &= ~(STA_PPSTIME | STA_PPSFREQ);
2957 }
2958 if (sys_leap == LEAP_ADDSECOND)
2959 ntv.status |= STA_INS;
2960 else if (sys_leap == LEAP_DELSECOND)
2961 ntv.status |= STA_DEL;
2962 }
2963
2964
2965
2966
2967
2968
2969 if (ntp_adjtime(&ntv) == TIME_ERROR) {
2970 if (!(ntv.status & STA_PPSSIGNAL))
2971 report_event(EVNT_KERN, NULL,
2972 "PPS no signal");
2973 }
2974 pll_status = ntv.status;
2975#ifdef STA_NANO
2976 clock_offset = ntv.offset / 1e9;
2977#else
2978 clock_offset = ntv.offset / 1e6;
2979#endif
2980 clock_frequency = FREQTOD(ntv.freq);
2981
2982
2983
2984
2985 if (ntv.status & STA_PPSTIME) {
2986#ifdef STA_NANO
2987 clock_jitter = ntv.jitter / 1e9;
2988#else
2989 clock_jitter = ntv.jitter / 1e6;
2990#endif
2991 }
2992
2993#if defined(STA_NANO) && NTP_API == 4
2994
2995
2996
2997 if (loop_tai != sys_tai) {
2998 loop_tai = sys_tai;
2999 ntv.modes = MOD_TAI;
3000 ntv.constant = sys_tai;
3001 ntp_adjtime(&ntv);
3002 }
3003#endif
3004 }
3005#endif
3006#endif
3007