contrib/ntp/ntpdate/ntpdate.c

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