![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ntptimeset.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpdate|
Return to ntptimeset.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpdate |
1.1 misho 1: /*
2: * ntptimeset - get/set the time via ntp
3: *
4: * GOAL:
5: * The goal of ntptime is to set the current time on system startup
6: * to the best possible time using the network very wisely. It is assumed
7: * that after a resonable time has been sett then ntp daemon will
8: * maintain it.
9: *
10: * PROBLEM DOMAIN:
11: * We have three sets of issues related to acheiving the goal. The first
12: * issue is using the network when normal traffic is happening or when
13: * the entire network world is recovering from a campus wide power failure
14: * and is restarting. The second issue is the class of machine whether it
15: * is a user's office workstation being handled by an uneducated user or
16: * a server computer being handled by a trained operations staff. The third
17: * issue is whether the ratio of people to computers and whether the
18: * environment is stable and viable or not.
19: *
20: * NETWORK USAGE:
21: * The first issue of using the network wisely is a question of whether
22: * the network load and time server load and state are normal. If things
23: * are normal ntptime can do what ntpdate does of sending out 4 packets
24: * quickly to each server (new transmit done with each ack). However
25: * if network or time load is high then this scheme will simply contribute
26: * to problems. Given we have minimal state, we simply weight lost packets
27: * significantly and make sure we throttle output as much as possible
28: * without performance lost for quick startups.
29: *
30: * TRAINING AND KNOWLEDGE:
31: * The second issue of uneducated user of a office workstation versus a
32: * trained operation staff of a server machine translates into simply an
33: * issue of untrained and trained users.
34: *
35: * The training issue implies that for the sake of the users involved in the
36: * handling of their office workstation, problems and options should be
37: * communicated simply and effectively and not in terse expert related
38: * descriptions without possible options to be taken. The operator's training
39: * and education enables them to deal with either type of communication and
40: * control.
41: *
42: * AUTOMATION AND MANUAL CONTROL:
43: * The last issue boils down to a design problem. If the design tends to go
44: * into a manual mode when the environment is non-viable then one person
45: * handling many computers all at the same time will be heavily impacted. On
46: * the other hand, if the design tends to be automatic and does not indicate
47: * a way for the user to take over control then the computer will be
48: * unavailable for the user until the proble is resolved by someone else or
49: * the user.
50: *
51: * NOTE: Please do not have this program print out every minute some line,
52: * of output. If this happens and the environment is in trouble then
53: * many pages of paper on many different machines will be filled up.
54: * Save some tress in your lifetime.
55: *
56: * CONCLUSION:
57: * The behavior of the program derived from these three issues should be
58: * that during normal situations it quickly sets the time and allow the
59: * system to startup.
60: *
61: * However during abnormal conditions as detected by unresponsive servers,
62: * out-of-sync or bad responses and other detections, it should print out
63: * a simple but clear message and continue in a mellow way to get the best
64: * possible time. It may never get the time and if so should also indicate
65: * this.
66: *
67: * Rudy Nedved
68: * 18-May-1993
69: *
70: ****************************************************************
71: *
72: * Much of the above is confusing or no longer relevant. For example,
73: * it is rare these days for a machine's console to be a printing terminal,
74: * so the comment about saving trees doesn't mean much. Nonetheless,
75: * the basic principles still stand:
76: *
77: * - Work automatically, without human control or intervention. To
78: * this end, we use the same configuration file as ntpd itself, so
79: * you don't have to specify servers or other information on the
80: * command line. We also recognize that sometimes we won't be able
81: * to contact any servers, and give up in that event instead of
82: * hanging forever.
83: *
84: * - Behave in a sane way, both internally and externally, even in the
85: * face of insane conditions. That means we back off quickly when
86: * we don't hear a response, to avoid network congestion. Like
87: * ntpd, we verify responses from several servers before accepting
88: * the new time data.
89: *
90: * However, we don't assume that the local clock is right, or even
91: * close, because it might not be at boot time, and we want to catch
92: * and correct that situation. This behaviour has saved us in several
93: * instances. On HP-UX 9.0x, there used to be a bug in adjtimed which
94: * would cause the time to be set to some wild value, making the machine
95: * essentially unusable (we use Kerberos authentication pervasively,
96: * and it requires workstations and servers to have a time within five
97: * minutes of the Kerberos server). We also have problems on PC's
98: * running both Linux and some Microsoft OS -- they tend to disagree
99: * on what the BIOS clock should say, and who should update it, and
100: * when. On those systems, we not only run ntptimeset at boot, we
101: * also reset the BIOS clock based on the result, so the correct
102: * time will be retained across reboots.
103: *
104: * For these reasons, and others, we have continued to use this tool
105: * rather than ntpdate. It is run automatically at boot time on every
106: * workstation and server in our facility.
107: *
108: * In the past, we called this program 'ntptime'. Unfortunately, the
109: * ntp v4 distribution also includes a program with that name. In
110: * order to avoid confusion, we have renamed our program 'ntptimeset',
111: * which more accurately describes what it does.
112: *
113: * Jeffrey T. Hutzelman (N3NHS) <jhutz+@cmu.edu>
114: * School of Computer Science - Research Computing Facility
115: * Carnegie Mellon University - Pittsburgh, PA
116: * 16-Aug-1999
117: *
118: */
119:
120: #ifdef HAVE_CONFIG_H
121: # include <config.h>
122: #endif
123:
124: #include "ntp_machine.h"
125: #include "ntp_fp.h"
126: #include "ntp.h"
127: #include "ntp_io.h"
128: #include "iosignal.h"
129: #include "ntp_unixtime.h"
130: #include "ntpdate.h"
131: #include "ntp_string.h"
132: #include "ntp_syslog.h"
133: #include "ntp_select.h"
134: #include "ntp_stdlib.h"
135:
136: #ifdef HAVE_UNISTD_H
137: # include <unistd.h>
138: #endif
139:
140: #include <stdio.h>
141: #include <signal.h>
142: #include <ctype.h>
143: #ifndef SYS_WINNT
144: # ifdef HAVE_SYS_SIGNAL_H
145: # include <sys/signal.h>
146: # else
147: # include <signal.h>
148: # endif
149: # include <sys/ioctl.h>
150: #endif /* SYS_WINNT */
151:
152: #ifdef HAVE_SYS_RESOURCE_H
153: # include <sys/resource.h>
154: #endif /* HAVE_SYS_RESOURCE_H */
155:
156: #ifdef SYS_VXWORKS
157: # include "ioLib.h"
158: # include "sockLib.h"
159: # include "timers.h"
160: #endif
161:
162: #include "recvbuff.h"
163:
164: #ifdef SYS_WINNT
165: # define TARGET_RESOLUTION 1 /* Try for 1-millisecond accuracy
166: on Windows NT timers. */
167: #pragma comment(lib, "winmm")
168: #endif /* SYS_WINNT */
169:
170: /*
171: * Scheduling priority we run at
172: */
173: #ifndef SYS_VXWORKS
174: # define NTPDATE_PRIO (-12)
175: #else
176: # define NTPDATE_PRIO (100)
177: #endif
178:
179: #if defined(HAVE_TIMER_SETTIME) || defined (HAVE_TIMER_CREATE)
180: /* POSIX TIMERS - vxWorks doesn't have itimer - casey */
181: static timer_t ntpdate_timerid;
182: #endif
183:
184: /*
185: * Compatibility stuff for Version 2
186: */
187: #define NTP_MAXSKW 0x28f /* 0.01 sec in fp format */
188: #define NTP_MINDIST 0x51f /* 0.02 sec in fp format */
189: #define NTP_INFIN 15 /* max stratum, infinity a la Bellman-Ford */
190: #define NTP_MAXWGT (8*FP_SECOND) /* maximum select weight 8 seconds */
191: #define NTP_MAXLIST 5 /* maximum select list size */
192: #define PEER_SHIFT 8 /* 8 suitable for crystal time base */
193:
194: /*
195: * Debugging flag
196: */
197: volatile int debug = 0;
198:
199: /*
200: * File descriptor masks etc. for call to select
201: */
202: int fd;
203: fd_set fdmask;
204:
205: /*
206: * Initializing flag. All async routines watch this and only do their
207: * thing when it is clear.
208: */
209: int initializing = 1;
210:
211: /*
212: * Alarm flag. Set when an alarm occurs
213: */
214: volatile int alarm_flag = 0;
215:
216: /*
217: * Set the time if valid time determined
218: */
219: int set_time = 0;
220:
221: /*
222: * transmission rate control
223: */
224: #define MINTRANSMITS (3) /* minimum total packets per server */
225: #define MAXXMITCOUNT (2) /* maximum packets per time interrupt */
226:
227: /*
228: * time setting constraints
229: */
230: #define DESIREDDISP (4*FP_SECOND) /* desired dispersion, (fp 4) */
231: int max_period = DEFMAXPERIOD;
232: int min_servers = DEFMINSERVERS;
233: int min_valid = DEFMINVALID;
234:
235: /*
236: * counters related to time setting constraints
237: */
238: int contacted = 0; /* # of servers we have sent to */
239: int responding = 0; /* servers responding */
240: int validcount = 0; /* servers with valid time */
241: int valid_n_low = 0; /* valid time servers with low dispersion */
242:
243: /*
244: * Unpriviledged port flag.
245: */
246: int unpriv_port = 0;
247:
248: /*
249: * Program name.
250: */
251: char *progname;
252:
253: /*
254: * Systemwide parameters and flags
255: */
256: struct server **sys_servers; /* the server list */
257: int sys_numservers = 0; /* number of servers to poll */
258: int sys_authenticate = 0; /* true when authenticating */
259: u_int32 sys_authkey = 0; /* set to authentication key in use */
260: u_long sys_authdelay = 0; /* authentication delay */
261:
262: /*
263: * The current internal time
264: */
265: u_long current_time = 0;
266:
267: /*
268: * File of encryption keys
269: */
270:
271: #ifndef KEYFILE
272: # ifndef SYS_WINNT
273: #define KEYFILE "/etc/ntp.keys"
274: # else
275: #define KEYFILE "%windir%\\ntp.keys"
276: # endif /* SYS_WINNT */
277: #endif /* KEYFILE */
278:
279: #ifndef SYS_WINNT
280: const char *key_file = KEYFILE;
281: #else
282: char key_file_storage[MAX_PATH+1], *key_file ;
283: #endif /* SYS_WINNT */
284:
285: /*
286: * total packet counts
287: */
288: u_long total_xmit = 0;
289: u_long total_recv = 0;
290:
291: /*
292: * Miscellaneous flags
293: */
294: int verbose = 0;
295: #define HORRIBLEOK 3 /* how many packets to let out */
296: int horrible = 0; /* how many packets we drop for testing */
297: int secondhalf = 0; /* second half of timeout period */
298: int printmsg = 0; /* print time response analysis */
299:
300: /*
301: * The half time and finish time in internal time
302: */
303: u_long half_time = 0;
304: u_long finish_time = 0;
305:
306:
307: int ntptimesetmain P((int argc, char *argv[]));
308: static void analysis P((int final));
309: static int have_enough P((void));
310: static void transmit P((register struct server *server));
311: static void receive P((struct recvbuf *rbufp));
312: static void clock_filter P((register struct server *server, s_fp d, l_fp *c));
313: static void clock_count P((void));
314: static struct server *clock_select P((void));
315: static void set_local_clock P((void));
316: static struct server *findserver P((struct sockaddr_in *addr));
317: static void timer P((void));
318: #ifndef SYS_WINNT
319: static RETSIGTYPE alarming P((int sig));
320: #endif /* SYS_WINNT */
321: static void init_alarm P((void));
322: static void init_io P((void));
323: static int sendpkt P((struct sockaddr_in *dest, struct pkt *pkt, int len));
324: void input_handler P((l_fp *xts));
325: static void printserver P((register struct server *pp, FILE *fp));
326: #if !defined(HAVE_VSPRINTF)
327: int vsprintf P((char *str, const char *fmt, va_list ap));
328: #endif
329:
330: #ifdef HAVE_SIGNALED_IO
331: extern void wait_for_signal P((void));
332: extern void unblock_io_and_alarm P((void));
333: extern void block_io_and_alarm P((void));
334: #endif
335:
336:
337: #ifdef NO_MAIN_ALLOWED
338: CALL(ntptimeset,"ntptimeset",ntptimesetmain);
339:
340: void clear_globals()
341: {
342: /*
343: * Debugging flag
344: */
345: debug = 0;
346:
347: ntp_optind = 0;
348:
349: /*
350: * Initializing flag. All async routines watch this and only do their
351: * thing when it is clear.
352: */
353: initializing = 1;
354:
355: /*
356: * Alarm flag. Set when an alarm occurs
357: */
358: alarm_flag = 0;
359:
360: /*
361: * Unpriviledged port flag.
362: */
363: unpriv_port = 0;
364:
365: /*
366: * Systemwide parameters and flags
367: */
368: sys_numservers = 0; /* number of servers to poll */
369: sys_authenticate = 0; /* true when authenticating */
370: sys_authkey = 0; /* set to authentication key in use */
371: sys_authdelay = 0; /* authentication delay */
372:
373: /*
374: * The current internal time
375: */
376: current_time = 0;
377:
378: verbose = 0;
379: }
380: #endif /* NO_MAIN_ALLOWED */
381:
382: /*
383: * Main program. Initialize us and loop waiting for I/O and/or
384: * timer expiries.
385: */
386: #ifndef NO_MAIN_ALLOWED
387: int
388: main(
389: int argc,
390: char *argv[]
391: )
392: {
393: return ntptimesetmain(argc, argv);
394: }
395: #endif /* NO_MAIN_ALLOWED */
396:
397:
398: int
399: ntptimesetmain(
400: int argc,
401: char *argv[]
402: )
403: {
404: int was_alarmed;
405: int tot_recvbufs;
406: struct recvbuf *rbuf;
407: l_fp tmp;
408: int errflg;
409: int c;
410: extern char *ntp_optarg;
411: extern int ntp_optind;
412: int ltmp;
413: char *cfgpath;
414:
415: #ifdef SYS_WINNT
416: HANDLE process_handle;
417:
418: wVersionRequested = MAKEWORD(1,1);
419: if (WSAStartup(wVersionRequested, &wsaData)) {
420: msyslog(LOG_ERR, "No useable winsock.dll: %m");
421: exit(1);
422: }
423: #endif /* SYS_WINNT */
424:
425: #ifdef NO_MAIN_ALLOWED
426: clear_globals();
427: #endif
428:
429: errflg = 0;
430: cfgpath = 0;
431: progname = argv[0];
432: syslogit = 0;
433:
434: /*
435: * Decode argument list
436: */
437: while ((c = ntp_getopt(argc, argv, "a:c:de:slt:uvHS:V:")) != EOF)
438: switch (c)
439: {
440: case 'a':
441: c = atoi(ntp_optarg);
442: sys_authenticate = 1;
443: sys_authkey = c;
444: break;
445: case 'c':
446: cfgpath = ntp_optarg;
447: break;
448: case 'd':
449: ++debug;
450: break;
451: case 'e':
452: if (!atolfp(ntp_optarg, &tmp)
453: || tmp.l_ui != 0) {
454: (void) fprintf(stderr,
455: "%s: encryption delay %s is unlikely\n",
456: progname, ntp_optarg);
457: errflg++;
458: } else {
459: sys_authdelay = tmp.l_uf;
460: }
461: break;
462: case 's':
463: set_time = 1;
464: break;
465: case 'l':
466: syslogit = 1;
467: break;
468: case 't':
469: ltmp = atoi(ntp_optarg);
470: if (ltmp <= 0) {
471: (void) fprintf(stderr,
472: "%s: maximum time period (%d) is invalid\n",
473: progname, ltmp);
474: errflg++;
475: }
476: else
477: max_period = ltmp;
478: break;
479: case 'u':
480: unpriv_port = 1;
481: break;
482: case 'v':
483: ++verbose;
484: break;
485: case 'H':
486: horrible++;
487: break;
488: case 'S':
489: ltmp = atoi(ntp_optarg);
490: if (ltmp <= 0) {
491: (void) fprintf(stderr,
492: "%s: minimum responding (%d) is invalid\n",
493: progname, ltmp);
494: errflg++;
495: }
496: else
497: min_servers = ltmp;
498: break;
499: case 'V':
500: ltmp = atoi(ntp_optarg);
501: if (ltmp <= 0) {
502: (void) fprintf(stderr,
503: "%s: minimum valid (%d) is invalid\n",
504: progname, ltmp);
505: errflg++;
506: }
507: else
508: min_valid = ltmp;
509: break;
510: case '?':
511: ++errflg;
512: break;
513: default:
514: break;
515: }
516:
517:
518: if (errflg || ntp_optind < argc) {
519: fprintf(stderr,"usage: %s [switches...]\n",progname);
520: fprintf(stderr," -v (verbose)\n");
521: fprintf(stderr," -c path (set config file path)\n");
522: fprintf(stderr," -a key (authenticate using key)\n");
523: fprintf(stderr," -e delay (authentication delay)\n");
524: fprintf(stderr," -S num (# of servers that must respond)\n");
525: fprintf(stderr," -V num (# of servers that must valid)\n");
526: fprintf(stderr," -s (set the time based if okay)\n");
527: fprintf(stderr," -t secs (time period before ending)\n");
528: fprintf(stderr," -l (use syslog facility)\n");
529: fprintf(stderr," -u (use unprivileged port)\n");
530: fprintf(stderr," -H (drop packets for debugging)\n");
531: fprintf(stderr," -d (debug output)\n");
532: exit(2);
533: }
534:
535: /*
536: * Logging. Open the syslog if we have to
537: */
538: if (syslogit) {
539: #if !defined (SYS_WINNT) && !defined (SYS_VXWORKS) && !defined SYS_CYGWIN32
540: # ifndef LOG_DAEMON
541: openlog("ntptimeset", LOG_PID);
542: # else
543:
544: # ifndef LOG_NTP
545: # define LOG_NTP LOG_DAEMON
546: # endif
547: openlog("ntptimeset", LOG_PID | LOG_NDELAY, LOG_NTP);
548: if (debug)
549: setlogmask(LOG_UPTO(LOG_DEBUG));
550: else
551: setlogmask(LOG_UPTO(LOG_INFO));
552: # endif /* LOG_DAEMON */
553: #endif /* SYS_WINNT */
554: }
555:
556: if (debug || verbose)
557: msyslog(LOG_INFO, "%s", Version);
558:
559: if (horrible)
560: msyslog(LOG_INFO, "Dropping %d out of %d packets",
561: horrible,horrible+HORRIBLEOK);
562: /*
563: * Add servers we are going to be polling
564: */
565: loadservers(cfgpath);
566:
567: if (sys_numservers < min_servers) {
568: msyslog(LOG_ERR, "Found %d servers, require %d servers",
569: sys_numservers,min_servers);
570: exit(2);
571: }
572:
573: /*
574: * determine when we will end at least
575: */
576: finish_time = max_period * TIMER_HZ;
577: half_time = finish_time >> 1;
578:
579: /*
580: * Initialize the time of day routines and the I/O subsystem
581: */
582: if (sys_authenticate) {
583: init_auth();
584: #ifdef SYS_WINNT
585: if (!key_file) key_file = KEYFILE;
586: if (!ExpandEnvironmentStrings(key_file, key_file_storage, MAX_PATH))
587: {
588: msyslog(LOG_ERR, "ExpandEnvironmentStrings(%s) failed: %m\n",
589: key_file);
590: } else {
591: key_file = key_file_storage;
592: }
593: #endif /* SYS_WINNT */
594:
595: if (!authreadkeys(key_file)) {
596: msyslog(LOG_ERR, "no key file, exiting");
597: exit(1);
598: }
599: if (!authistrusted(sys_authkey)) {
600: char buf[10];
601:
602: (void) sprintf(buf, "%lu", (unsigned long)sys_authkey);
603: msyslog(LOG_ERR, "authentication key %s unknown", buf);
604: exit(1);
605: }
606: }
607: init_io();
608: init_alarm();
609:
610: /*
611: * Set the priority.
612: */
613: #ifdef SYS_VXWORKS
614: taskPrioritySet( taskIdSelf(), NTPDATE_PRIO);
615: #endif
616: #if defined(HAVE_ATT_NICE)
617: nice (NTPDATE_PRIO);
618: #endif
619: #if defined(HAVE_BSD_NICE)
620: (void) setpriority(PRIO_PROCESS, 0, NTPDATE_PRIO);
621: #endif
622: #ifdef SYS_WINNT
623: process_handle = GetCurrentProcess();
624: if (!SetPriorityClass(process_handle, (DWORD) REALTIME_PRIORITY_CLASS)) {
625: msyslog(LOG_ERR, "SetPriorityClass failed: %m");
626: }
627: #endif /* SYS_WINNT */
628:
629: initializing = 0;
630:
631: /*
632: * Use select() on all on all input fd's for unlimited
633: * time. select() will terminate on SIGALARM or on the
634: * reception of input. Using select() means we can't do
635: * robust signal handling and we get a potential race
636: * between checking for alarms and doing the select().
637: * Mostly harmless, I think.
638: * Keep going until we have enough information, or time is up.
639: */
640: /* On VMS, I suspect that select() can't be interrupted
641: * by a "signal" either, so I take the easy way out and
642: * have select() time out after one second.
643: * System clock updates really aren't time-critical,
644: * and - lacking a hardware reference clock - I have
645: * yet to learn about anything else that is.
646: */
647: was_alarmed = 0;
648: while (finish_time > current_time) {
649: #if !defined(HAVE_SIGNALED_IO)
650: fd_set rdfdes;
651: int nfound;
652: #elif defined(HAVE_SIGNALED_IO)
653: block_io_and_alarm();
654: #endif
655:
656: tot_recvbufs = full_recvbuffs(); /* get received buffers */
657: if (printmsg) {
658: printmsg = 0;
659: analysis(0);
660: }
661: if (alarm_flag) { /* alarmed? */
662: was_alarmed = 1;
663: alarm_flag = 0;
664: }
665:
666: if (!was_alarmed && tot_recvbufs > 0) {
667: /*
668: * Nothing to do. Wait for something.
669: */
670: #ifndef HAVE_SIGNALED_IO
671: rdfdes = fdmask;
672: # if defined(VMS) || defined(SYS_VXWORKS)
673: /* make select() wake up after one second */
674: {
675: struct timeval t1;
676:
677: t1.tv_sec = 1; t1.tv_usec = 0;
678: nfound = select(fd+1, &rdfdes, (fd_set *)0,
679: (fd_set *)0, &t1);
680: }
681: # else
682: nfound = select(fd+1, &rdfdes, (fd_set *)0,
683: (fd_set *)0, (struct timeval *)0);
684: # endif /* VMS */
685: if (nfound > 0) {
686: l_fp ts;
687: get_systime(&ts);
688: (void)input_handler(&ts);
689: }
690: else if (nfound == -1 && errno != EINTR)
691: msyslog(LOG_ERR, "select() error: %m");
692: else if (debug) {
693: # if !defined SYS_VXWORKS && !defined SYS_CYGWIN32 /* to unclutter log */
694: msyslog(LOG_DEBUG, "select(): nfound=%d, error: %m", nfound);
695: # endif
696: }
697: #else /* HAVE_SIGNALED_IO */
698:
699: wait_for_signal();
700: #endif /* HAVE_SIGNALED_IO */
701: if (alarm_flag) /* alarmed? */
702: {
703: was_alarmed = 1;
704: alarm_flag = 0;
705: }
706: tot_recvbufs = full_recvbuffs(); /* get received buffers */
707: }
708: #ifdef HAVE_SIGNALED_IO
709: unblock_io_and_alarm();
710: #endif /* HAVE_SIGNALED_IO */
711:
712: /*
713: * Out here, signals are unblocked. Call timer routine
714: * to process expiry.
715: */
716: if (was_alarmed)
717: {
718: timer();
719: was_alarmed = 0;
720: }
721:
722: /*
723: * Call the data procedure to handle each received
724: * packet.
725: */
726: rbuf = get_full_recv_buffer();
727: while (rbuf != NULL)
728: {
729: receive(rbuf);
730: freerecvbuf(rbuf);
731: rbuf = get_full_recv_buffer();
732: }
733:
734: /*
735: * Do we have enough information to stop now?
736: */
737: if (have_enough())
738: break; /* time to end */
739:
740: /*
741: * Go around again
742: */
743: }
744:
745: /*
746: * adjust the clock and exit accordingly
747: */
748: set_local_clock();
749:
750: /*
751: * if we get here then we are in trouble
752: */
753: return(1);
754: }
755:
756:
757: /*
758: * analysis - print a message indicating what is happening with time service
759: * must mimic have_enough() procedure.
760: */
761: static void
762: analysis(
763: int final
764: )
765: {
766: if (contacted < sys_numservers) {
767: printf("%d servers of %d have been probed with %d packets\n",
768: contacted,sys_numservers,MINTRANSMITS);
769: return;
770: }
771: if (!responding) {
772: printf("No response from any of %d servers, network problem?\n",
773: sys_numservers);
774: return;
775: }
776: else if (responding < min_servers) {
777: printf("%d servers out of %d responding, need at least %d.\n",
778: responding, sys_numservers, min_servers);
779: return;
780: }
781: if (!validcount) {
782: printf("%d servers responding but none have valid time\n",
783: responding);
784: return;
785: }
786: else if (validcount < min_valid) {
787: printf("%d servers responding, %d are valid, need %d valid\n",
788: responding,validcount,min_valid);
789: return;
790: }
791: if (!final && valid_n_low != validcount) {
792: printf("%d valid servers but only %d have low dispersion\n",
793: validcount,valid_n_low);
794: return;
795: }
796: }
797:
798:
799: /* have_enough - see if we have enough information to terminate probing
800: */
801: static int
802: have_enough(void)
803: {
804: /* have we contacted all servers yet? */
805: if (contacted < sys_numservers)
806: return 0; /* no...try some more */
807:
808: /* have we got at least minimum servers responding? */
809: if (responding < min_servers)
810: return 0; /* no...try some more */
811:
812: /* count the clocks */
813: (void) clock_count();
814:
815: /* have we got at least minimum valid clocks? */
816: if (validcount <= 0 || validcount < min_valid)
817: return 0; /* no...try some more */
818:
819: /* do we have all valid servers with low dispersion */
820: if (!secondhalf && valid_n_low != validcount)
821: return 0;
822:
823: /* if we get into the secondhalf then we ignore dispersion */
824:
825: /* all conditions have been met...end */
826: return 1;
827: }
828:
829:
830: /*
831: * transmit - transmit a packet to the given server, or mark it completed.
832: * This is called by the timeout routine and by the receive
833: * procedure.
834: */
835: static void
836: transmit(
837: register struct server *server
838: )
839: {
840: struct pkt xpkt;
841: int timeout;
842:
843: if (debug > 2)
844: printf("transmit(%s)\n", ntoa(&server->srcadr));
845:
846: if ((server->reach & 01) == 0) {
847: l_fp ts;
848: /*
849: * Last message to this server timed out. Shift
850: * zeros into the filter.
851: */
852: L_CLR(&ts);
853: clock_filter(server, 0, &ts);
854: }
855:
856: /*
857: * shift reachable register over
858: */
859: server->reach <<= 1;
860:
861: /*
862: * If we're here, send another message to the server. Fill in
863: * the packet and let 'er rip.
864: */
865: xpkt.li_vn_mode = PKT_LI_VN_MODE(LEAP_NOTINSYNC,
866: server->version, MODE_CLIENT);
867: xpkt.stratum = STRATUM_TO_PKT(STRATUM_UNSPEC);
868: xpkt.ppoll = NTP_MINPOLL;
869: xpkt.precision = NTPDATE_PRECISION;
870: xpkt.rootdelay = htonl(NTPDATE_DISTANCE);
871: xpkt.rootdispersion = htonl(NTPDATE_DISP);
872: xpkt.refid = htonl(NTPDATE_REFID);
873: L_CLR(&xpkt.reftime);
874: L_CLR(&xpkt.org);
875: L_CLR(&xpkt.rec);
876:
877: /*
878: * Determine whether to authenticate or not. If so,
879: * fill in the extended part of the packet and do it.
880: * If not, just timestamp it and send it away.
881: */
882: if (sys_authenticate) {
883: int len;
884:
885: xpkt.exten[0] = htonl(sys_authkey);
886: get_systime(&server->xmt);
887: L_ADDUF(&server->xmt, sys_authdelay);
888: HTONL_FP(&server->xmt, &xpkt.xmt);
889: len = authencrypt(sys_authkey, (u_int32 *)&xpkt, LEN_PKT_NOMAC);
890: if (sendpkt(&(server->srcadr), &xpkt, (int)(LEN_PKT_NOMAC + len))) {
891: if (debug > 1)
892: printf("failed transmit auth to %s\n",
893: ntoa(&(server->srcadr)));
894: return;
895: }
896:
897: if (debug > 1)
898: printf("transmit auth to %s\n",
899: ntoa(&(server->srcadr)));
900: } else {
901: get_systime(&(server->xmt));
902: HTONL_FP(&server->xmt, &xpkt.xmt);
903: if (sendpkt(&(server->srcadr), &xpkt, LEN_PKT_NOMAC)) {
904: if (debug > 1)
905: printf("failed transmit to %s\n",
906: ntoa(&(server->srcadr)));
907: return;
908: }
909:
910: if (debug > 1)
911: printf("transmit to %s\n", ntoa(&(server->srcadr)));
912: }
913:
914: /*
915: * count transmits, record contacted count and set transmit time
916: */
917: if (++server->xmtcnt == MINTRANSMITS)
918: contacted++;
919: server->last_xmit = current_time;
920:
921: /*
922: * determine timeout for this packet. The more packets we send
923: * to the host, the slower we get. If the host indicates that
924: * it is not "sane" then we expect even less.
925: */
926: if (server->xmtcnt < MINTRANSMITS) {
927: /* we have not sent enough */
928: timeout = TIMER_HZ; /* 1 second probe */
929: }
930: else if (server->rcvcnt <= 0) {
931: /* we have heard nothing */
932: if (secondhalf)
933: timeout = TIMER_HZ<<4; /* 16 second probe */
934: else
935: timeout = TIMER_HZ<<3; /* 8 second probe */
936: }
937: else {
938: /* if we have low dispersion then probe infrequently */
939: if (server->dispersion <= DESIREDDISP)
940: timeout = TIMER_HZ<<4; /* 16 second probe */
941: /* if the server is not in sync then let it alone */
942: else if (server->leap == LEAP_NOTINSYNC)
943: timeout = TIMER_HZ<<4; /* 16 second probe */
944: /* if the server looks broken ignore it */
945: else if (server->org.l_ui < server->reftime.l_ui)
946: timeout = TIMER_HZ<<5; /* 32 second probe */
947: else if (secondhalf)
948: timeout = TIMER_HZ<<2; /* 4 second probe */
949: else
950: timeout = TIMER_HZ<<1; /* 2 second probe */
951: }
952:
953: /*
954: * set next transmit time based on timeout
955: */
956: server->event_time = current_time + timeout;
957: }
958:
959:
960: /*
961: * receive - receive and process an incoming frame
962: */
963: static void
964: receive(
965: struct recvbuf *rbufp
966: )
967: {
968: register struct pkt *rpkt;
969: register struct server *server;
970: register s_fp di;
971: l_fp t10, t23;
972: l_fp org;
973: l_fp rec;
974: l_fp ci;
975: int has_mac;
976: int is_authentic;
977:
978: if (debug > 2)
979: printf("receive(%s)\n", ntoa(&rbufp->srcadr));
980: /*
981: * Check to see if the packet basically looks like something
982: * intended for us.
983: */
984: if (rbufp->recv_length == LEN_PKT_NOMAC)
985: has_mac = 0;
986: else if (rbufp->recv_length >= LEN_PKT_NOMAC)
987: has_mac = 1;
988: else {
989: if (debug > 2)
990: printf("receive: packet length %d\n",
991: rbufp->recv_length);
992: return; /* funny length packet */
993: }
994:
995: rpkt = &(rbufp->recv_pkt);
996: if (PKT_VERSION(rpkt->li_vn_mode) < NTP_OLDVERSION ||
997: PKT_VERSION(rpkt->li_vn_mode) > NTP_VERSION) {
998: if (debug > 1)
999: printf("receive: bad version %d\n",
1000: PKT_VERSION(rpkt->li_vn_mode));
1001: return;
1002: }
1003:
1004: if ((PKT_MODE(rpkt->li_vn_mode) != MODE_SERVER
1005: && PKT_MODE(rpkt->li_vn_mode) != MODE_PASSIVE)
1006: || rpkt->stratum >=STRATUM_UNSPEC) {
1007: if (debug > 1)
1008: printf("receive: mode %d stratum %d\n",
1009: PKT_MODE(rpkt->li_vn_mode), rpkt->stratum);
1010: return;
1011: }
1012:
1013: /*
1014: * So far, so good. See if this is from a server we know.
1015: */
1016: server = findserver(&(rbufp->srcadr));
1017: if (server == NULL) {
1018: if (debug > 1)
1019: printf("receive: server not found\n");
1020: return;
1021: }
1022:
1023: /*
1024: * Decode the org timestamp and make sure we're getting a response
1025: * to our last request.
1026: */
1027: NTOHL_FP(&rpkt->org, &org);
1028: if (!L_ISEQU(&org, &server->xmt)) {
1029: if (debug > 1)
1030: printf("receive: pkt.org and peer.xmt differ\n");
1031: return;
1032: }
1033:
1034: /*
1035: * Check out the authenticity if we're doing that.
1036: */
1037: if (!sys_authenticate)
1038: is_authentic = 1;
1039: else {
1040: is_authentic = 0;
1041:
1042: if (debug > 3)
1043: printf("receive: rpkt keyid=%ld sys_authkey=%ld decrypt=%ld\n",
1044: (long int)ntohl(rpkt->exten[0]), (long int)sys_authkey,
1045: (long int)authdecrypt(sys_authkey, (u_int32 *)rpkt,
1046: LEN_PKT_NOMAC, (int)(rbufp->recv_length - LEN_PKT_NOMAC)));
1047:
1048: if (has_mac && ntohl(rpkt->exten[0]) == sys_authkey &&
1049: authdecrypt(sys_authkey, (u_int32 *)rpkt, LEN_PKT_NOMAC,
1050: (int)(rbufp->recv_length - LEN_PKT_NOMAC)))
1051: is_authentic = 1;
1052: if (debug)
1053: printf("receive: authentication %s\n",
1054: is_authentic ? "passed" : "failed");
1055: }
1056: server->trust <<= 1;
1057: if (!is_authentic)
1058: server->trust |= 1;
1059:
1060: /*
1061: * Looks good. Record info from the packet.
1062: */
1063: server->leap = PKT_LEAP(rpkt->li_vn_mode);
1064: server->stratum = PKT_TO_STRATUM(rpkt->stratum);
1065: server->precision = rpkt->precision;
1066: server->rootdelay = ntohl(rpkt->rootdelay);
1067: server->rootdispersion = ntohl(rpkt->rootdispersion);
1068: server->refid = rpkt->refid;
1069: NTOHL_FP(&rpkt->reftime, &server->reftime);
1070: NTOHL_FP(&rpkt->rec, &rec);
1071: NTOHL_FP(&rpkt->xmt, &server->org);
1072:
1073: /*
1074: * count this guy as responding
1075: */
1076: server->reach |= 1;
1077: if (server->rcvcnt++ == 0)
1078: responding++;
1079:
1080: /*
1081: * Make sure the server is at least somewhat sane. If not, ignore
1082: * it for later.
1083: */
1084: if (L_ISZERO(&rec) || !L_ISHIS(&server->org, &rec)) {
1085: if (debug > 1)
1086: printf("receive: pkt insane\n");
1087: return;
1088: }
1089:
1090: /*
1091: * Calculate the round trip delay (di) and the clock offset (ci).
1092: * We use the equations (reordered from those in the spec):
1093: *
1094: * d = (t2 - t3) - (t1 - t0)
1095: * c = ((t2 - t3) + (t1 - t0)) / 2
1096: */
1097: t10 = server->org; /* pkt.xmt == t1 */
1098: L_SUB(&t10, &rbufp->recv_time); /* recv_time == t0*/
1099:
1100: t23 = rec; /* pkt.rec == t2 */
1101: L_SUB(&t23, &org); /* pkt->org == t3 */
1102:
1103: /* now have (t2 - t3) and (t0 - t1). Calculate (ci) and (di) */
1104: ci = t10;
1105: L_ADD(&ci, &t23);
1106: L_RSHIFT(&ci);
1107:
1108: /*
1109: * Calculate di in t23 in full precision, then truncate
1110: * to an s_fp.
1111: */
1112: L_SUB(&t23, &t10);
1113: di = LFPTOFP(&t23);
1114:
1115: if (debug > 3)
1116: printf("offset: %s, delay %s\n", lfptoa(&ci, 6), fptoa(di, 5));
1117:
1118: di += (FP_SECOND >> (-(int)NTPDATE_PRECISION))
1119: + (FP_SECOND >> (-(int)server->precision)) + NTP_MAXSKW;
1120:
1121: if (di <= 0) { /* value still too raunchy to use? */
1122: L_CLR(&ci);
1123: di = 0;
1124: } else {
1125: di = max(di, NTP_MINDIST);
1126: }
1127:
1128:
1129: /*
1130: * This one is valid. Give it to clock_filter(),
1131: */
1132: clock_filter(server, di, &ci);
1133: if (debug > 1)
1134: printf("receive from %s\n", ntoa(&rbufp->srcadr));
1135:
1136: /*
1137: * See if we should goes the transmission. If not return now
1138: * otherwise have the next event time be shortened
1139: */
1140: if (server->stratum <= NTP_INFIN)
1141: return; /* server does not have a stratum */
1142: if (server->leap == LEAP_NOTINSYNC)
1143: return; /* just booted server or out of sync */
1144: if (!L_ISHIS(&server->org, &server->reftime))
1145: return; /* broken host */
1146: if (server->trust != 0)
1147: return; /* can not trust it */
1148:
1149: if (server->dispersion < DESIREDDISP)
1150: return; /* we have the desired dispersion */
1151:
1152: server->event_time -= (TIMER_HZ+1);
1153: }
1154:
1155:
1156: /*
1157: * clock_filter - add clock sample, determine a server's delay, dispersion
1158: * and offset
1159: */
1160: static void
1161: clock_filter(
1162: register struct server *server,
1163: s_fp di,
1164: l_fp *c
1165: )
1166: {
1167: register int i, j;
1168: int ord[NTP_SHIFT];
1169:
1170: /*
1171: * Insert sample and increment nextpt
1172: */
1173:
1174: i = server->filter_nextpt;
1175: server->filter_delay[i] = di;
1176: server->filter_offset[i] = *c;
1177: server->filter_soffset[i] = LFPTOFP(c);
1178: server->filter_nextpt++;
1179: if (server->filter_nextpt >= NTP_SHIFT)
1180: server->filter_nextpt = 0;
1181:
1182: /*
1183: * Sort indices into increasing delay order
1184: */
1185: for (i = 0; i < NTP_SHIFT; i++)
1186: ord[i] = i;
1187:
1188: for (i = 0; i < (NTP_SHIFT-1); i++) {
1189: for (j = i+1; j < NTP_SHIFT; j++) {
1190: if (server->filter_delay[ord[j]] == 0)
1191: continue;
1192: if (server->filter_delay[ord[i]] == 0
1193: || (server->filter_delay[ord[i]]
1194: > server->filter_delay[ord[j]])) {
1195: register int tmp;
1196:
1197: tmp = ord[i];
1198: ord[i] = ord[j];
1199: ord[j] = tmp;
1200: }
1201: }
1202: }
1203:
1204: /*
1205: * Now compute the dispersion, and assign values to delay and
1206: * offset. If there are no samples in the register, delay and
1207: * offset go to zero and dispersion is set to the maximum.
1208: */
1209: if (server->filter_delay[ord[0]] == 0) {
1210: server->delay = 0;
1211: L_CLR(&server->offset);
1212: server->soffset = 0;
1213: server->dispersion = PEER_MAXDISP;
1214: } else {
1215: register s_fp d;
1216:
1217: server->delay = server->filter_delay[ord[0]];
1218: server->offset = server->filter_offset[ord[0]];
1219: server->soffset = LFPTOFP(&server->offset);
1220: server->dispersion = 0;
1221: for (i = 1; i < NTP_SHIFT; i++) {
1222: if (server->filter_delay[ord[i]] == 0)
1223: d = PEER_MAXDISP;
1224: else {
1225: d = server->filter_soffset[ord[i]]
1226: - server->filter_soffset[ord[0]];
1227: if (d < 0)
1228: d = -d;
1229: if (d > PEER_MAXDISP)
1230: d = PEER_MAXDISP;
1231: }
1232: /*
1233: * XXX This *knows* PEER_FILTER is 1/2
1234: */
1235: server->dispersion += (u_fp)(d) >> i;
1236: }
1237: }
1238: /*
1239: * We're done
1240: */
1241: }
1242:
1243:
1244: /* clock_count - count the clock sources we have
1245: */
1246: static void
1247: clock_count(void)
1248: {
1249: register struct server *server;
1250: register int n;
1251:
1252: /* reset counts */
1253: validcount = valid_n_low = 0;
1254:
1255: /* go through the list of servers and count the clocks we believe
1256: * and that have low dispersion
1257: */
1258: for (n = 0; n < sys_numservers; n++) {
1259: server = sys_servers[n];
1260: if (server->delay == 0) {
1261: continue; /* no data */
1262: }
1263: if (server->stratum > NTP_INFIN) {
1264: continue; /* stratum no good */
1265: }
1266: if (server->delay > NTP_MAXWGT) {
1267: continue; /* too far away */
1268: }
1269: if (server->leap == LEAP_NOTINSYNC)
1270: continue; /* he's in trouble */
1271: if (!L_ISHIS(&server->org, &server->reftime)) {
1272: continue; /* very broken host */
1273: }
1274: if ((server->org.l_ui - server->reftime.l_ui) >= NTP_MAXAGE) {
1275: continue; /* too long without sync */
1276: }
1277: if (server->trust != 0) {
1278: continue;
1279: }
1280:
1281: /*
1282: * This one is a valid time source..
1283: */
1284: validcount++;
1285:
1286: /*
1287: * See if this one has a okay low dispersion
1288: */
1289: if (server->dispersion <= DESIREDDISP)
1290: valid_n_low++;
1291: }
1292:
1293: if (debug > 1)
1294: printf("have %d, valid %d, low %d\n",
1295: responding, validcount, valid_n_low);
1296: }
1297:
1298:
1299: /*
1300: * clock_select - select the pick-of-the-litter clock from the samples
1301: * we've got.
1302: */
1303: static struct server *
1304: clock_select(void)
1305: {
1306: register struct server *server;
1307: register int i;
1308: register int nlist;
1309: register s_fp d;
1310: register int j;
1311: register int n;
1312: s_fp local_threshold;
1313: struct server *server_list[NTP_MAXCLOCK];
1314: u_fp server_badness[NTP_MAXCLOCK];
1315: struct server *sys_server;
1316:
1317: /*
1318: * This first chunk of code is supposed to go through all
1319: * servers we know about to find the NTP_MAXLIST servers which
1320: * are most likely to succeed. We run through the list
1321: * doing the sanity checks and trying to insert anyone who
1322: * looks okay. We are at all times aware that we should
1323: * only keep samples from the top two strata and we only need
1324: * NTP_MAXLIST of them.
1325: */
1326: nlist = 0; /* none yet */
1327: for (n = 0; n < sys_numservers; n++) {
1328: server = sys_servers[n];
1329: if (server->delay == 0)
1330: continue; /* no data */
1331: if (server->stratum > NTP_INFIN)
1332: continue; /* stratum no good */
1333: if (server->delay > NTP_MAXWGT) {
1334: continue; /* too far away */
1335: }
1336: if (server->leap == LEAP_NOTINSYNC)
1337: continue; /* he's in trouble */
1338: if (!L_ISHIS(&server->org, &server->reftime)) {
1339: continue; /* very broken host */
1340: }
1341: if ((server->org.l_ui - server->reftime.l_ui)
1342: >= NTP_MAXAGE) {
1343: continue; /* too long without sync */
1344: }
1345: if (server->trust != 0) {
1346: continue;
1347: }
1348:
1349: /*
1350: * This one seems sane. Find where he belongs
1351: * on the list.
1352: */
1353: d = server->dispersion + server->dispersion;
1354: for (i = 0; i < nlist; i++)
1355: if (server->stratum <= server_list[i]->stratum)
1356: break;
1357: for ( ; i < nlist; i++) {
1358: if (server->stratum < server_list[i]->stratum)
1359: break;
1360: if (d < (s_fp) server_badness[i])
1361: break;
1362: }
1363:
1364: /*
1365: * If i points past the end of the list, this
1366: * guy is a loser, else stick him in.
1367: */
1368: if (i >= NTP_MAXLIST)
1369: continue;
1370: for (j = nlist; j > i; j--)
1371: if (j < NTP_MAXLIST) {
1372: server_list[j] = server_list[j-1];
1373: server_badness[j]
1374: = server_badness[j-1];
1375: }
1376:
1377: server_list[i] = server;
1378: server_badness[i] = d;
1379: if (nlist < NTP_MAXLIST)
1380: nlist++;
1381: }
1382:
1383: /*
1384: * Got the five-or-less best. Cut the list where the number of
1385: * strata exceeds two.
1386: */
1387: j = 0;
1388: for (i = 1; i < nlist; i++)
1389: if (server_list[i]->stratum > server_list[i-1]->stratum)
1390: if (++j == 2) {
1391: nlist = i;
1392: break;
1393: }
1394:
1395: /*
1396: * Whew! What we should have by now is 0 to 5 candidates for
1397: * the job of syncing us. If we have none, we're out of luck.
1398: * If we have one, he's a winner. If we have more, do falseticker
1399: * detection.
1400: */
1401:
1402: if (nlist == 0)
1403: sys_server = 0;
1404: else if (nlist == 1) {
1405: sys_server = server_list[0];
1406: } else {
1407: /*
1408: * Re-sort by stratum, bdelay estimate quality and
1409: * server.delay.
1410: */
1411: for (i = 0; i < nlist-1; i++)
1412: for (j = i+1; j < nlist; j++) {
1413: if (server_list[i]->stratum
1414: < server_list[j]->stratum)
1415: break; /* already sorted by stratum */
1416: if (server_list[i]->delay
1417: < server_list[j]->delay)
1418: continue;
1419: server = server_list[i];
1420: server_list[i] = server_list[j];
1421: server_list[j] = server;
1422: }
1423:
1424: /*
1425: * Calculate the fixed part of the dispersion limit
1426: */
1427: local_threshold = (FP_SECOND >> (-(int)NTPDATE_PRECISION))
1428: + NTP_MAXSKW;
1429:
1430: /*
1431: * Now drop samples until we're down to one.
1432: */
1433: while (nlist > 1) {
1434: for (n = 0; n < nlist; n++) {
1435: server_badness[n] = 0;
1436: for (j = 0; j < nlist; j++) {
1437: if (j == n) /* with self? */
1438: continue;
1439: d = server_list[j]->soffset
1440: - server_list[n]->soffset;
1441: if (d < 0) /* absolute value */
1442: d = -d;
1443: /*
1444: * XXX This code *knows* that
1445: * NTP_SELECT is 3/4
1446: */
1447: for (i = 0; i < j; i++)
1448: d = (d>>1) + (d>>2);
1449: server_badness[n] += d;
1450: }
1451: }
1452:
1453: /*
1454: * We now have an array of nlist badness
1455: * coefficients. Find the badest. Find
1456: * the minimum precision while we're at
1457: * it.
1458: */
1459: i = 0;
1460: n = server_list[0]->precision;;
1461: for (j = 1; j < nlist; j++) {
1462: if (server_badness[j] >= server_badness[i])
1463: i = j;
1464: if (n > server_list[j]->precision)
1465: n = server_list[j]->precision;
1466: }
1467:
1468: /*
1469: * i is the index of the server with the worst
1470: * dispersion. If his dispersion is less than
1471: * the threshold, stop now, else delete him and
1472: * continue around again.
1473: */
1474: if (server_badness[i] < (local_threshold
1475: + (FP_SECOND >> (-n))))
1476: break;
1477: for (j = i + 1; j < nlist; j++)
1478: server_list[j-1] = server_list[j];
1479: nlist--;
1480: }
1481:
1482: /*
1483: * What remains is a list of less than 5 servers. Take
1484: * the best.
1485: */
1486: sys_server = server_list[0];
1487: }
1488:
1489: /*
1490: * That's it. Return our server.
1491: */
1492: return sys_server;
1493: }
1494:
1495:
1496: /*
1497: * set_local_clock -- handle setting the local clock or displaying info.
1498: */
1499: static void
1500: set_local_clock(void)
1501: {
1502: register int i;
1503: register struct server *server;
1504: time_t tmp;
1505: double dtemp;
1506:
1507: /*
1508: * if setting time then print final analysis
1509: */
1510: if (set_time)
1511: analysis(1);
1512:
1513: /*
1514: * pick a clock
1515: */
1516: server = clock_select();
1517:
1518: /*
1519: * do some display of information
1520: */
1521: if (debug || verbose) {
1522: for (i = 0; i < sys_numservers; i++)
1523: printserver(sys_servers[i], stdout);
1524: if (debug)
1525: printf("packets sent %ld, received %ld\n",
1526: total_xmit, total_recv);
1527: }
1528:
1529: /*
1530: * see if we have a server to set the time with
1531: */
1532: if (server == 0) {
1533: if (!set_time || verbose)
1534: fprintf(stdout,"No servers available to sync time with\n");
1535: exit(1);
1536: }
1537:
1538: /*
1539: * we have a valid and selected time to use!!!!!
1540: */
1541:
1542: /*
1543: * if we are not setting the time then display offset and exit
1544: */
1545: if (!set_time) {
1546: fprintf(stdout,
1547: "Your clock is off by %s seconds. (%s) [%ld/%ld]\n",
1548: lfptoa(&server->offset, 7),
1549: ntoa(&server->srcadr),
1550: total_xmit, total_recv);
1551: exit(0);
1552: }
1553:
1554: /*
1555: * set the clock
1556: * XXX: Examine the more flexible approach used by ntpdate.
1557: * Note that a design consideration here is that we sometimes
1558: * _want_ to step the clock by a _huge_ amount in either
1559: * direction, because the local clock is completely bogus.
1560: * This condition must be recognized and dealt with, so
1561: * that we always get a good time when this completes.
1562: * -- jhutz+@cmu.edu, 16-Aug-1999
1563: */
1564: LFPTOD(&server->offset, dtemp);
1565: step_systime(dtemp);
1566: time(&tmp);
1567: fprintf(stdout,"Time set to %.20s [%s %s %ld/%ld]\n",
1568: ctime(&tmp)+4,
1569: ntoa(&server->srcadr),
1570: lfptoa(&server->offset, 7),
1571: total_xmit, total_recv);
1572: exit(0);
1573: }
1574:
1575:
1576: /*
1577: * findserver - find a server in the list given its address
1578: */
1579: static struct server *
1580: findserver(
1581: struct sockaddr_in *addr
1582: )
1583: {
1584: register int i;
1585: register u_int32 netnum;
1586:
1587: if (htons(addr->sin_port) != NTP_PORT)
1588: return 0;
1589: netnum = addr->sin_addr.s_addr;
1590:
1591: for (i = 0; i < sys_numservers; i++) {
1592: if (netnum == sys_servers[i]->srcadr.sin_addr.s_addr)
1593: return sys_servers[i];
1594: }
1595: return 0;
1596: }
1597:
1598:
1599: /*
1600: * timer - process a timer interrupt
1601: */
1602: static void
1603: timer(void)
1604: {
1605: register int k;
1606:
1607: /*
1608: * Bump the current idea of the time
1609: */
1610: current_time++;
1611:
1612: /*
1613: * see if we have reached half time
1614: */
1615: if (current_time >= half_time && !secondhalf) {
1616: secondhalf++;
1617: if (debug)
1618: printf("\nSecond Half of Timeout!\n");
1619: printmsg++;
1620: }
1621:
1622: /*
1623: * We only want to send a few packets per transmit interrupt
1624: * to throttle things
1625: */
1626: for(k = 0;k < MAXXMITCOUNT;k++) {
1627: register int i, oldi;
1628: register u_long oldxtime;
1629:
1630: /*
1631: * We want to send a packet out for a server that has an
1632: * expired event time. However to be mellow about this, we only
1633: * use one expired event timer and to avoid starvation we use
1634: * the one with the oldest last transmit time.
1635: */
1636: oldi = -1;
1637: oldxtime = 0;
1638: for (i = 0; i < sys_numservers; i++) {
1639: if (sys_servers[i]->event_time <= current_time) {
1640: if (oldi < 0 || oldxtime > sys_servers[i]->last_xmit) {
1641: oldxtime = sys_servers[i]->last_xmit;
1642: oldi = i;
1643: }
1644: }
1645: }
1646: if (oldi >= 0)
1647: transmit(sys_servers[oldi]);
1648: else
1649: break; /* no expired event */
1650: } /* end of transmit loop */
1651: }
1652:
1653:
1654: #ifndef SYS_WINNT
1655: /*
1656: * alarming - record the occurance of an alarm interrupt
1657: */
1658: static RETSIGTYPE
1659: alarming(
1660: int sig
1661: )
1662: #else
1663: void CALLBACK
1664: alarming(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2)
1665: #endif /* SYS_WINNT */
1666: {
1667: alarm_flag++;
1668: }
1669:
1670:
1671: /*
1672: * init_alarm - set up the timer interrupt
1673: */
1674: static void
1675: init_alarm(void)
1676: {
1677: #ifndef SYS_WINNT
1678: # ifndef HAVE_TIMER_SETTIME
1679: struct itimerval itimer;
1680: # else
1681: struct itimerspec ntpdate_itimer;
1682: # endif
1683: #else
1684: TIMECAPS tc;
1685: UINT wTimerRes, wTimerID;
1686: # endif /* SYS_WINNT */
1687: #if defined SYS_CYGWIN32 || defined SYS_WINNT
1688: HANDLE hToken;
1689: TOKEN_PRIVILEGES tkp;
1690: DWORD dwUser = 0;
1691: #endif /* SYS_WINNT */
1692:
1693: alarm_flag = 0;
1694:
1695: #ifndef SYS_WINNT
1696: # if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME)
1697: alarm_flag = 0;
1698: /* this code was put in as setitimer() is non existant this us the
1699: * POSIX "equivalents" setup - casey
1700: */
1701: /* ntpdate_timerid is global - so we can kill timer later */
1702: if (timer_create (CLOCK_REALTIME, NULL, &ntpdate_timerid) ==
1703: # ifdef SYS_VXWORKS
1704: ERROR
1705: # else
1706: -1
1707: # endif
1708: )
1709: {
1710: fprintf (stderr, "init_alarm(): timer_create (...) FAILED\n");
1711: return;
1712: }
1713:
1714: /* TIMER_HZ = (5)
1715: * Set up the alarm interrupt. The first comes 1/(2*TIMER_HZ)
1716: * seconds from now and they continue on every 1/TIMER_HZ seconds.
1717: */
1718: (void) signal_no_reset(SIGALRM, alarming);
1719: ntpdate_itimer.it_interval.tv_sec = ntpdate_itimer.it_value.tv_sec = 0;
1720: ntpdate_itimer.it_interval.tv_nsec = 1000000000/TIMER_HZ;
1721: ntpdate_itimer.it_value.tv_nsec = 1000000000/(TIMER_HZ<<1);
1722: timer_settime(ntpdate_timerid, 0 /* !TIMER_ABSTIME */, &ntpdate_itimer, NULL);
1723: # else
1724: /*
1725: * Set up the alarm interrupt. The first comes 1/(2*TIMER_HZ)
1726: * seconds from now and they continue on every 1/TIMER_HZ seconds.
1727: */
1728: (void) signal_no_reset(SIGALRM, alarming);
1729: itimer.it_interval.tv_sec = itimer.it_value.tv_sec = 0;
1730: itimer.it_interval.tv_usec = 1000000/TIMER_HZ;
1731: itimer.it_value.tv_usec = 1000000/(TIMER_HZ<<1);
1732: setitimer(ITIMER_REAL, &itimer, (struct itimerval *)0);
1733: # endif
1734: #if defined SYS_CYGWIN32
1735: /*
1736: * Get previleges needed for fiddling with the clock
1737: */
1738:
1739: /* get the current process token handle */
1740: if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
1741: msyslog(LOG_ERR, "OpenProcessToken failed: %m");
1742: exit(1);
1743: }
1744: /* get the LUID for system-time privilege. */
1745: LookupPrivilegeValue(NULL, SE_SYSTEMTIME_NAME, &tkp.Privileges[0].Luid);
1746: tkp.PrivilegeCount = 1; /* one privilege to set */
1747: tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
1748: /* get set-time privilege for this process. */
1749: AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,(PTOKEN_PRIVILEGES) NULL, 0);
1750: /* cannot test return value of AdjustTokenPrivileges. */
1751: if (GetLastError() != ERROR_SUCCESS)
1752: msyslog(LOG_ERR, "AdjustTokenPrivileges failed: %m");
1753: #endif
1754: #else /* SYS_WINNT */
1755: _tzset();
1756:
1757: /*
1758: * Get previleges needed for fiddling with the clock
1759: */
1760:
1761: /* get the current process token handle */
1762: if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
1763: msyslog(LOG_ERR, "OpenProcessToken failed: %m");
1764: exit(1);
1765: }
1766: /* get the LUID for system-time privilege. */
1767: LookupPrivilegeValue(NULL, SE_SYSTEMTIME_NAME, &tkp.Privileges[0].Luid);
1768: tkp.PrivilegeCount = 1; /* one privilege to set */
1769: tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
1770: /* get set-time privilege for this process. */
1771: AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,(PTOKEN_PRIVILEGES) NULL, 0);
1772: /* cannot test return value of AdjustTokenPrivileges. */
1773: if (GetLastError() != ERROR_SUCCESS)
1774: msyslog(LOG_ERR, "AdjustTokenPrivileges failed: %m");
1775:
1776: /*
1777: * Set up timer interrupts for every 2**EVENT_TIMEOUT seconds
1778: * Under Win/NT, expiry of timer interval leads to invocation
1779: * of a callback function (on a different thread) rather than
1780: * generating an alarm signal
1781: */
1782:
1783: /* determine max and min resolution supported */
1784: if(timeGetDevCaps(&tc, sizeof(TIMECAPS)) != TIMERR_NOERROR) {
1785: msyslog(LOG_ERR, "timeGetDevCaps failed: %m");
1786: exit(1);
1787: }
1788: wTimerRes = min(max(tc.wPeriodMin, TARGET_RESOLUTION), tc.wPeriodMax);
1789: /* establish the minimum timer resolution that we'll use */
1790: timeBeginPeriod(wTimerRes);
1791:
1792: /* start the timer event */
1793: wTimerID = timeSetEvent(
1794: (UINT) (1000/TIMER_HZ), /* Delay */
1795: wTimerRes, /* Resolution */
1796: (LPTIMECALLBACK) alarming, /* Callback function */
1797: (DWORD) dwUser, /* User data */
1798: TIME_PERIODIC); /* Event type (periodic) */
1799: if (wTimerID == 0) {
1800: msyslog(LOG_ERR, "timeSetEvent failed: %m");
1801: exit(1);
1802: }
1803: #endif /* SYS_WINNT */
1804: }
1805:
1806:
1807: /*
1808: * init_io - initialize I/O data and open socket
1809: */
1810: static void
1811: init_io(void)
1812: {
1813: #ifdef SYS_WINNT
1814: WORD wVersionRequested;
1815: WSADATA wsaData;
1816: init_transmitbuff();
1817: #endif /* SYS_WINNT */
1818:
1819: /*
1820: * Init buffer free list and stat counters
1821: */
1822: init_recvbuff(sys_numservers + 2);
1823:
1824: #if defined(HAVE_SIGNALED_IO)
1825: set_signal();
1826: #endif
1827:
1828: #ifdef SYS_WINNT
1829: wVersionRequested = MAKEWORD(1,1);
1830: if (WSAStartup(wVersionRequested, &wsaData))
1831: {
1832: msyslog(LOG_ERR, "No useable winsock.dll: %m");
1833: exit(1);
1834: }
1835: #endif /* SYS_WINNT */
1836:
1837: BLOCKIO();
1838:
1839: /* create a datagram (UDP) socket */
1840: if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
1841: msyslog(LOG_ERR, "socket() failed: %m");
1842: exit(1);
1843: /*NOTREACHED*/
1844: }
1845:
1846: /*
1847: * bind the socket to the NTP port
1848: */
1849: if (!debug && set_time && !unpriv_port) {
1850: struct sockaddr_in addr;
1851:
1852: memset((char *)&addr, 0, sizeof addr);
1853: addr.sin_family = AF_INET;
1854: addr.sin_port = htons(NTP_PORT);
1855: addr.sin_addr.s_addr = htonl(INADDR_ANY);
1856: if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
1857: #ifndef SYS_WINNT
1858: if (errno == EADDRINUSE)
1859: #else
1860: if (WSAGetLastError() == WSAEADDRINUSE)
1861: #endif
1862: msyslog(LOG_ERR,
1863: "the NTP socket is in use, exiting");
1864: else
1865: msyslog(LOG_ERR, "bind() fails: %m");
1866: exit(1);
1867: }
1868: }
1869:
1870: FD_ZERO(&fdmask);
1871: FD_SET(fd, &fdmask);
1872:
1873: /*
1874: * set non-blocking,
1875: */
1876:
1877: #ifdef USE_FIONBIO
1878: /* in vxWorks we use FIONBIO, but the others are defined for old systems, so
1879: * all hell breaks loose if we leave them defined
1880: */
1881: #undef O_NONBLOCK
1882: #undef FNDELAY
1883: #undef O_NDELAY
1884: #endif
1885:
1886: #if defined(O_NONBLOCK) /* POSIX */
1887: if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
1888: {
1889: msyslog(LOG_ERR, "fcntl(O_NONBLOCK) fails: %m");
1890: exit(1);
1891: /*NOTREACHED*/
1892: }
1893: #elif defined(FNDELAY)
1894: if (fcntl(fd, F_SETFL, FNDELAY) < 0)
1895: {
1896: msyslog(LOG_ERR, "fcntl(FNDELAY) fails: %m");
1897: exit(1);
1898: /*NOTREACHED*/
1899: }
1900: #elif defined(O_NDELAY) /* generally the same as FNDELAY */
1901: if (fcntl(fd, F_SETFL, O_NDELAY) < 0)
1902: {
1903: msyslog(LOG_ERR, "fcntl(O_NDELAY) fails: %m");
1904: exit(1);
1905: /*NOTREACHED*/
1906: }
1907: #elif defined(FIONBIO)
1908: if (
1909: # if defined(VMS)
1910: (ioctl(fd,FIONBIO,&1) < 0)
1911: # elif defined(SYS_WINNT)
1912: (ioctlsocket(fd,FIONBIO,(u_long *) &on) == SOCKET_ERROR)
1913: # else
1914: (ioctl(fd,FIONBIO,&on) < 0)
1915: # endif
1916: )
1917: {
1918: msyslog(LOG_ERR, "ioctl(FIONBIO) fails: %m");
1919: exit(1);
1920: /*NOTREACHED*/
1921: }
1922: #elif defined(FIOSNBIO)
1923: if (ioctl(fd,FIOSNBIO,&on) < 0)
1924: {
1925: msyslog(LOG_ERR, "ioctl(FIOSNBIO) fails: %m");
1926: exit(1);
1927: /*NOTREACHED*/
1928: }
1929: #else
1930: # include "Bletch: Need non-blocking I/O!"
1931: #endif
1932:
1933: #ifdef HAVE_SIGNALED_IO
1934: init_socket_sig(fd);
1935: #endif /* not HAVE_SIGNALED_IO */
1936:
1937: UNBLOCKIO();
1938: }
1939:
1940:
1941: /*
1942: * sendpkt - send a packet to the specified destination
1943: */
1944: static int
1945: sendpkt(
1946: struct sockaddr_in *dest,
1947: struct pkt *pkt,
1948: int len
1949: )
1950: {
1951: int cc;
1952: static int horriblecnt = 0;
1953: #ifdef SYS_WINNT
1954: DWORD err;
1955: #endif /* SYS_WINNT */
1956:
1957: total_xmit++; /* count it */
1958:
1959: if (horrible) {
1960: if (++horriblecnt > HORRIBLEOK) {
1961: if (debug > 3)
1962: printf("dropping send (%s)\n", ntoa(dest));
1963: if (horriblecnt >= HORRIBLEOK+horrible)
1964: horriblecnt = 0;
1965: return 0;
1966: }
1967: }
1968:
1969:
1970: cc = sendto(fd, (char *)pkt, (size_t)len, 0, (struct sockaddr *)dest,
1971: sizeof(struct sockaddr_in));
1972: #ifndef SYS_WINNT
1973: if (cc == -1) {
1974: if (errno != EWOULDBLOCK && errno != ENOBUFS)
1975: #else
1976: if (cc == SOCKET_ERROR) {
1977: err = WSAGetLastError();
1978: if (err != WSAEWOULDBLOCK && err != WSAENOBUFS)
1979: #endif /* SYS_WINNT */
1980: msyslog(LOG_ERR, "sendto(%s): %m", ntoa(dest));
1981: return -1;
1982: }
1983: return 0;
1984: }
1985:
1986:
1987: /*
1988: * input_handler - receive packets asynchronously
1989: */
1990: void
1991: input_handler(l_fp *xts)
1992: {
1993: register int n;
1994: register struct recvbuf *rb;
1995: struct timeval tvzero;
1996: int fromlen;
1997: fd_set fds;
1998: l_fp ts;
1999: ts = *xts; /* we ignore xts, but make the compiler happy */
2000:
2001: /*
2002: * Do a poll to see if we have data
2003: */
2004: for (;;) {
2005: fds = fdmask;
2006: tvzero.tv_sec = tvzero.tv_usec = 0;
2007: n = select(fd+1, &fds, (fd_set *)0, (fd_set *)0, &tvzero);
2008:
2009: /*
2010: * If nothing to do, just return. If an error occurred,
2011: * complain and return. If we've got some, freeze a
2012: * timestamp.
2013: */
2014: if (n == 0)
2015: return;
2016: else if (n == -1) {
2017: if (errno != EINTR) {
2018: msyslog(LOG_ERR, "select() error: %m");
2019: }
2020: return;
2021: }
2022: get_systime(&ts);
2023:
2024: /*
2025: * Get a buffer and read the frame. If we
2026: * haven't got a buffer, or this is received
2027: * on the wild card socket, just dump the packet.
2028: */
2029: if (initializing || free_recvbuffs == 0) {
2030: char buf[100];
2031:
2032: #ifndef SYS_WINNT
2033: (void) read(fd, buf, sizeof buf);
2034: #else
2035: /* NT's _read does not operate on nonblocking sockets
2036: * either recvfrom or ReadFile() has to be used here.
2037: * ReadFile is used in [ntpd]ntp_intres() and ntpdc,
2038: * just to be different use recvfrom() here
2039: */
2040: recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *)0, NULL);
2041: #endif /* SYS_WINNT */
2042: continue;
2043: }
2044:
2045: rb = get_free_recv_buffer();
2046:
2047: fromlen = sizeof(struct sockaddr_in);
2048: rb->recv_length = recvfrom(fd, (char *)&rb->recv_pkt,
2049: sizeof(rb->recv_pkt), 0,
2050: (struct sockaddr *)&rb->srcadr, &fromlen);
2051: if (rb->recv_length == -1) {
2052: freerecvbuf(rb);
2053: continue;
2054: }
2055:
2056: /*
2057: * Got one. Mark how and when it got here,
2058: * put it on the full list.
2059: */
2060: rb->recv_time = ts;
2061: add_full_recv_buffer(rb);
2062: total_recv++; /* count it */
2063: }
2064: }
2065:
2066:
2067: /* XXX ELIMINATE printserver similar in ntptrace.c, ntpdate.c */
2068: /*
2069: * printserver - print detail information for a server
2070: */
2071: static void
2072: printserver(
2073: register struct server *pp,
2074: FILE *fp
2075: )
2076: {
2077: register int i;
2078: char junk[5];
2079: char *str;
2080:
2081: if (!debug) {
2082: (void) fprintf(fp,
2083: "%-15s %d/%d %03o v%d s%d offset %9s delay %s disp %s\n",
2084: ntoa(&pp->srcadr),
2085: pp->xmtcnt,pp->rcvcnt,pp->reach,
2086: pp->version,pp->stratum,
2087: lfptoa(&pp->offset, 6), ufptoa(pp->delay, 5),
2088: ufptoa(pp->dispersion, 4));
2089: return;
2090: }
2091:
2092: (void) fprintf(fp, "server %s, port %d\n",
2093: ntoa(&pp->srcadr), ntohs(pp->srcadr.sin_port));
2094:
2095: (void) fprintf(fp, "stratum %d, precision %d, leap %c%c, trust %03o\n",
2096: pp->stratum, pp->precision,
2097: pp->leap & 0x2 ? '1' : '0',
2098: pp->leap & 0x1 ? '1' : '0',
2099: pp->trust);
2100:
2101: if (pp->stratum == 1) {
2102: junk[4] = 0;
2103: memmove(junk, (char *)&pp->refid, 4);
2104: str = junk;
2105: } else {
2106: str = numtoa(pp->refid);
2107: }
2108: (void) fprintf(fp,
2109: "refid [%s], delay %s, dispersion %s\n",
2110: str, fptoa((s_fp)pp->delay, 5),
2111: ufptoa(pp->dispersion, 5));
2112:
2113: (void) fprintf(fp, "transmitted %d, received %d, reachable %03o\n",
2114: pp->xmtcnt, pp->rcvcnt, pp->reach);
2115:
2116: (void) fprintf(fp, "reference time: %s\n",
2117: prettydate(&pp->reftime));
2118: (void) fprintf(fp, "originate timestamp: %s\n",
2119: prettydate(&pp->org));
2120: (void) fprintf(fp, "transmit timestamp: %s\n",
2121: prettydate(&pp->xmt));
2122:
2123: (void) fprintf(fp, "filter delay: ");
2124: for (i = 0; i < NTP_SHIFT; i++) {
2125: (void) fprintf(fp, " %-8.8s", fptoa(pp->filter_delay[i], 5));
2126: if (i == (NTP_SHIFT>>1)-1)
2127: (void) fprintf(fp, "\n ");
2128: }
2129: (void) fprintf(fp, "\n");
2130:
2131: (void) fprintf(fp, "filter offset:");
2132: for (i = 0; i < PEER_SHIFT; i++) {
2133: (void) fprintf(fp, " %-8.8s", lfptoa(&pp->filter_offset[i], 6));
2134: if (i == (PEER_SHIFT>>1)-1)
2135: (void) fprintf(fp, "\n ");
2136: }
2137: (void) fprintf(fp, "\n");
2138:
2139: (void) fprintf(fp, "delay %s, dispersion %s\n",
2140: fptoa((s_fp)pp->delay, 5), ufptoa(pp->dispersion, 5));
2141:
2142: (void) fprintf(fp, "offset %s\n\n",
2143: lfptoa(&pp->offset, 6));
2144: }
2145:
2146: #if !defined(HAVE_VSPRINTF)
2147: int
2148: vsprintf(
2149: char *str,
2150: const char *fmt,
2151: va_list ap
2152: )
2153: {
2154: FILE f;
2155: int len;
2156:
2157: f._flag = _IOWRT+_IOSTRG;
2158: f._ptr = str;
2159: f._cnt = 32767;
2160: len = _doprnt(fmt, ap, &f);
2161: *f._ptr = 0;
2162: return (len);
2163: }
2164: #endif