1 /*
2 * ntpdate - set the time of day by polling one or more NTP servers
3 */
4
5 #ifdef HAVE_CONFIG_H
6 # include <config.h>
7 #endif
8
9 #ifdef HAVE_NETINFO
10 #include <netinfo/ni.h>
11 #endif
12
13 #include "ntp_machine.h"
14 #include "ntp_fp.h"
15 #include "ntp.h"
16 #include "ntp_io.h"
17 #include "timevalops.h"
18 #include "ntpdate.h"
19 #include "ntp_string.h"
20 #include "ntp_syslog.h"
21 #include "ntp_select.h"
22 #include "ntp_stdlib.h"
23 #include <ssl_applink.c>
24
25 #include "isc/net.h"
26 #include "isc/result.h"
27 #include "isc/sockaddr.h"
28
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32
33 #include <stdio.h>
34 #include <signal.h>
35 #include <ctype.h>
36 #ifdef HAVE_POLL_H
37 # include <poll.h>
38 #endif
39 #ifdef HAVE_SYS_SIGNAL_H
40 # include <sys/signal.h>
41 #endif
42 #ifdef HAVE_SYS_IOCTL_H
43 # include <sys/ioctl.h>
44 #endif
45 #ifdef HAVE_SYS_RESOURCE_H
46 # include <sys/resource.h>
47 #endif
48
49 #include <arpa/inet.h>
50
51 #ifdef SYS_VXWORKS
52 # include "ioLib.h"
53 # include "sockLib.h"
54 # include "timers.h"
55
56 /* select wants a zero structure ... */
57 struct timeval timeout = {0,0};
58 #elif defined(SYS_WINNT)
59 /*
60 * Windows does not abort a select select call if SIGALRM goes off
61 * so a 200 ms timeout is needed (TIMER_HZ is 5).
62 */
63 struct sock_timeval timeout = {0,1000000/TIMER_HZ};
64 #else
65 struct timeval timeout = {60,0};
66 #endif
67
68 #ifdef HAVE_NETINFO
69 #include <netinfo/ni.h>
70 #endif
71
72 #include "recvbuff.h"
73
74 #ifdef SYS_WINNT
75 #define TARGET_RESOLUTION 1 /* Try for 1-millisecond accuracy
76 on Windows NT timers. */
77 #pragma comment(lib, "winmm")
78 isc_boolean_t ntp_port_inuse(int af, u_short port);
79 UINT wTimerRes;
80 #endif /* SYS_WINNT */
81
82 /*
83 * Scheduling priority we run at
84 */
85 #ifndef SYS_VXWORKS
86 # define NTPDATE_PRIO (-12)
87 #else
88 # define NTPDATE_PRIO (100)
89 #endif
90
91 #ifdef HAVE_TIMER_CREATE
92 /* POSIX TIMERS - vxWorks doesn't have itimer - casey */
93 static timer_t ntpdate_timerid;
94 #endif
95
96 /*
97 * Compatibility stuff for Version 2
98 */
99 #define NTP_MAXSKW 0x28f /* 0.01 sec in fp format */
100 #define NTP_MINDIST 0x51f /* 0.02 sec in fp format */
101 #define PEER_MAXDISP (64*FP_SECOND) /* maximum dispersion (fp 64) */
102 #define NTP_INFIN 15 /* max stratum, infinity a la Bellman-Ford */
103 #define NTP_MAXWGT (8*FP_SECOND) /* maximum select weight 8 seconds */
104 #define NTP_MAXLIST 5 /* maximum select list size */
105 #define PEER_SHIFT 8 /* 8 suitable for crystal time base */
106
107 /*
108 * for get_systime()
109 */
110 s_char sys_precision; /* local clock precision (log2 s) */
111
112 /*
113 * File descriptor masks etc. for call to select
114 */
115
116 int ai_fam_templ;
117 int nbsock; /* the number of sockets used */
118 SOCKET fd[MAX_AF];
119 int fd_family[MAX_AF]; /* to remember the socket family */
120 #ifdef HAVE_POLL_H
121 struct pollfd fdmask[MAX_AF];
122 #else
123 fd_set fdmask;
124 SOCKET maxfd;
125 #endif
126 int polltest = 0;
127
128 /*
129 * Initializing flag. All async routines watch this and only do their
130 * thing when it is clear.
131 */
132 int initializing = 1;
133
134 /*
135 * Alarm flag. Set when an alarm occurs
136 */
137 volatile int alarm_flag = 0;
138
139 /*
140 * Simple query flag.
141 */
142 int simple_query = 0;
143
144 /*
145 * Unprivileged port flag.
146 */
147 int unpriv_port = 0;
148
149 /*
150 * Program name.
151 */
152 char const *progname;
153
154 /*
155 * Systemwide parameters and flags
156 */
157 int sys_samples = 0; /* number of samples/server, will be modified later */
158 u_long sys_timeout = DEFTIMEOUT; /* timeout time, in TIMER_HZ units */
159 struct server *sys_servers; /* the server list */
160 int sys_numservers = 0; /* number of servers to poll */
161 int sys_authenticate = 0; /* true when authenticating */
162 u_int32 sys_authkey = 0; /* set to authentication key in use */
163 u_long sys_authdelay = 0; /* authentication delay */
164 int sys_version = NTP_VERSION; /* version to poll with */
165
166 /*
167 * The current internal time
168 */
169 u_long current_time = 0;
170
171 /*
172 * Counter for keeping track of completed servers
173 */
174 int complete_servers = 0;
175
176 /*
177 * File of encryption keys
178 */
179
180 #ifndef KEYFILE
181 # ifndef SYS_WINNT
182 #define KEYFILE "/etc/ntp.keys"
183 # else
184 #define KEYFILE "%windir%\\ntp.keys"
185 # endif /* SYS_WINNT */
186 #endif /* KEYFILE */
187
188 #ifndef SYS_WINNT
189 const char *key_file = KEYFILE;
190 #else
191 char key_file_storage[MAX_PATH+1], *key_file ;
192 #endif /* SYS_WINNT */
193
194 /*
195 * Miscellaneous flags
196 */
197 int verbose = 0;
198 int always_step = 0;
199 int never_step = 0;
200
201 int ntpdatemain (int, char **);
202
203 static void transmit (struct server *);
204 static void receive (struct recvbuf *);
205 static void server_data (struct server *, s_fp, l_fp *, u_fp);
206 static void clock_filter (struct server *);
207 static struct server *clock_select (void);
208 static int clock_adjust (void);
209 static void addserver (char *);
210 static struct server *findserver (sockaddr_u *);
211 void timer (void);
212 static void init_alarm (void);
213 #ifndef SYS_WINNT
214 static RETSIGTYPE alarming (int);
215 #endif /* SYS_WINNT */
216 static void init_io (void);
217 static void sendpkt (sockaddr_u *, struct pkt *, int);
218 void input_handler (void);
219
220 static int l_adj_systime (l_fp *);
221 static int l_step_systime (l_fp *);
222
223 static void print_server (struct server *, FILE *);
224
225 #ifdef SYS_WINNT
226 int on = 1;
227 WORD wVersionRequested;
228 WSADATA wsaData;
229 #endif /* SYS_WINNT */
230
231 #ifdef NO_MAIN_ALLOWED
232 CALL(ntpdate,"ntpdate",ntpdatemain);
233
clear_globals()234 void clear_globals()
235 {
236 /*
237 * Debugging flag
238 */
239 debug = 0;
240
241 ntp_optind = 0;
242 /*
243 * Initializing flag. All async routines watch this and only do their
244 * thing when it is clear.
245 */
246 initializing = 1;
247
248 /*
249 * Alarm flag. Set when an alarm occurs
250 */
251 alarm_flag = 0;
252
253 /*
254 * Simple query flag.
255 */
256 simple_query = 0;
257
258 /*
259 * Unprivileged port flag.
260 */
261 unpriv_port = 0;
262
263 /*
264 * Systemwide parameters and flags
265 */
266 sys_numservers = 0; /* number of servers to poll */
267 sys_authenticate = 0; /* true when authenticating */
268 sys_authkey = 0; /* set to authentication key in use */
269 sys_authdelay = 0; /* authentication delay */
270 sys_version = NTP_VERSION; /* version to poll with */
271
272 /*
273 * The current internal time
274 */
275 current_time = 0;
276
277 /*
278 * Counter for keeping track of completed servers
279 */
280 complete_servers = 0;
281 verbose = 0;
282 always_step = 0;
283 never_step = 0;
284 }
285 #endif
286
287 #ifdef HAVE_NETINFO
288 static ni_namelist *getnetinfoservers (void);
289 #endif
290
291 /*
292 * Main program. Initialize us and loop waiting for I/O and/or
293 * timer expiries.
294 */
295 #ifndef NO_MAIN_ALLOWED
296 int
main(int argc,char * argv[])297 main(
298 int argc,
299 char *argv[]
300 )
301 {
302 return ntpdatemain (argc, argv);
303 }
304 #endif /* NO_MAIN_ALLOWED */
305
306 int
ntpdatemain(int argc,char * argv[])307 ntpdatemain (
308 int argc,
309 char *argv[]
310 )
311 {
312 int was_alarmed;
313 int tot_recvbufs;
314 struct recvbuf *rbuf;
315 l_fp tmp;
316 int errflg;
317 int c;
318 int nfound;
319
320 #ifdef HAVE_NETINFO
321 ni_namelist *netinfoservers;
322 #endif
323 #ifdef SYS_WINNT
324 key_file = key_file_storage;
325
326 if (!ExpandEnvironmentStrings(KEYFILE, key_file, MAX_PATH))
327 msyslog(LOG_ERR, "ExpandEnvironmentStrings(KEYFILE) failed: %m");
328
329 ssl_applink();
330 #endif /* SYS_WINNT */
331
332 #ifdef NO_MAIN_ALLOWED
333 clear_globals();
334 #endif
335
336 init_lib(); /* sets up ipv4_works, ipv6_works */
337
338 /* Check to see if we have IPv6. Otherwise default to IPv4 */
339 if (!ipv6_works)
340 ai_fam_templ = AF_INET;
341
342 errflg = 0;
343 progname = argv[0];
344 syslogit = 0;
345
346 /*
347 * Decode argument list
348 */
349 while ((c = ntp_getopt(argc, argv, "46a:bBde:k:o:p:qst:uv")) != EOF)
350 switch (c)
351 {
352 case '4':
353 ai_fam_templ = AF_INET;
354 break;
355 case '6':
356 ai_fam_templ = AF_INET6;
357 break;
358 case 'a':
359 c = atoi(ntp_optarg);
360 sys_authenticate = 1;
361 sys_authkey = c;
362 break;
363 case 'b':
364 always_step++;
365 never_step = 0;
366 break;
367 case 'B':
368 never_step++;
369 always_step = 0;
370 break;
371 case 'd':
372 ++debug;
373 break;
374 case 'e':
375 if (!atolfp(ntp_optarg, &tmp)
376 || tmp.l_ui != 0) {
377 (void) fprintf(stderr,
378 "%s: encryption delay %s is unlikely\n",
379 progname, ntp_optarg);
380 errflg++;
381 } else {
382 sys_authdelay = tmp.l_uf;
383 }
384 break;
385 case 'k':
386 key_file = ntp_optarg;
387 break;
388 case 'o':
389 sys_version = atoi(ntp_optarg);
390 break;
391 case 'p':
392 c = atoi(ntp_optarg);
393 if (c <= 0 || c > NTP_SHIFT) {
394 (void) fprintf(stderr,
395 "%s: number of samples (%d) is invalid\n",
396 progname, c);
397 errflg++;
398 } else {
399 sys_samples = c;
400 }
401 break;
402 case 'q':
403 simple_query = 1;
404 break;
405 case 's':
406 syslogit = 1;
407 break;
408 case 't':
409 if (!atolfp(ntp_optarg, &tmp)) {
410 (void) fprintf(stderr,
411 "%s: timeout %s is undecodeable\n",
412 progname, ntp_optarg);
413 errflg++;
414 } else {
415 sys_timeout = ((LFPTOFP(&tmp) * TIMER_HZ)
416 + 0x8000) >> 16;
417 sys_timeout = max(sys_timeout, MINTIMEOUT);
418 }
419 break;
420 case 'v':
421 verbose = 1;
422 break;
423 case 'u':
424 unpriv_port = 1;
425 break;
426 case '?':
427 ++errflg;
428 break;
429 default:
430 break;
431 }
432
433 if (errflg) {
434 (void) fprintf(stderr,
435 "usage: %s [-46bBdqsuv] [-a key#] [-e delay] [-k file] [-p samples] [-o version#] [-t timeo] server ...\n",
436 progname);
437 exit(2);
438 }
439
440 /*
441 * If number of Samples (-p) not specified by user:
442 * - if a simple_query (-q) just ONE will do
443 * - otherwise the normal is DEFSAMPLES
444 */
445 if (sys_samples == 0)
446 sys_samples = (simple_query ? 1 : DEFSAMPLES);
447
448 if (debug || simple_query) {
449 #ifdef HAVE_SETVBUF
450 static char buf[BUFSIZ];
451 setvbuf(stdout, buf, _IOLBF, BUFSIZ);
452 #else
453 setlinebuf(stdout);
454 #endif
455 }
456
457 /*
458 * Logging. Open the syslog if we have to
459 */
460 if (syslogit) {
461 #if !defined (SYS_WINNT) && !defined (SYS_VXWORKS) && !defined SYS_CYGWIN32
462 # ifndef LOG_DAEMON
463 openlog("ntpdate", LOG_PID);
464 # else
465
466 # ifndef LOG_NTP
467 # define LOG_NTP LOG_DAEMON
468 # endif
469 openlog("ntpdate", LOG_PID | LOG_NDELAY, LOG_NTP);
470 if (debug)
471 setlogmask(LOG_UPTO(LOG_DEBUG));
472 else
473 setlogmask(LOG_UPTO(LOG_INFO));
474 # endif /* LOG_DAEMON */
475 #endif /* SYS_WINNT */
476 }
477
478 if (debug || verbose)
479 msyslog(LOG_NOTICE, "%s", Version);
480
481 /*
482 * Add servers we are going to be polling
483 */
484 #ifdef HAVE_NETINFO
485 netinfoservers = getnetinfoservers();
486 #endif
487
488 for ( ; ntp_optind < argc; ntp_optind++)
489 addserver(argv[ntp_optind]);
490
491 #ifdef HAVE_NETINFO
492 if (netinfoservers) {
493 if ( netinfoservers->ni_namelist_len &&
494 *netinfoservers->ni_namelist_val ) {
495 u_int servercount = 0;
496 while (servercount < netinfoservers->ni_namelist_len) {
497 if (debug) msyslog(LOG_DEBUG,
498 "Adding time server %s from NetInfo configuration.",
499 netinfoservers->ni_namelist_val[servercount]);
500 addserver(netinfoservers->ni_namelist_val[servercount++]);
501 }
502 }
503 ni_namelist_free(netinfoservers);
504 free(netinfoservers);
505 }
506 #endif
507
508 if (sys_numservers == 0) {
509 msyslog(LOG_ERR, "no servers can be used, exiting");
510 exit(1);
511 }
512
513 /*
514 * Initialize the time of day routines and the I/O subsystem
515 */
516 if (sys_authenticate) {
517 init_auth();
518 if (!authreadkeys(key_file)) {
519 msyslog(LOG_ERR, "no key file <%s>, exiting", key_file);
520 exit(1);
521 }
522 authtrust(sys_authkey, 1);
523 if (!authistrusted(sys_authkey)) {
524 msyslog(LOG_ERR, "authentication key %lu unknown",
525 (unsigned long) sys_authkey);
526 exit(1);
527 }
528 }
529 init_io();
530 init_alarm();
531
532 /*
533 * Set the priority.
534 */
535 #ifdef SYS_VXWORKS
536 taskPrioritySet( taskIdSelf(), NTPDATE_PRIO);
537 #endif
538 #if defined(HAVE_ATT_NICE)
539 nice (NTPDATE_PRIO);
540 #endif
541 #if defined(HAVE_BSD_NICE)
542 (void) setpriority(PRIO_PROCESS, 0, NTPDATE_PRIO);
543 #endif
544
545
546 initializing = 0;
547 was_alarmed = 0;
548
549 while (complete_servers < sys_numservers) {
550 #ifdef HAVE_POLL_H
551 struct pollfd* rdfdes;
552 rdfdes = fdmask;
553 #else
554 fd_set rdfdes;
555 rdfdes = fdmask;
556 #endif
557
558 if (alarm_flag) { /* alarmed? */
559 was_alarmed = 1;
560 alarm_flag = 0;
561 }
562 tot_recvbufs = full_recvbuffs(); /* get received buffers */
563
564 if (!was_alarmed && tot_recvbufs == 0) {
565 /*
566 * Nothing to do. Wait for something.
567 */
568 #ifdef HAVE_POLL_H
569 nfound = poll(rdfdes, (unsigned int)nbsock, timeout.tv_sec * 1000);
570
571 #else
572 nfound = select(maxfd, &rdfdes, NULL, NULL,
573 &timeout);
574 #endif
575 if (nfound > 0)
576 input_handler();
577 else if (nfound == SOCKET_ERROR)
578 {
579 #ifndef SYS_WINNT
580 if (errno != EINTR)
581 #else
582 if (WSAGetLastError() != WSAEINTR)
583 #endif
584 msyslog(LOG_ERR,
585 #ifdef HAVE_POLL_H
586 "poll() error: %m"
587 #else
588 "select() error: %m"
589 #endif
590 );
591 } else if (errno != 0) {
592 #ifndef SYS_VXWORKS
593 msyslog(LOG_DEBUG,
594 #ifdef HAVE_POLL_H
595 "poll(): nfound = %d, error: %m",
596 #else
597 "select(): nfound = %d, error: %m",
598 #endif
599 nfound);
600 #endif
601 }
602 if (alarm_flag) { /* alarmed? */
603 was_alarmed = 1;
604 alarm_flag = 0;
605 }
606 tot_recvbufs = full_recvbuffs(); /* get received buffers */
607 }
608
609 /*
610 * Out here, signals are unblocked. Call receive
611 * procedure for each incoming packet.
612 */
613 rbuf = get_full_recv_buffer();
614 while (rbuf != NULL)
615 {
616 receive(rbuf);
617 freerecvbuf(rbuf);
618 rbuf = get_full_recv_buffer();
619 }
620
621 /*
622 * Call timer to process any timeouts
623 */
624 if (was_alarmed) {
625 timer();
626 was_alarmed = 0;
627 }
628
629 /*
630 * Go around again
631 */
632 }
633
634 /*
635 * When we get here we've completed the polling of all servers.
636 * Adjust the clock, then exit.
637 */
638 #ifdef SYS_WINNT
639 WSACleanup();
640 #endif
641 #ifdef SYS_VXWORKS
642 close (fd);
643 timer_delete(ntpdate_timerid);
644 #endif
645
646 return clock_adjust();
647 }
648
649
650 /*
651 * transmit - transmit a packet to the given server, or mark it completed.
652 * This is called by the timeout routine and by the receive
653 * procedure.
654 */
655 static void
transmit(register struct server * server)656 transmit(
657 register struct server *server
658 )
659 {
660 struct pkt xpkt;
661
662 if (server->filter_nextpt < server->xmtcnt) {
663 l_fp ts;
664 /*
665 * Last message to this server timed out. Shift
666 * zeros into the filter.
667 */
668 L_CLR(&ts);
669 server_data(server, 0, &ts, 0);
670 }
671
672 if ((int)server->filter_nextpt >= sys_samples) {
673 /*
674 * Got all the data we need. Mark this guy
675 * completed and return.
676 */
677 server->event_time = 0;
678 complete_servers++;
679 return;
680 }
681
682 if (debug)
683 printf("transmit(%s)\n", stoa(&server->srcadr));
684
685 /*
686 * If we're here, send another message to the server. Fill in
687 * the packet and let 'er rip.
688 */
689 xpkt.li_vn_mode = PKT_LI_VN_MODE(LEAP_NOTINSYNC,
690 sys_version, MODE_CLIENT);
691 xpkt.stratum = STRATUM_TO_PKT(STRATUM_UNSPEC);
692 xpkt.ppoll = NTP_MINPOLL;
693 xpkt.precision = NTPDATE_PRECISION;
694 xpkt.rootdelay = htonl(NTPDATE_DISTANCE);
695 xpkt.rootdisp = htonl(NTPDATE_DISP);
696 xpkt.refid = htonl(NTPDATE_REFID);
697 L_CLR(&xpkt.reftime);
698 L_CLR(&xpkt.org);
699 L_CLR(&xpkt.rec);
700
701 /*
702 * Determine whether to authenticate or not. If so,
703 * fill in the extended part of the packet and do it.
704 * If not, just timestamp it and send it away.
705 */
706 if (sys_authenticate) {
707 size_t len;
708
709 xpkt.exten[0] = htonl(sys_authkey);
710 get_systime(&server->xmt);
711 L_ADDUF(&server->xmt, sys_authdelay);
712 HTONL_FP(&server->xmt, &xpkt.xmt);
713 len = authencrypt(sys_authkey, (u_int32 *)&xpkt, LEN_PKT_NOMAC);
714 sendpkt(&server->srcadr, &xpkt, (int)(LEN_PKT_NOMAC + len));
715
716 if (debug > 1)
717 printf("transmit auth to %s\n",
718 stoa(&server->srcadr));
719 } else {
720 get_systime(&(server->xmt));
721 HTONL_FP(&server->xmt, &xpkt.xmt);
722 sendpkt(&server->srcadr, &xpkt, LEN_PKT_NOMAC);
723
724 if (debug > 1)
725 printf("transmit to %s\n", stoa(&server->srcadr));
726 }
727
728 /*
729 * Update the server timeout and transmit count
730 */
731 server->event_time = current_time + sys_timeout;
732 server->xmtcnt++;
733 }
734
735
736 /*
737 * receive - receive and process an incoming frame
738 */
739 static void
receive(struct recvbuf * rbufp)740 receive(
741 struct recvbuf *rbufp
742 )
743 {
744 register struct pkt *rpkt;
745 register struct server *server;
746 register s_fp di;
747 l_fp t10, t23, tmp;
748 l_fp org;
749 l_fp rec;
750 l_fp ci;
751 int has_mac;
752 int is_authentic;
753
754 if (debug)
755 printf("receive(%s)\n", stoa(&rbufp->recv_srcadr));
756 /*
757 * Check to see if the packet basically looks like something
758 * intended for us.
759 */
760 if (rbufp->recv_length == LEN_PKT_NOMAC)
761 has_mac = 0;
762 else if (rbufp->recv_length >= (int)LEN_PKT_NOMAC)
763 has_mac = 1;
764 else {
765 if (debug)
766 printf("receive: packet length %d\n",
767 rbufp->recv_length);
768 return; /* funny length packet */
769 }
770
771 rpkt = &(rbufp->recv_pkt);
772 if (PKT_VERSION(rpkt->li_vn_mode) < NTP_OLDVERSION ||
773 PKT_VERSION(rpkt->li_vn_mode) > NTP_VERSION) {
774 return;
775 }
776
777 if ((PKT_MODE(rpkt->li_vn_mode) != MODE_SERVER
778 && PKT_MODE(rpkt->li_vn_mode) != MODE_PASSIVE)
779 || rpkt->stratum >= STRATUM_UNSPEC) {
780 if (debug)
781 printf("receive: mode %d stratum %d\n",
782 PKT_MODE(rpkt->li_vn_mode), rpkt->stratum);
783 return;
784 }
785
786 /*
787 * So far, so good. See if this is from a server we know.
788 */
789 server = findserver(&(rbufp->recv_srcadr));
790 if (server == NULL) {
791 if (debug)
792 printf("receive: server not found\n");
793 return;
794 }
795
796 /*
797 * Decode the org timestamp and make sure we're getting a response
798 * to our last request.
799 */
800 NTOHL_FP(&rpkt->org, &org);
801 if (!L_ISEQU(&org, &server->xmt)) {
802 if (debug)
803 printf("receive: pkt.org and peer.xmt differ\n");
804 return;
805 }
806
807 /*
808 * Check out the authenticity if we're doing that.
809 */
810 if (!sys_authenticate)
811 is_authentic = 1;
812 else {
813 is_authentic = 0;
814
815 if (debug > 3)
816 printf("receive: rpkt keyid=%ld sys_authkey=%ld decrypt=%ld\n",
817 (long int)ntohl(rpkt->exten[0]), (long int)sys_authkey,
818 (long int)authdecrypt(sys_authkey, (u_int32 *)rpkt,
819 LEN_PKT_NOMAC, (size_t)(rbufp->recv_length - LEN_PKT_NOMAC)));
820
821 if (has_mac && ntohl(rpkt->exten[0]) == sys_authkey &&
822 authdecrypt(sys_authkey, (u_int32 *)rpkt, LEN_PKT_NOMAC,
823 (size_t)(rbufp->recv_length - LEN_PKT_NOMAC)))
824 is_authentic = 1;
825 if (debug)
826 printf("receive: authentication %s\n",
827 is_authentic ? "passed" : "failed");
828 }
829 server->trust <<= 1;
830 if (!is_authentic)
831 server->trust |= 1;
832
833 /*
834 * Check for a KoD (rate limiting) response, cease and decist.
835 */
836 if (LEAP_NOTINSYNC == PKT_LEAP(rpkt->li_vn_mode) &&
837 STRATUM_PKT_UNSPEC == rpkt->stratum &&
838 !memcmp("RATE", &rpkt->refid, 4)) {
839 msyslog(LOG_ERR, "%s rate limit response from server.",
840 stoa(&rbufp->recv_srcadr));
841 server->event_time = 0;
842 complete_servers++;
843 return;
844 }
845
846 /*
847 * Looks good. Record info from the packet.
848 */
849 server->leap = PKT_LEAP(rpkt->li_vn_mode);
850 server->stratum = PKT_TO_STRATUM(rpkt->stratum);
851 server->precision = rpkt->precision;
852 server->rootdelay = ntohl(rpkt->rootdelay);
853 server->rootdisp = ntohl(rpkt->rootdisp);
854 server->refid = rpkt->refid;
855 NTOHL_FP(&rpkt->reftime, &server->reftime);
856 NTOHL_FP(&rpkt->rec, &rec);
857 NTOHL_FP(&rpkt->xmt, &server->org);
858
859 /*
860 * Make sure the server is at least somewhat sane. If not, try
861 * again.
862 */
863 if (L_ISZERO(&rec) || !L_ISHIS(&server->org, &rec)) {
864 server->event_time = current_time + sys_timeout;
865 return;
866 }
867
868 /*
869 * Calculate the round trip delay (di) and the clock offset (ci).
870 * We use the equations (reordered from those in the spec):
871 *
872 * d = (t2 - t3) - (t1 - t0)
873 * c = ((t2 - t3) + (t1 - t0)) / 2
874 */
875 t10 = server->org; /* pkt.xmt == t1 */
876 L_SUB(&t10, &rbufp->recv_time); /* recv_time == t0*/
877
878 t23 = rec; /* pkt.rec == t2 */
879 L_SUB(&t23, &org); /* pkt->org == t3 */
880
881 /* now have (t2 - t3) and (t0 - t1). Calculate (ci) and (di) */
882 /*
883 * Calculate (ci) = ((t1 - t0) / 2) + ((t2 - t3) / 2)
884 * For large offsets this may prevent an overflow on '+'
885 */
886 ci = t10;
887 L_RSHIFT(&ci);
888 tmp = t23;
889 L_RSHIFT(&tmp);
890 L_ADD(&ci, &tmp);
891
892 /*
893 * Calculate di in t23 in full precision, then truncate
894 * to an s_fp.
895 */
896 L_SUB(&t23, &t10);
897 di = LFPTOFP(&t23);
898
899 if (debug > 3)
900 printf("offset: %s, delay %s\n", lfptoa(&ci, 6), fptoa(di, 5));
901
902 di += (FP_SECOND >> (-(int)NTPDATE_PRECISION))
903 + (FP_SECOND >> (-(int)server->precision)) + NTP_MAXSKW;
904
905 if (di <= 0) { /* value still too raunchy to use? */
906 L_CLR(&ci);
907 di = 0;
908 } else {
909 di = max(di, NTP_MINDIST);
910 }
911
912 /*
913 * Shift this data in, then schedule another transmit.
914 */
915 server_data(server, (s_fp) di, &ci, 0);
916
917 if ((int)server->filter_nextpt >= sys_samples) {
918 /*
919 * Got all the data we need. Mark this guy
920 * completed and return.
921 */
922 server->event_time = 0;
923 complete_servers++;
924 return;
925 }
926
927 server->event_time = current_time + sys_timeout;
928 }
929
930
931 /*
932 * server_data - add a sample to the server's filter registers
933 */
934 static void
server_data(register struct server * server,s_fp d,l_fp * c,u_fp e)935 server_data(
936 register struct server *server,
937 s_fp d,
938 l_fp *c,
939 u_fp e
940 )
941 {
942 u_short i;
943
944 i = server->filter_nextpt;
945 if (i < NTP_SHIFT) {
946 server->filter_delay[i] = d;
947 server->filter_offset[i] = *c;
948 server->filter_soffset[i] = LFPTOFP(c);
949 server->filter_error[i] = e;
950 server->filter_nextpt = (u_short)(i + 1);
951 }
952 }
953
954
955 /*
956 * clock_filter - determine a server's delay, dispersion and offset
957 */
958 static void
clock_filter(register struct server * server)959 clock_filter(
960 register struct server *server
961 )
962 {
963 register int i, j;
964 int ord[NTP_SHIFT];
965
966 INSIST((0 < sys_samples) && (sys_samples <= NTP_SHIFT));
967
968 /*
969 * Sort indices into increasing delay order
970 */
971 for (i = 0; i < sys_samples; i++)
972 ord[i] = i;
973
974 for (i = 0; i < (sys_samples-1); i++) {
975 for (j = i+1; j < sys_samples; j++) {
976 if (server->filter_delay[ord[j]] == 0)
977 continue;
978 if (server->filter_delay[ord[i]] == 0
979 || (server->filter_delay[ord[i]]
980 > server->filter_delay[ord[j]])) {
981 register int tmp;
982
983 tmp = ord[i];
984 ord[i] = ord[j];
985 ord[j] = tmp;
986 }
987 }
988 }
989
990 /*
991 * Now compute the dispersion, and assign values to delay and
992 * offset. If there are no samples in the register, delay and
993 * offset go to zero and dispersion is set to the maximum.
994 */
995 if (server->filter_delay[ord[0]] == 0) {
996 server->delay = 0;
997 L_CLR(&server->offset);
998 server->soffset = 0;
999 server->dispersion = PEER_MAXDISP;
1000 } else {
1001 register s_fp d;
1002
1003 server->delay = server->filter_delay[ord[0]];
1004 server->offset = server->filter_offset[ord[0]];
1005 server->soffset = LFPTOFP(&server->offset);
1006 server->dispersion = 0;
1007 for (i = 1; i < sys_samples; i++) {
1008 if (server->filter_delay[ord[i]] == 0)
1009 d = PEER_MAXDISP;
1010 else {
1011 d = server->filter_soffset[ord[i]]
1012 - server->filter_soffset[ord[0]];
1013 if (d < 0)
1014 d = -d;
1015 if (d > PEER_MAXDISP)
1016 d = PEER_MAXDISP;
1017 }
1018 /*
1019 * XXX This *knows* PEER_FILTER is 1/2
1020 */
1021 server->dispersion += (u_fp)(d) >> i;
1022 }
1023 }
1024 /*
1025 * We're done
1026 */
1027 }
1028
1029
1030 /*
1031 * clock_select - select the pick-of-the-litter clock from the samples
1032 * we've got.
1033 */
1034 static struct server *
clock_select(void)1035 clock_select(void)
1036 {
1037 struct server *server;
1038 u_int nlist;
1039 s_fp d;
1040 u_int count;
1041 u_int i;
1042 u_int j;
1043 u_int k;
1044 int n;
1045 s_fp local_threshold;
1046 struct server *server_list[NTP_MAXCLOCK];
1047 u_fp server_badness[NTP_MAXCLOCK];
1048 struct server *sys_server;
1049
1050 /*
1051 * This first chunk of code is supposed to go through all
1052 * servers we know about to find the NTP_MAXLIST servers which
1053 * are most likely to succeed. We run through the list
1054 * doing the sanity checks and trying to insert anyone who
1055 * looks okay. We are at all times aware that we should
1056 * only keep samples from the top two strata and we only need
1057 * NTP_MAXLIST of them.
1058 */
1059 nlist = 0; /* none yet */
1060 for (server = sys_servers; server != NULL; server = server->next_server) {
1061 if (server->stratum == 0) {
1062 if (debug)
1063 printf("%s: Server dropped: no data\n", ntoa(&server->srcadr));
1064 continue; /* no data */
1065 }
1066 if (server->stratum > NTP_INFIN) {
1067 if (debug)
1068 printf("%s: Server dropped: strata too high\n", ntoa(&server->srcadr));
1069 continue; /* stratum no good */
1070 }
1071 if (server->delay > NTP_MAXWGT) {
1072 if (debug)
1073 printf("%s: Server dropped: server too far away\n",
1074 ntoa(&server->srcadr));
1075 continue; /* too far away */
1076 }
1077 if (server->leap == LEAP_NOTINSYNC) {
1078 if (debug)
1079 printf("%s: Server dropped: leap not in sync\n", ntoa(&server->srcadr));
1080 continue; /* he's in trouble */
1081 }
1082 if (!L_ISHIS(&server->org, &server->reftime)) {
1083 if (debug)
1084 printf("%s: Server dropped: server is very broken\n",
1085 ntoa(&server->srcadr));
1086 continue; /* very broken host */
1087 }
1088 if ((server->org.l_ui - server->reftime.l_ui)
1089 >= NTP_MAXAGE) {
1090 if (debug)
1091 printf("%s: Server dropped: server has gone too long without sync\n",
1092 ntoa(&server->srcadr));
1093 continue; /* too long without sync */
1094 }
1095 if (server->trust != 0) {
1096 if (debug)
1097 printf("%s: Server dropped: Server is untrusted\n",
1098 ntoa(&server->srcadr));
1099 continue;
1100 }
1101
1102 /*
1103 * This one seems sane. Find where he belongs
1104 * on the list.
1105 */
1106 d = server->dispersion + server->dispersion;
1107 for (i = 0; i < nlist; i++)
1108 if (server->stratum <= server_list[i]->stratum)
1109 break;
1110 for ( ; i < nlist; i++) {
1111 if (server->stratum < server_list[i]->stratum)
1112 break;
1113 if (d < (s_fp) server_badness[i])
1114 break;
1115 }
1116
1117 /*
1118 * If i points past the end of the list, this
1119 * guy is a loser, else stick him in.
1120 */
1121 if (i >= NTP_MAXLIST)
1122 continue;
1123 for (j = nlist; j > i; j--)
1124 if (j < NTP_MAXLIST) {
1125 server_list[j] = server_list[j-1];
1126 server_badness[j]
1127 = server_badness[j-1];
1128 }
1129
1130 server_list[i] = server;
1131 server_badness[i] = d;
1132 if (nlist < NTP_MAXLIST)
1133 nlist++;
1134 }
1135
1136 /*
1137 * Got the five-or-less best. Cut the list where the number of
1138 * strata exceeds two.
1139 */
1140 count = 0;
1141 for (i = 1; i < nlist; i++)
1142 if (server_list[i]->stratum > server_list[i-1]->stratum) {
1143 count++;
1144 if (2 == count) {
1145 nlist = i;
1146 break;
1147 }
1148 }
1149
1150 /*
1151 * Whew! What we should have by now is 0 to 5 candidates for
1152 * the job of syncing us. If we have none, we're out of luck.
1153 * If we have one, he's a winner. If we have more, do falseticker
1154 * detection.
1155 */
1156
1157 if (0 == nlist)
1158 sys_server = NULL;
1159 else if (1 == nlist) {
1160 sys_server = server_list[0];
1161 } else {
1162 /*
1163 * Re-sort by stratum, bdelay estimate quality and
1164 * server.delay.
1165 */
1166 for (i = 0; i < nlist-1; i++)
1167 for (j = i+1; j < nlist; j++) {
1168 if (server_list[i]->stratum <
1169 server_list[j]->stratum)
1170 /* already sorted by stratum */
1171 break;
1172 if (server_list[i]->delay <
1173 server_list[j]->delay)
1174 continue;
1175 server = server_list[i];
1176 server_list[i] = server_list[j];
1177 server_list[j] = server;
1178 }
1179
1180 /*
1181 * Calculate the fixed part of the dispersion limit
1182 */
1183 local_threshold = (FP_SECOND >> (-(int)NTPDATE_PRECISION))
1184 + NTP_MAXSKW;
1185
1186 /*
1187 * Now drop samples until we're down to one.
1188 */
1189 while (nlist > 1) {
1190 for (k = 0; k < nlist; k++) {
1191 server_badness[k] = 0;
1192 for (j = 0; j < nlist; j++) {
1193 if (j == k) /* with self? */
1194 continue;
1195 d = server_list[j]->soffset -
1196 server_list[k]->soffset;
1197 if (d < 0) /* abs value */
1198 d = -d;
1199 /*
1200 * XXX This code *knows* that
1201 * NTP_SELECT is 3/4
1202 */
1203 for (i = 0; i < j; i++)
1204 d = (d>>1) + (d>>2);
1205 server_badness[k] += d;
1206 }
1207 }
1208
1209 /*
1210 * We now have an array of nlist badness
1211 * coefficients. Find the badest. Find
1212 * the minimum precision while we're at
1213 * it.
1214 */
1215 i = 0;
1216 n = server_list[0]->precision;;
1217 for (j = 1; j < nlist; j++) {
1218 if (server_badness[j] >= server_badness[i])
1219 i = j;
1220 if (n > server_list[j]->precision)
1221 n = server_list[j]->precision;
1222 }
1223
1224 /*
1225 * i is the index of the server with the worst
1226 * dispersion. If his dispersion is less than
1227 * the threshold, stop now, else delete him and
1228 * continue around again.
1229 */
1230 if ( (s_fp) server_badness[i] < (local_threshold
1231 + (FP_SECOND >> (-n))))
1232 break;
1233 for (j = i + 1; j < nlist; j++)
1234 server_list[j-1] = server_list[j];
1235 nlist--;
1236 }
1237
1238 /*
1239 * What remains is a list of less than 5 servers. Take
1240 * the best.
1241 */
1242 sys_server = server_list[0];
1243 }
1244
1245 /*
1246 * That's it. Return our server.
1247 */
1248 return sys_server;
1249 }
1250
1251
1252 /*
1253 * clock_adjust - process what we've received, and adjust the time
1254 * if we got anything decent.
1255 */
1256 static int
clock_adjust(void)1257 clock_adjust(void)
1258 {
1259 register struct server *sp, *server;
1260 int dostep;
1261
1262 for (sp = sys_servers; sp != NULL; sp = sp->next_server)
1263 clock_filter(sp);
1264 server = clock_select();
1265
1266 if (debug || simple_query) {
1267 if (debug)
1268 printf ("\n");
1269 for (sp = sys_servers; sp != NULL; sp = sp->next_server)
1270 print_server(sp, stdout);
1271 }
1272
1273 if (server == 0) {
1274 msyslog(LOG_ERR,
1275 "no server suitable for synchronization found");
1276 return(1);
1277 }
1278
1279 if (always_step) {
1280 dostep = 1;
1281 } else if (never_step) {
1282 dostep = 0;
1283 } else {
1284 /* [Bug 3023] get absolute difference, avoiding signed
1285 * integer overflow like hell.
1286 */
1287 u_fp absoffset;
1288 if (server->soffset < 0)
1289 absoffset = 1u + (u_fp)(-(server->soffset + 1));
1290 else
1291 absoffset = (u_fp)server->soffset;
1292 dostep = (absoffset >= NTPDATE_THRESHOLD);
1293 }
1294
1295 if (dostep) {
1296 if (simple_query || l_step_systime(&server->offset)){
1297 msyslog(LOG_NOTICE, "step time server %s offset %s sec",
1298 stoa(&server->srcadr),
1299 lfptoa(&server->offset, 6));
1300 }
1301 } else {
1302 if (simple_query || l_adj_systime(&server->offset)) {
1303 msyslog(LOG_NOTICE, "adjust time server %s offset %s sec",
1304 stoa(&server->srcadr),
1305 lfptoa(&server->offset, 6));
1306 }
1307 }
1308 return(0);
1309 }
1310
1311
1312 /*
1313 * is_unreachable - check to see if we have a route to given destination
1314 * (non-blocking).
1315 */
1316 static int
is_reachable(sockaddr_u * dst)1317 is_reachable (sockaddr_u *dst)
1318 {
1319 SOCKET sockfd;
1320
1321 sockfd = socket(AF(dst), SOCK_DGRAM, 0);
1322 if (sockfd == -1) {
1323 return 0;
1324 }
1325
1326 if (connect(sockfd, &dst->sa, SOCKLEN(dst))) {
1327 closesocket(sockfd);
1328 return 0;
1329 }
1330 closesocket(sockfd);
1331 return 1;
1332 }
1333
1334
1335
1336 /* XXX ELIMINATE: merge BIG slew into adj_systime in lib/systime.c */
1337 /*
1338 * addserver - determine a server's address and allocate a new structure
1339 * for it.
1340 */
1341 static void
addserver(char * serv)1342 addserver(
1343 char *serv
1344 )
1345 {
1346 register struct server *server;
1347 /* Address infos structure to store result of getaddrinfo */
1348 struct addrinfo *addrResult, *ptr;
1349 /* Address infos structure to store hints for getaddrinfo */
1350 struct addrinfo hints;
1351 /* Error variable for getaddrinfo */
1352 int error;
1353 /* Service name */
1354 char service[5];
1355 sockaddr_u addr;
1356
1357 strlcpy(service, "ntp", sizeof(service));
1358
1359 /* Get host address. Looking for UDP datagram connection. */
1360 ZERO(hints);
1361 hints.ai_family = ai_fam_templ;
1362 hints.ai_socktype = SOCK_DGRAM;
1363
1364 #ifdef DEBUG
1365 if (debug)
1366 printf("Looking for host %s and service %s\n", serv, service);
1367 #endif
1368
1369 error = getaddrinfo(serv, service, &hints, &addrResult);
1370 if (error != 0) {
1371 /* Conduct more refined error analysis */
1372 if (error == EAI_FAIL || error == EAI_AGAIN){
1373 /* Name server is unusable. Exit after failing on the
1374 first server, in order to shorten the timeout caused
1375 by waiting for resolution of several servers */
1376 fprintf(stderr, "Exiting, name server cannot be used: %s (%d)",
1377 gai_strerror(error), error);
1378 msyslog(LOG_ERR, "name server cannot be used: %s (%d)",
1379 gai_strerror(error), error);
1380 exit(1);
1381 }
1382 fprintf(stderr, "Error resolving %s: %s (%d)\n", serv,
1383 gai_strerror(error), error);
1384 msyslog(LOG_ERR, "Can't find host %s: %s (%d)", serv,
1385 gai_strerror(error), error);
1386 return;
1387 }
1388 #ifdef DEBUG
1389 if (debug) {
1390 ZERO(addr);
1391 INSIST(addrResult->ai_addrlen <= sizeof(addr));
1392 memcpy(&addr, addrResult->ai_addr, addrResult->ai_addrlen);
1393 fprintf(stderr, "host found : %s\n", stohost(&addr));
1394 }
1395 #endif
1396
1397 /* We must get all returned server in case the first one fails */
1398 for (ptr = addrResult; ptr != NULL; ptr = ptr->ai_next) {
1399 ZERO(addr);
1400 INSIST(ptr->ai_addrlen <= sizeof(addr));
1401 memcpy(&addr, ptr->ai_addr, ptr->ai_addrlen);
1402 if (is_reachable(&addr)) {
1403 server = emalloc_zero(sizeof(*server));
1404 memcpy(&server->srcadr, ptr->ai_addr, ptr->ai_addrlen);
1405 server->event_time = ++sys_numservers;
1406 if (sys_servers == NULL)
1407 sys_servers = server;
1408 else {
1409 struct server *sp;
1410
1411 for (sp = sys_servers; sp->next_server != NULL;
1412 sp = sp->next_server)
1413 /* empty */;
1414 sp->next_server = server;
1415 }
1416 }
1417 }
1418
1419 freeaddrinfo(addrResult);
1420 }
1421
1422
1423 /*
1424 * findserver - find a server in the list given its address
1425 * ***(For now it isn't totally AF-Independant, to check later..)
1426 */
1427 static struct server *
findserver(sockaddr_u * addr)1428 findserver(
1429 sockaddr_u *addr
1430 )
1431 {
1432 struct server *server;
1433 struct server *mc_server;
1434
1435 mc_server = NULL;
1436 if (SRCPORT(addr) != NTP_PORT)
1437 return 0;
1438
1439 for (server = sys_servers; server != NULL;
1440 server = server->next_server) {
1441 if (SOCK_EQ(addr, &server->srcadr))
1442 return server;
1443
1444 if (AF(addr) == AF(&server->srcadr)) {
1445 if (IS_MCAST(&server->srcadr))
1446 mc_server = server;
1447 }
1448 }
1449
1450 if (mc_server != NULL) {
1451
1452 struct server *sp;
1453
1454 if (mc_server->event_time != 0) {
1455 mc_server->event_time = 0;
1456 complete_servers++;
1457 }
1458
1459 server = emalloc_zero(sizeof(*server));
1460
1461 server->srcadr = *addr;
1462
1463 server->event_time = ++sys_numservers;
1464
1465 for (sp = sys_servers; sp->next_server != NULL;
1466 sp = sp->next_server)
1467 /* empty */;
1468 sp->next_server = server;
1469 transmit(server);
1470 }
1471 return NULL;
1472 }
1473
1474
1475 /*
1476 * timer - process a timer interrupt
1477 */
1478 void
timer(void)1479 timer(void)
1480 {
1481 struct server *server;
1482
1483 /*
1484 * Bump the current idea of the time
1485 */
1486 current_time++;
1487
1488 /*
1489 * Search through the server list looking for guys
1490 * who's event timers have expired. Give these to
1491 * the transmit routine.
1492 */
1493 for (server = sys_servers; server != NULL;
1494 server = server->next_server) {
1495 if (server->event_time != 0
1496 && server->event_time <= current_time)
1497 transmit(server);
1498 }
1499 }
1500
1501
1502 /*
1503 * The code duplication in the following subroutine sucks, but
1504 * we need to appease ansi2knr.
1505 */
1506
1507 #ifndef SYS_WINNT
1508 /*
1509 * alarming - record the occurance of an alarm interrupt
1510 */
1511 static RETSIGTYPE
alarming(int sig)1512 alarming(
1513 int sig
1514 )
1515 {
1516 alarm_flag++;
1517 }
1518 #else /* SYS_WINNT follows */
1519 void CALLBACK
alarming(UINT uTimerID,UINT uMsg,DWORD dwUser,DWORD dw1,DWORD dw2)1520 alarming(UINT uTimerID, UINT uMsg, DWORD dwUser, DWORD dw1, DWORD dw2)
1521 {
1522 UNUSED_ARG(uTimerID); UNUSED_ARG(uMsg); UNUSED_ARG(dwUser);
1523 UNUSED_ARG(dw1); UNUSED_ARG(dw2);
1524
1525 alarm_flag++;
1526 }
1527
1528 static void
callTimeEndPeriod(void)1529 callTimeEndPeriod(void)
1530 {
1531 timeEndPeriod( wTimerRes );
1532 wTimerRes = 0;
1533 }
1534 #endif /* SYS_WINNT */
1535
1536
1537 /*
1538 * init_alarm - set up the timer interrupt
1539 */
1540 static void
init_alarm(void)1541 init_alarm(void)
1542 {
1543 #ifndef SYS_WINNT
1544 # ifdef HAVE_TIMER_CREATE
1545 struct itimerspec its;
1546 # else
1547 struct itimerval itv;
1548 # endif
1549 #else /* SYS_WINNT follows */
1550 TIMECAPS tc;
1551 UINT wTimerID;
1552 HANDLE hToken;
1553 TOKEN_PRIVILEGES tkp;
1554 DWORD dwUser = 0;
1555 #endif /* SYS_WINNT */
1556
1557 alarm_flag = 0;
1558
1559 #ifndef SYS_WINNT
1560 # ifdef HAVE_TIMER_CREATE
1561 alarm_flag = 0;
1562 /* this code was put in as setitimer() is non existant this us the
1563 * POSIX "equivalents" setup - casey
1564 */
1565 /* ntpdate_timerid is global - so we can kill timer later */
1566 if (timer_create (CLOCK_REALTIME, NULL, &ntpdate_timerid) ==
1567 # ifdef SYS_VXWORKS
1568 ERROR
1569 # else
1570 -1
1571 # endif
1572 )
1573 {
1574 fprintf (stderr, "init_alarm(): timer_create (...) FAILED\n");
1575 return;
1576 }
1577
1578 /* TIMER_HZ = (5)
1579 * Set up the alarm interrupt. The first comes 1/(2*TIMER_HZ)
1580 * seconds from now and they continue on every 1/TIMER_HZ seconds.
1581 */
1582 signal_no_reset(SIGALRM, alarming);
1583 its.it_interval.tv_sec = 0;
1584 its.it_value.tv_sec = 0;
1585 its.it_interval.tv_nsec = 1000000000/TIMER_HZ;
1586 its.it_value.tv_nsec = 1000000000/(TIMER_HZ<<1);
1587 timer_settime(ntpdate_timerid, 0 /* !TIMER_ABSTIME */, &its, NULL);
1588 # else /* !HAVE_TIMER_CREATE follows */
1589 /*
1590 * Set up the alarm interrupt. The first comes 1/(2*TIMER_HZ)
1591 * seconds from now and they continue on every 1/TIMER_HZ seconds.
1592 */
1593 signal_no_reset(SIGALRM, alarming);
1594 itv.it_interval.tv_sec = 0;
1595 itv.it_value.tv_sec = 0;
1596 itv.it_interval.tv_usec = 1000000/TIMER_HZ;
1597 itv.it_value.tv_usec = 1000000/(TIMER_HZ<<1);
1598
1599 setitimer(ITIMER_REAL, &itv, NULL);
1600 # endif /* !HAVE_TIMER_CREATE */
1601 #else /* SYS_WINNT follows */
1602 _tzset();
1603
1604 if (!simple_query && !debug) {
1605 /*
1606 * Get privileges needed for fiddling with the clock
1607 */
1608
1609 /* get the current process token handle */
1610 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
1611 msyslog(LOG_ERR, "OpenProcessToken failed: %m");
1612 exit(1);
1613 }
1614 /* get the LUID for system-time privilege. */
1615 LookupPrivilegeValue(NULL, SE_SYSTEMTIME_NAME, &tkp.Privileges[0].Luid);
1616 tkp.PrivilegeCount = 1; /* one privilege to set */
1617 tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
1618 /* get set-time privilege for this process. */
1619 AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,(PTOKEN_PRIVILEGES) NULL, 0);
1620 /* cannot test return value of AdjustTokenPrivileges. */
1621 if (GetLastError() != ERROR_SUCCESS)
1622 msyslog(LOG_ERR, "AdjustTokenPrivileges failed: %m");
1623 }
1624
1625 /*
1626 * Set up timer interrupts for every 2**EVENT_TIMEOUT seconds
1627 * Under Win/NT, expiry of timer interval leads to invocation
1628 * of a callback function (on a different thread) rather than
1629 * generating an alarm signal
1630 */
1631
1632 /* determine max and min resolution supported */
1633 if(timeGetDevCaps(&tc, sizeof(TIMECAPS)) != TIMERR_NOERROR) {
1634 msyslog(LOG_ERR, "timeGetDevCaps failed: %m");
1635 exit(1);
1636 }
1637 wTimerRes = min(max(tc.wPeriodMin, TARGET_RESOLUTION), tc.wPeriodMax);
1638 /* establish the minimum timer resolution that we'll use */
1639 timeBeginPeriod(wTimerRes);
1640 atexit(callTimeEndPeriod);
1641
1642 /* start the timer event */
1643 wTimerID = timeSetEvent(
1644 (UINT) (1000/TIMER_HZ), /* Delay */
1645 wTimerRes, /* Resolution */
1646 (LPTIMECALLBACK) alarming, /* Callback function */
1647 (DWORD) dwUser, /* User data */
1648 TIME_PERIODIC); /* Event type (periodic) */
1649 if (wTimerID == 0) {
1650 msyslog(LOG_ERR, "timeSetEvent failed: %m");
1651 exit(1);
1652 }
1653 #endif /* SYS_WINNT */
1654 }
1655
1656
1657
1658
1659 /*
1660 * We do asynchronous input using the SIGIO facility. A number of
1661 * recvbuf buffers are preallocated for input. In the signal
1662 * handler we poll to see if the socket is ready and read the
1663 * packets from it into the recvbuf's along with a time stamp and
1664 * an indication of the source host and the interface it was received
1665 * through. This allows us to get as accurate receive time stamps
1666 * as possible independent of other processing going on.
1667 *
1668 * We allocate a number of recvbufs equal to the number of servers
1669 * plus 2. This should be plenty.
1670 */
1671
1672
1673 /*
1674 * init_io - initialize I/O data and open socket
1675 */
1676 static void
init_io(void)1677 init_io(void)
1678 {
1679 struct addrinfo *res, *ressave;
1680 struct addrinfo hints;
1681 sockaddr_u addr;
1682 char service[5];
1683 int rc;
1684 int optval = 1;
1685 int check_ntp_port_in_use = !debug && !simple_query && !unpriv_port;
1686
1687 /*
1688 * Init buffer free list and stat counters
1689 */
1690 init_recvbuff(sys_numservers + 2);
1691
1692 /*
1693 * Open the socket
1694 */
1695
1696 strlcpy(service, "ntp", sizeof(service));
1697
1698 /*
1699 * Init hints addrinfo structure
1700 */
1701 ZERO(hints);
1702 hints.ai_family = ai_fam_templ;
1703 hints.ai_flags = AI_PASSIVE;
1704 hints.ai_socktype = SOCK_DGRAM;
1705
1706 if (getaddrinfo(NULL, service, &hints, &res) != 0) {
1707 msyslog(LOG_ERR, "getaddrinfo() failed: %m");
1708 exit(1);
1709 /*NOTREACHED*/
1710 }
1711
1712 #ifdef SYS_WINNT
1713 if (check_ntp_port_in_use && ntp_port_inuse(AF_INET, NTP_PORT)){
1714 msyslog(LOG_ERR, "the NTP socket is in use, exiting: %m");
1715 exit(1);
1716 }
1717 #endif
1718
1719 /* Remember the address of the addrinfo structure chain */
1720 ressave = res;
1721
1722 /*
1723 * For each structure returned, open and bind socket
1724 */
1725 for(nbsock = 0; (nbsock < MAX_AF) && res ; res = res->ai_next) {
1726 /* create a datagram (UDP) socket */
1727 fd[nbsock] = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
1728 if (fd[nbsock] == SOCKET_ERROR) {
1729 #ifndef SYS_WINNT
1730 if (errno == EPROTONOSUPPORT || errno == EAFNOSUPPORT ||
1731 errno == EPFNOSUPPORT)
1732 #else
1733 int err = WSAGetLastError();
1734 if (err == WSAEPROTONOSUPPORT || err == WSAEAFNOSUPPORT ||
1735 err == WSAEPFNOSUPPORT)
1736 #endif
1737 continue;
1738 msyslog(LOG_ERR, "socket() failed: %m");
1739 exit(1);
1740 /*NOTREACHED*/
1741 }
1742 /* set socket to reuse address */
1743 if (setsockopt(fd[nbsock], SOL_SOCKET, SO_REUSEADDR, (void*) &optval, sizeof(optval)) < 0) {
1744 msyslog(LOG_ERR, "setsockopt() SO_REUSEADDR failed: %m");
1745 exit(1);
1746 /*NOTREACHED*/
1747 }
1748 #ifdef IPV6_V6ONLY
1749 /* Restricts AF_INET6 socket to IPv6 communications (see RFC 2553bis-03) */
1750 if (res->ai_family == AF_INET6)
1751 if (setsockopt(fd[nbsock], IPPROTO_IPV6, IPV6_V6ONLY, (void*) &optval, sizeof(optval)) < 0) {
1752 msyslog(LOG_ERR, "setsockopt() IPV6_V6ONLY failed: %m");
1753 exit(1);
1754 /*NOTREACHED*/
1755 }
1756 #endif
1757
1758 /* Remember the socket family in fd_family structure */
1759 fd_family[nbsock] = res->ai_family;
1760
1761 /*
1762 * bind the socket to the NTP port
1763 */
1764 if (check_ntp_port_in_use) {
1765 ZERO(addr);
1766 INSIST(res->ai_addrlen <= sizeof(addr));
1767 memcpy(&addr, res->ai_addr, res->ai_addrlen);
1768 rc = bind(fd[nbsock], &addr.sa, SOCKLEN(&addr));
1769 if (rc < 0) {
1770 if (EADDRINUSE == socket_errno())
1771 msyslog(LOG_ERR, "the NTP socket is in use, exiting");
1772 else
1773 msyslog(LOG_ERR, "bind() fails: %m");
1774 exit(1);
1775 }
1776 }
1777
1778 #ifdef HAVE_POLL_H
1779 fdmask[nbsock].fd = fd[nbsock];
1780 fdmask[nbsock].events = POLLIN;
1781 #else
1782 FD_SET(fd[nbsock], &fdmask);
1783 if (maxfd < fd[nbsock]+1) {
1784 maxfd = fd[nbsock]+1;
1785 }
1786 #endif
1787
1788 /*
1789 * set non-blocking,
1790 */
1791 #ifndef SYS_WINNT
1792 # ifdef SYS_VXWORKS
1793 {
1794 int on = TRUE;
1795
1796 if (ioctl(fd[nbsock],FIONBIO, &on) == ERROR) {
1797 msyslog(LOG_ERR, "ioctl(FIONBIO) fails: %m");
1798 exit(1);
1799 }
1800 }
1801 # else /* not SYS_VXWORKS */
1802 # if defined(O_NONBLOCK)
1803 if (fcntl(fd[nbsock], F_SETFL, O_NONBLOCK) < 0) {
1804 msyslog(LOG_ERR, "fcntl(FNDELAY|FASYNC) fails: %m");
1805 exit(1);
1806 /*NOTREACHED*/
1807 }
1808 # else /* not O_NONBLOCK */
1809 # if defined(FNDELAY)
1810 if (fcntl(fd[nbsock], F_SETFL, FNDELAY) < 0) {
1811 msyslog(LOG_ERR, "fcntl(FNDELAY|FASYNC) fails: %m");
1812 exit(1);
1813 /*NOTREACHED*/
1814 }
1815 # else /* FNDELAY */
1816 # include "Bletch: Need non blocking I/O"
1817 # endif /* FNDELAY */
1818 # endif /* not O_NONBLOCK */
1819 # endif /* SYS_VXWORKS */
1820 #else /* SYS_WINNT */
1821 if (ioctlsocket(fd[nbsock], FIONBIO, (u_long *) &on) == SOCKET_ERROR) {
1822 msyslog(LOG_ERR, "ioctlsocket(FIONBIO) fails: %m");
1823 exit(1);
1824 }
1825 #endif /* SYS_WINNT */
1826 nbsock++;
1827 }
1828 freeaddrinfo(ressave);
1829 }
1830
1831 /*
1832 * sendpkt - send a packet to the specified destination
1833 */
1834 static void
sendpkt(sockaddr_u * dest,struct pkt * pkt,int len)1835 sendpkt(
1836 sockaddr_u *dest,
1837 struct pkt *pkt,
1838 int len
1839 )
1840 {
1841 int i;
1842 int cc;
1843 SOCKET sock = INVALID_SOCKET;
1844
1845 #ifdef SYS_WINNT
1846 DWORD err;
1847 #endif /* SYS_WINNT */
1848
1849 /* Find a local family compatible socket to send ntp packet to ntp server */
1850 for(i = 0; (i < MAX_AF); i++) {
1851 if(AF(dest) == fd_family[i]) {
1852 sock = fd[i];
1853 break;
1854 }
1855 }
1856
1857 if (INVALID_SOCKET == sock) {
1858 msyslog(LOG_ERR, "cannot find family compatible socket to send ntp packet");
1859 exit(1);
1860 /*NOTREACHED*/
1861 }
1862
1863 cc = sendto(sock, (char *)pkt, len, 0, (struct sockaddr *)dest,
1864 SOCKLEN(dest));
1865
1866 if (SOCKET_ERROR == cc) {
1867 #ifndef SYS_WINNT
1868 if (errno != EWOULDBLOCK && errno != ENOBUFS)
1869 #else
1870 err = WSAGetLastError();
1871 if (err != WSAEWOULDBLOCK && err != WSAENOBUFS)
1872 #endif /* SYS_WINNT */
1873 msyslog(LOG_ERR, "sendto(%s): %m", stohost(dest));
1874 }
1875 }
1876
1877
1878 /*
1879 * input_handler - receive packets asynchronously
1880 */
1881 void
input_handler(void)1882 input_handler(void)
1883 {
1884 register int n;
1885 register struct recvbuf *rb;
1886 struct sock_timeval tvzero;
1887 GETSOCKNAME_SOCKLEN_TYPE fromlen;
1888 l_fp ts;
1889 int i;
1890 #ifdef HAVE_POLL_H
1891 struct pollfd fds[MAX_AF];
1892 #else
1893 fd_set fds;
1894 #endif
1895 SOCKET fdc = 0;
1896
1897 /*
1898 * Do a poll to see if we have data
1899 */
1900 for (;;) {
1901 tvzero.tv_sec = tvzero.tv_usec = 0;
1902 #ifdef HAVE_POLL_H
1903 memcpy(fds, fdmask, sizeof(fdmask));
1904 n = poll(fds, (unsigned int)nbsock, tvzero.tv_sec * 1000);
1905
1906 /*
1907 * Determine which socket received data
1908 */
1909
1910 for(i=0; i < nbsock; i++) {
1911 if(fds[i].revents & POLLIN) {
1912 fdc = fd[i];
1913 break;
1914 }
1915 }
1916
1917 #else
1918 fds = fdmask;
1919 n = select(maxfd, &fds, NULL, NULL, &tvzero);
1920
1921 /*
1922 * Determine which socket received data
1923 */
1924
1925 for(i=0; i < nbsock; i++) {
1926 if(FD_ISSET(fd[i], &fds)) {
1927 fdc = fd[i];
1928 break;
1929 }
1930 }
1931
1932 #endif
1933
1934 /*
1935 * If nothing to do, just return. If an error occurred,
1936 * complain and return. If we've got some, freeze a
1937 * timestamp.
1938 */
1939 if (n == 0)
1940 return;
1941 else if (n == -1) {
1942 if (errno != EINTR)
1943 msyslog(LOG_ERR,
1944 #ifdef HAVE_POLL_H
1945 "poll() error: %m"
1946 #else
1947 "select() error: %m"
1948 #endif
1949 );
1950 return;
1951 }
1952 get_systime(&ts);
1953
1954 /*
1955 * Get a buffer and read the frame. If we
1956 * haven't got a buffer, or this is received
1957 * on the wild card socket, just dump the packet.
1958 */
1959 if (initializing || free_recvbuffs() == 0) {
1960 char buf[100];
1961
1962
1963 #ifndef SYS_WINNT
1964 (void) read(fdc, buf, sizeof buf);
1965 #else
1966 /* NT's _read does not operate on nonblocking sockets
1967 * either recvfrom or ReadFile() has to be used here.
1968 * ReadFile is used in [ntpd]ntp_intres() and ntpdc,
1969 * just to be different use recvfrom() here
1970 */
1971 recvfrom(fdc, buf, sizeof(buf), 0, (struct sockaddr *)0, NULL);
1972 #endif /* SYS_WINNT */
1973 continue;
1974 }
1975
1976 rb = get_free_recv_buffer();
1977
1978 fromlen = sizeof(rb->recv_srcadr);
1979 rb->recv_length = recvfrom(fdc, (char *)&rb->recv_pkt,
1980 sizeof(rb->recv_pkt), 0,
1981 (struct sockaddr *)&rb->recv_srcadr, &fromlen);
1982 if (rb->recv_length == -1) {
1983 freerecvbuf(rb);
1984 continue;
1985 }
1986
1987 /*
1988 * Got one. Mark how and when it got here,
1989 * put it on the full list.
1990 */
1991 rb->recv_time = ts;
1992 add_full_recv_buffer(rb);
1993 }
1994 }
1995
1996
1997 /*
1998 * adj_systime - do a big long slew of the system time
1999 */
2000 static int
l_adj_systime(l_fp * ts)2001 l_adj_systime(
2002 l_fp *ts
2003 )
2004 {
2005 struct timeval adjtv, oadjtv;
2006 int isneg = 0;
2007 l_fp offset;
2008 #ifndef STEP_SLEW
2009 l_fp overshoot;
2010 #endif
2011
2012 /*
2013 * Take the absolute value of the offset
2014 */
2015 offset = *ts;
2016 if (L_ISNEG(&offset)) {
2017 isneg = 1;
2018 L_NEG(&offset);
2019 }
2020
2021 #ifndef STEP_SLEW
2022 /*
2023 * Calculate the overshoot. XXX N.B. This code *knows*
2024 * ADJ_OVERSHOOT is 1/2.
2025 */
2026 overshoot = offset;
2027 L_RSHIFTU(&overshoot);
2028 if (overshoot.l_ui != 0 || (overshoot.l_uf > ADJ_MAXOVERSHOOT)) {
2029 overshoot.l_ui = 0;
2030 overshoot.l_uf = ADJ_MAXOVERSHOOT;
2031 }
2032 L_ADD(&offset, &overshoot);
2033 #endif
2034 TSTOTV(&offset, &adjtv);
2035
2036 if (isneg) {
2037 adjtv.tv_sec = -adjtv.tv_sec;
2038 adjtv.tv_usec = -adjtv.tv_usec;
2039 }
2040
2041 if (!debug && (adjtv.tv_usec != 0)) {
2042 /* A time correction needs to be applied. */
2043 #if !defined SYS_WINNT && !defined SYS_CYGWIN32
2044 /* Slew the time on systems that support this. */
2045 if (adjtime(&adjtv, &oadjtv) < 0) {
2046 msyslog(LOG_ERR, "Can't adjust the time of day: %m");
2047 exit(1);
2048 }
2049 #else /* SYS_WINNT or SYS_CYGWIN32 is defined */
2050 /*
2051 * The NT SetSystemTimeAdjustment() call achieves slewing by
2052 * changing the clock frequency. This means that we cannot specify
2053 * it to slew the clock by a definite amount and then stop like
2054 * the Unix adjtime() routine. We can technically adjust the clock
2055 * frequency, have ntpdate sleep for a while, and then wake
2056 * up and reset the clock frequency, but this might cause some
2057 * grief if the user attempts to run ntpd immediately after
2058 * ntpdate and the socket is in use.
2059 */
2060 printf("\nSlewing the system time is not supported on Windows. Use the -b option to step the time.\n");
2061 #endif /* defined SYS_WINNT || defined SYS_CYGWIN32 */
2062 }
2063 return 1;
2064 }
2065
2066
2067 /*
2068 * This fuction is not the same as lib/systime step_systime!!!
2069 */
2070 static int
l_step_systime(l_fp * ts)2071 l_step_systime(
2072 l_fp *ts
2073 )
2074 {
2075 double dtemp;
2076
2077 #ifdef SLEWALWAYS
2078 #ifdef STEP_SLEW
2079 l_fp ftmp;
2080 int isneg;
2081 int n;
2082
2083 if (debug)
2084 return 1;
2085
2086 /*
2087 * Take the absolute value of the offset
2088 */
2089 ftmp = *ts;
2090
2091 if (L_ISNEG(&ftmp)) {
2092 L_NEG(&ftmp);
2093 isneg = 1;
2094 } else
2095 isneg = 0;
2096
2097 if (ftmp.l_ui >= 3) { /* Step it and slew - we might win */
2098 LFPTOD(ts, dtemp);
2099 n = step_systime(dtemp);
2100 if (n == 0)
2101 return 0;
2102 if (isneg) /* WTF! */
2103 ts->l_ui = ~0;
2104 else
2105 ts->l_ui = ~0;
2106 }
2107 /*
2108 * Just add adjustment into the current offset. The update
2109 * routine will take care of bringing the system clock into
2110 * line.
2111 */
2112 #endif
2113 if (debug)
2114 return 1;
2115 #ifdef FORCE_NTPDATE_STEP
2116 LFPTOD(ts, dtemp);
2117 return step_systime(dtemp);
2118 #else
2119 l_adj_systime(ts);
2120 return 1;
2121 #endif
2122 #else /* SLEWALWAYS */
2123 if (debug)
2124 return 1;
2125 LFPTOD(ts, dtemp);
2126 return step_systime(dtemp);
2127 #endif /* SLEWALWAYS */
2128 }
2129
2130
2131 /* XXX ELIMINATE print_server similar in ntptrace.c, ntpdate.c */
2132 /*
2133 * print_server - print detail information for a server
2134 */
2135 static void
print_server(register struct server * pp,FILE * fp)2136 print_server(
2137 register struct server *pp,
2138 FILE *fp
2139 )
2140 {
2141 register int i;
2142 char junk[5];
2143 const char *str;
2144
2145 if (pp->stratum == 0) /* Nothing received => nothing to print */
2146 return;
2147
2148 if (!debug) {
2149 (void) fprintf(fp, "server %s, stratum %d, offset %s, delay %s\n",
2150 stoa(&pp->srcadr), pp->stratum,
2151 lfptoa(&pp->offset, 6), fptoa((s_fp)pp->delay, 5));
2152 return;
2153 }
2154
2155 (void) fprintf(fp, "server %s, port %d\n",
2156 stoa(&pp->srcadr), ntohs(((struct sockaddr_in*)&(pp->srcadr))->sin_port));
2157
2158 (void) fprintf(fp, "stratum %d, precision %d, leap %c%c, trust %03o\n",
2159 pp->stratum, pp->precision,
2160 pp->leap & 0x2 ? '1' : '0',
2161 pp->leap & 0x1 ? '1' : '0',
2162 pp->trust);
2163
2164 if (REFID_ISTEXT(pp->stratum)) {
2165 str = (char *) &pp->refid;
2166 for (i=0; i<4 && str[i]; i++) {
2167 junk[i] = (isprint(str[i]) ? str[i] : '.');
2168 }
2169 junk[i] = 0; // force terminating 0
2170 str = junk;
2171 } else {
2172 str = numtoa(pp->refid);
2173 }
2174 (void) fprintf(fp,
2175 "refid [%s], root delay %s, root dispersion %s\n",
2176 str, fptoa((s_fp)pp->rootdelay, 6),
2177 ufptoa(pp->rootdisp, 6));
2178
2179 (void) fprintf(fp, "transmitted %d, in filter %d\n",
2180 pp->xmtcnt, pp->filter_nextpt);
2181
2182 (void) fprintf(fp, "reference time: %s\n",
2183 prettydate(&pp->reftime));
2184 (void) fprintf(fp, "originate timestamp: %s\n",
2185 prettydate(&pp->org));
2186 (void) fprintf(fp, "transmit timestamp: %s\n",
2187 prettydate(&pp->xmt));
2188
2189 if (sys_samples > 1) {
2190 (void) fprintf(fp, "filter delay: ");
2191 for (i = 0; i < NTP_SHIFT; i++) {
2192 (void) fprintf(fp, " %-8.8s", fptoa(pp->filter_delay[i], 5));
2193 if (i == (NTP_SHIFT>>1)-1)
2194 (void) fprintf(fp, "\n ");
2195 }
2196 (void) fprintf(fp, "\n");
2197
2198 (void) fprintf(fp, "filter offset:");
2199 for (i = 0; i < PEER_SHIFT; i++) {
2200 (void) fprintf(fp, " %-8.8s", lfptoa(&pp->filter_offset[i], 6));
2201 if (i == (PEER_SHIFT>>1)-1)
2202 (void) fprintf(fp, "\n ");
2203 }
2204 (void) fprintf(fp, "\n");
2205 }
2206
2207 (void) fprintf(fp, "delay %s, dispersion %s\n",
2208 fptoa((s_fp)pp->delay, 5), ufptoa(pp->dispersion, 5));
2209
2210 (void) fprintf(fp, "offset %s\n\n",
2211 lfptoa(&pp->offset, 6));
2212 }
2213
2214
2215 #ifdef HAVE_NETINFO
2216 static ni_namelist *
getnetinfoservers(void)2217 getnetinfoservers(void)
2218 {
2219 ni_status status;
2220 void *domain;
2221 ni_id confdir;
2222 ni_namelist *namelist = emalloc(sizeof(ni_namelist));
2223
2224 /* Find a time server in NetInfo */
2225 if ((status = ni_open(NULL, ".", &domain)) != NI_OK) return NULL;
2226
2227 while (status = ni_pathsearch(domain, &confdir, NETINFO_CONFIG_DIR) == NI_NODIR) {
2228 void *next_domain;
2229 if (ni_open(domain, "..", &next_domain) != NI_OK) break;
2230 ni_free(domain);
2231 domain = next_domain;
2232 }
2233 if (status != NI_OK) return NULL;
2234
2235 NI_INIT(namelist);
2236 if (ni_lookupprop(domain, &confdir, "server", namelist) != NI_OK) {
2237 ni_namelist_free(namelist);
2238 free(namelist);
2239 return NULL;
2240 }
2241
2242 return(namelist);
2243 }
2244 #endif
2245
2246 #ifdef SYS_WINNT
ntp_port_inuse(int af,u_short port)2247 isc_boolean_t ntp_port_inuse(int af, u_short port)
2248 {
2249 /*
2250 * Check if NTP socket is already in use on this system
2251 * This is only for Windows Systems, as they tend not to fail on the real bind() below
2252 */
2253
2254 SOCKET checksocket;
2255 struct sockaddr_in checkservice;
2256 checksocket = socket(af, SOCK_DGRAM, 0);
2257 if (checksocket == INVALID_SOCKET) {
2258 return (ISC_TRUE);
2259 }
2260
2261 checkservice.sin_family = (short) AF_INET;
2262 checkservice.sin_addr.s_addr = INADDR_LOOPBACK;
2263 checkservice.sin_port = htons(port);
2264
2265 if (bind(checksocket, (struct sockaddr *)&checkservice,
2266 sizeof(checkservice)) == SOCKET_ERROR) {
2267 if ( WSAGetLastError() == WSAEADDRINUSE ){
2268 closesocket(checksocket);
2269 return (ISC_TRUE);
2270 }
2271 }
2272 closesocket(checksocket);
2273 return (ISC_FALSE);
2274 }
2275 #endif
2276