contrib/ntp/ntpd/ntp_io.c

   1 /*
   2  * ntp_io.c - input/output routines for ntpd.   The socket-opening code
   3  *                 was shamelessly stolen from ntpd.
   4  */
   5
   6 #ifdef HAVE_CONFIG_H
   7 # include <config.h>
   8 #endif
   9
  10 #include "ntp_machine.h"
  11 #include "ntpd.h"
  12 #include "ntp_io.h"
  13 #include "iosignal.h"
  14 #include "ntp_refclock.h"
  15 #include "ntp_if.h"
  16 #include "ntp_stdlib.h"
  17
  18 #include <stdio.h>
  19 #include <signal.h>
  20 #ifdef HAVE_SYS_PARAM_H
  21 # include <sys/param.h>
  22 #endif /* HAVE_SYS_PARAM_H */
  23 #ifdef HAVE_NETINET_IN_H
  24 # include <netinet/in.h>
  25 #endif
  26 #ifdef HAVE_NETINET_IN_SYSTM_H
  27 # include <netinet/in_systm.h>
  28 #else /* Some old linux systems at least have in_system.h instead. */
  29 # include <netinet/in_system.h>
  30 #endif /* HAVE_NETINET_IN_SYSTM_H */
  31 #include <netinet/ip.h>
  32 #ifdef HAVE_SYS_IOCTL_H
  33 # include <sys/ioctl.h>
  34 #endif
  35 #ifdef HAVE_SYS_SOCKIO_H        /* UXPV: SIOC* #defines (Frank Vance <fvance@waii.com>) */
  36 # include <sys/sockio.h>
  37 #endif
  38 #include <arpa/inet.h>
  39
  40 #if _BSDI_VERSION >= 199510
  41 # include <ifaddrs.h>
  42 #endif
  43
  44 #if defined(VMS)                /* most likely UCX-specific */
  45
  46 #include <UCX$INETDEF.H>
  47
  48 /* "un*x"-compatible names for some items in UCX$INETDEF.H */
  49 #define ifreq           IFREQDEF
  50 #define ifr_name        IFR$T_NAME
  51 #define ifr_addr                IFR$R_DUMMY.IFR$T_ADDR
  52 #define ifr_broadaddr   IFR$R_DUMMY.IFR$T_BROADADDR
  53 #define ifr_flags               IFR$R_DUMMY.IFR$R_DUMMY_1_OVRL.IFR$W_FLAGS
  54 #define IFF_UP          IFR$M_IFF_UP
  55 #define IFF_BROADCAST   IFR$M_IFF_BROADCAST
  56 #define IFF_LOOPBACK    IFR$M_IFF_LOOPBACK
  57
  58 #endif /* VMS */
  59
  60
  61 #if defined(VMS) || defined(SYS_WINNT)
  62 /* structure used in SIOCGIFCONF request (after [KSR] OSF/1) */
  63 struct ifconf {
  64         int ifc_len;                    /* size of buffer */
  65         union {
  66                 caddr_t ifcu_buf;
  67                 struct ifreq *ifcu_req;
  68         } ifc_ifcu;
  69 };
  70 #define ifc_buf ifc_ifcu.ifcu_buf       /* buffer address */
  71 #define ifc_req ifc_ifcu.ifcu_req       /* array of structures returned */
  72
  73 #endif /* VMS */
  74
  75 #if defined(USE_TTY_SIGPOLL) || defined(USE_UDP_SIGPOLL)
  76 # if defined(SYS_AIX) && defined(_IO) /* XXX Identify AIX some other way */
  77 #  undef _IO
  78 # endif
  79 # include <stropts.h>
  80 #endif
  81
  82 /*
  83  * We do asynchronous input using the SIGIO facility.  A number of
  84  * recvbuf buffers are preallocated for input.  In the signal
  85  * handler we poll to see which sockets are ready and read the
  86  * packets from them into the recvbuf's along with a time stamp and
  87  * an indication of the source host and the interface it was received
  88  * through.  This allows us to get as accurate receive time stamps
  89  * as possible independent of other processing going on.
  90  *
  91  * We watch the number of recvbufs available to the signal handler
  92  * and allocate more when this number drops below the low water
  93  * mark.  If the signal handler should run out of buffers in the
  94  * interim it will drop incoming frames, the idea being that it is
  95  * better to drop a packet than to be inaccurate.
  96  */
  97
  98
  99 /*
 100  * Other statistics of possible interest
 101  */
 102 volatile u_long packets_dropped;        /* total number of packets dropped on reception */
 103 volatile u_long packets_ignored;        /* packets received on wild card interface */
 104 volatile u_long packets_received;       /* total number of packets received */
 105 u_long packets_sent;    /* total number of packets sent */
 106 u_long packets_notsent; /* total number of packets which couldn't be sent */
 107
 108 volatile u_long handler_calls;  /* number of calls to interrupt handler */
 109 volatile u_long handler_pkts;   /* number of pkts received by handler */
 110 u_long io_timereset;            /* time counters were reset */
 111
 112 /*
 113  * Interface stuff
 114  */
 115 struct interface *any_interface;        /* default interface */
 116 struct interface *loopback_interface;   /* loopback interface */
 117 struct interface inter_list[MAXINTERFACES];
 118 int ninterfaces;
 119
 120 #ifdef REFCLOCK
 121 /*
 122  * Refclock stuff.      We keep a chain of structures with data concerning
 123  * the guys we are doing I/O for.
 124  */
 125 static  struct refclockio *refio;
 126 #endif /* REFCLOCK */
 127
 128 /*
 129  * File descriptor masks etc. for call to select
 130  */
 131 fd_set activefds;
 132 int maxactivefd;
 133
 134 static  int create_sockets      P((u_int));
 135 static  int open_socket         P((struct sockaddr_in *, int, int));
 136 static  void    close_socket    P((int));
 137 static  void    close_file      P((int));
 138 static  char *  fdbits          P((int, fd_set *));
 139
 140 /*
 141  * init_io - initialize I/O data structures and call socket creation routine
 142  */
 143 void
 144 init_io(void)
 145 {
 146 #ifdef SYS_WINNT
 147         WORD wVersionRequested;
 148         WSADATA wsaData;
 149         init_transmitbuff();
 150 #endif /* SYS_WINNT */
 151
 152         /*
 153          * Init buffer free list and stat counters
 154          */
 155         init_recvbuff(RECV_INIT);
 156
 157         packets_dropped = packets_received = 0;
 158         packets_ignored = 0;
 159         packets_sent = packets_notsent = 0;
 160         handler_calls = handler_pkts = 0;
 161         io_timereset = 0;
 162         loopback_interface = 0;
 163
 164 #ifdef REFCLOCK
 165         refio = 0;
 166 #endif
 167
 168 #if defined(HAVE_SIGNALED_IO)
 169         (void) set_signal();
 170 #endif
 171
 172 #ifdef SYS_WINNT
 173         wVersionRequested = MAKEWORD(1,1);
 174         if (WSAStartup(wVersionRequested, &wsaData))
 175         {
 176                 msyslog(LOG_ERR, "No useable winsock.dll: %m");
 177                 exit(1);
 178         }
 179 #endif /* SYS_WINNT */
 180
 181         /*
 182          * Create the sockets
 183          */
 184         BLOCKIO();
 185         (void) create_sockets(htons(NTP_PORT));
 186         UNBLOCKIO();
 187
 188 #ifdef DEBUG
 189         if (debug)
 190             printf("init_io: maxactivefd %d\n", maxactivefd);
 191 #endif
 192 }
 193
 194 /*
 195  * create_sockets - create a socket for each interface plus a default
 196  *                      socket for when we don't know where to send
 197  */
 198 static int
 199 create_sockets(
 200         u_int port
 201         )
 202 {
 203 #if _BSDI_VERSION >= 199510
 204         int i, j;
 205         struct ifaddrs *ifaddrs, *ifap;
 206         struct sockaddr_in resmask;
 207 #if     _BSDI_VERSION < 199701
 208         struct ifaddrs *lp;
 209         int num_if;
 210 #endif
 211 #else   /* _BSDI_VERSION >= 199510 */
 212 # ifdef STREAMS_TLI
 213         struct strioctl ioc;
 214 # endif /* STREAMS_TLI */
 215         char    buf[MAXINTERFACES*sizeof(struct ifreq)];
 216         struct  ifconf  ifc;
 217         struct  ifreq   ifreq, *ifr;
 218         int n, i, j, vs, size = 0;
 219         struct sockaddr_in resmask;
 220 #endif  /* _BSDI_VERSION >= 199510 */
 221
 222 #ifdef DEBUG
 223         if (debug)
 224             printf("create_sockets(%d)\n", ntohs( (u_short) port));
 225 #endif
 226
 227         /*
 228          * create pseudo-interface with wildcard address
 229          */
 230         inter_list[0].sin.sin_family = AF_INET;
 231         inter_list[0].sin.sin_port = port;
 232         inter_list[0].sin.sin_addr.s_addr = htonl(INADDR_ANY);
 233         (void) strncpy(inter_list[0].name, "wildcard",
 234                        sizeof(inter_list[0].name));
 235         inter_list[0].mask.sin_addr.s_addr = htonl(~ (u_int32)0);
 236         inter_list[0].received = 0;
 237         inter_list[0].sent = 0;
 238         inter_list[0].notsent = 0;
 239         inter_list[0].flags = INT_BROADCAST;
 240         any_interface = &inter_list[0];
 241
 242 #if _BSDI_VERSION >= 199510
 243 #if     _BSDI_VERSION >= 199701
 244         if (getifaddrs(&ifaddrs) < 0)
 245         {
 246                 msyslog(LOG_ERR, "getifaddrs: %m");
 247                 exit(1);
 248         }
 249         i = 1;
 250         for (ifap = ifaddrs; ifap != NULL; ifap = ifap->ifa_next)
 251 #else
 252             if (getifaddrs(&ifaddrs, &num_if) < 0)
 253             {
 254                     msyslog(LOG_ERR, "create_sockets: getifaddrs() failed: %m");
 255                     exit(1);
 256             }
 257
 258         i = 1;
 259
 260         for (ifap = ifaddrs, lp = ifap + num_if; ifap < lp; ifap++)
 261 #endif
 262         {
 263                 struct sockaddr_in *sin;
 264
 265                 if (!ifap->ifa_addr)
 266                     continue;
 267
 268                 if (ifap->ifa_addr->sa_family != AF_INET)
 269                     continue;
 270
 271                 if ((ifap->ifa_flags & IFF_UP) == 0)
 272                     continue;
 273
 274                 if (ifap->ifa_flags & IFF_LOOPBACK) {
 275                         sin = (struct sockaddr_in *)ifap->ifa_addr;
 276                         if (ntohl(sin->sin_addr.s_addr) != 0x7f000001)
 277                                 continue;
 278                 }
 279                 inter_list[i].flags = 0;
 280                 if (ifap->ifa_flags & IFF_BROADCAST)
 281                         inter_list[i].flags |= INT_BROADCAST;
 282                 strcpy(inter_list[i].name, ifap->ifa_name);
 283                 sin = (struct sockaddr_in *)ifap->ifa_addr;
 284                 inter_list[i].sin = *sin;
 285                 inter_list[i].sin.sin_port = port;
 286                 if (ifap->ifa_flags & IFF_LOOPBACK) {
 287                         inter_list[i].flags = INT_LOOPBACK;
 288                         if (loopback_interface == NULL
 289                             || ntohl(sin->sin_addr.s_addr) != 0x7f000001)
 290                             loopback_interface = &inter_list[i];
 291                 }
 292                 if (inter_list[i].flags & INT_BROADCAST) {
 293                         sin = (struct sockaddr_in *)ifap->ifa_broadaddr;
 294                         inter_list[i].bcast = *sin;
 295                         inter_list[i].bcast.sin_port = port;
 296                 }
 297                 if (ifap->ifa_flags & (IFF_LOOPBACK|IFF_POINTOPOINT)) {
 298                         inter_list[i].mask.sin_addr.s_addr = 0xffffffff;
 299                 } else {
 300                         sin = (struct sockaddr_in *)ifap->ifa_netmask;
 301                         inter_list[i].mask = *sin;
 302                 }
 303                 inter_list[i].mask.sin_family = AF_INET;
 304                 inter_list[i].mask.sin_len = sizeof *sin;
 305
 306                 /*
 307                  * look for an already existing source interface address.  If
 308                  * the machine has multiple point to point interfaces, then
 309                  * the local address may appear more than once.
 310                  *
 311                  * A second problem exists if we have two addresses on
 312                  * the same network (via "ifconfig alias ...").  Don't
 313                  * make two xntp interfaces for the two aliases on the
 314                  * one physical interface. -wsr
 315                  */
 316                 for (j=0; j < i; j++)
 317                     if (inter_list[j].sin.sin_addr.s_addr &
 318                         inter_list[j].mask.sin_addr.s_addr ==
 319                         inter_list[i].sin.sin_addr.s_addr &
 320                         inter_list[i].mask.sin_addr.s_addr)
 321                     {
 322                             if (inter_list[j].flags & INT_LOOPBACK)
 323                                 inter_list[j] = inter_list[i];
 324                             break;
 325                     }
 326                 if (j == i)
 327                     i++;
 328                 if (i > MAXINTERFACES)
 329                     break;
 330         }
 331         free(ifaddrs);
 332 #else   /* _BSDI_VERSION >= 199510 */
 333 # ifdef USE_STREAMS_DEVICE_FOR_IF_CONFIG
 334         if ((vs = open("/dev/ip", O_RDONLY)) < 0)
 335         {
 336                 msyslog(LOG_ERR, "create_sockets: open(/dev/ip) failed: %m");
 337                 exit(1);
 338         }
 339 # else /* not USE_STREAMS_DEVICE_FOR_IF_CONFIG */
 340         if (
 341                 (vs = socket(AF_INET, SOCK_DGRAM, 0))
 342 #  ifndef SYS_WINNT
 343                 < 0
 344 #  else /* SYS_WINNT */
 345                 == INVALID_SOCKET
 346 #  endif /* SYS_WINNT */
 347                 ) {
 348                 msyslog(LOG_ERR, "create_sockets: socket(AF_INET, SOCK_DGRAM) failed: %m");
 349                 exit(1);
 350         }
 351 # endif /* not USE_STREAMS_DEVICE_FOR_IF_CONFIG */
 352
 353         i = 1;
 354 # if !defined(SYS_WINNT)
 355         ifc.ifc_len = sizeof(buf);
 356 # endif
 357 # ifdef STREAMS_TLI
 358         ioc.ic_cmd = SIOCGIFCONF;
 359         ioc.ic_timout = 0;
 360         ioc.ic_dp = (caddr_t)buf;
 361         ioc.ic_len = sizeof(buf);
 362         if(ioctl(vs, I_STR, &ioc) < 0 ||
 363            ioc.ic_len < sizeof(struct ifreq))
 364         {
 365                 msyslog(LOG_ERR, "create_sockets: ioctl(I_STR:SIOCGIFCONF) failed: %m - exiting");
 366                 exit(1);
 367         }
 368 #  ifdef SIZE_RETURNED_IN_BUFFER
 369         ifc.ifc_len = ioc.ic_len - sizeof(int);
 370         ifc.ifc_buf = buf + sizeof(int);
 371 #  else /* not SIZE_RETURNED_IN_BUFFER */
 372         ifc.ifc_len = ioc.ic_len;
 373         ifc.ifc_buf = buf;
 374 #  endif /* not SIZE_RETURNED_IN_BUFFER */
 375
 376 # else /* not STREAMS_TLI */
 377         ifc.ifc_len = sizeof(buf);
 378         ifc.ifc_buf = buf;
 379 #  ifndef SYS_WINNT
 380         if (ioctl(vs, SIOCGIFCONF, (char *)&ifc) < 0)
 381 #  else
 382         if (WSAIoctl(vs, SIO_GET_INTERFACE_LIST, 0, 0, ifc.ifc_buf, ifc.ifc_len, &ifc.ifc_len, 0, 0) == SOCKET_ERROR)
 383 #  endif /* SYS_WINNT */
 384 {
 385                 msyslog(LOG_ERR, "create_sockets: ioctl(SIOCGIFCONF) failed: %m - exiting");
 386                 exit(1);
 387 }
 388
 389 # endif /* not STREAMS_TLI */
 390
 391         for(n = ifc.ifc_len, ifr = ifc.ifc_req; n > 0;
 392             ifr = (struct ifreq *)((char *)ifr + size))
 393         {
 394                 extern int listen_to_virtual_ips;
 395
 396                 size = sizeof(*ifr);
 397
 398 # ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
 399                 if (ifr->ifr_addr.sa_len > sizeof(ifr->ifr_addr))
 400                     size += ifr->ifr_addr.sa_len - sizeof(struct sockaddr);
 401 # endif
 402                 n -= size;
 403
 404 # if !defined(SYS_WINNT)
 405                 /* Exclude logical interfaces (indicated by ':' in the interface name)  */
 406                 if (debug)
 407                         printf("interface <%s> ", ifr->ifr_name);
 408                 if ((listen_to_virtual_ips == 0)
 409                     && (strchr(ifr->ifr_name, (int)':') != NULL)) {
 410                         if (debug)
 411                             printf("ignored\n");
 412                         continue;
 413                 }
 414                 if (debug)
 415                     printf("OK\n");
 416
 417                 if (
 418 #  ifdef VMS /* VMS+UCX */
 419                         (((struct sockaddr *)&(ifr->ifr_addr))->sa_family != AF_INET)
 420 #  else
 421                         (ifr->ifr_addr.sa_family != AF_INET)
 422 #  endif /* VMS+UCX */
 423                         ) {
 424                         if (debug)
 425                             printf("ignoring %s - not AF_INET\n",
 426                                    ifr->ifr_name);
 427                         continue;
 428                 }
 429 # endif /* SYS_WINNT */
 430                 memcpy(&ifreq, ifr, sizeof(ifreq));
 431                 inter_list[i].flags = 0;
 432                 /* is it broadcast capable? */
 433 # ifndef SYS_WINNT
 434 #  ifdef STREAMS_TLI
 435                 ioc.ic_cmd = SIOCGIFFLAGS;
 436                 ioc.ic_timout = 0;
 437                 ioc.ic_dp = (caddr_t)&ifreq;
 438                 ioc.ic_len = sizeof(struct ifreq);
 439                 if(ioctl(vs, I_STR, &ioc)) {
 440                         msyslog(LOG_ERR, "create_sockets: ioctl(I_STR:SIOCGIFFLAGS) failed: %m");
 441                         continue;
 442                 }
 443 #  else /* not STREAMS_TLI */
 444                 if (ioctl(vs, SIOCGIFFLAGS, (char *)&ifreq) < 0) {
 445                         if (errno != ENXIO)
 446                             msyslog(LOG_ERR, "create_sockets: ioctl(SIOCGIFFLAGS) failed: %m");
 447                         continue;
 448                 }
 449 #  endif /* not STREAMS_TLI */
 450                 if ((ifreq.ifr_flags & IFF_UP) == 0) {
 451                         if (debug)
 452                             printf("ignoring %s - interface not UP\n",
 453                                    ifr->ifr_name);
 454                         continue;
 455                 }
 456                 inter_list[i].flags = 0;
 457                 if (ifreq.ifr_flags & IFF_BROADCAST)
 458                     inter_list[i].flags |= INT_BROADCAST;
 459 # endif /* not SYS_WINNT */
 460 # if !defined(SUN_3_3_STINKS)
 461                 if (
 462 #  if defined(IFF_LOCAL_LOOPBACK) /* defined(SYS_HPUX) && (SYS_HPUX < 8) */
 463                         (ifreq.ifr_flags & IFF_LOCAL_LOOPBACK)
 464 #  elif defined(IFF_LOOPBACK)
 465                         (ifreq.ifr_flags & IFF_LOOPBACK)
 466 #  else /* not IFF_LOCAL_LOOPBACK and not IFF_LOOPBACK */
 467                         /* test against 127.0.0.1 (yuck!!) */
 468                         (inter_list[i].sin.sin_addr.s_addr == inet_addr("127.0.0.1"))
 469 #  endif /* not IFF_LOCAL_LOOPBACK and not IFF_LOOPBACK */
 470                         )
 471                 {
 472 #  ifndef SYS_WINNT
 473                         inter_list[i].flags |= INT_LOOPBACK;
 474 #  endif /* not SYS_WINNT */
 475                         if (loopback_interface == 0)
 476                         {
 477                                 loopback_interface = &inter_list[i];
 478                         }
 479                 }
 480 # endif /* not SUN_3_3_STINKS */
 481
 482 #if 0
 483 # ifndef SYS_WINNT
 484 #  ifdef STREAMS_TLI
 485                 ioc.ic_cmd = SIOCGIFADDR;
 486                 ioc.ic_timout = 0;
 487                 ioc.ic_dp = (caddr_t)&ifreq;
 488                 ioc.ic_len = sizeof(struct ifreq);
 489                 if (ioctl(vs, I_STR, &ioc))
 490                 {
 491                         msyslog(LOG_ERR, "create_sockets: ioctl(I_STR:SIOCGIFADDR) failed: %m");
 492                         continue;
 493                 }
 494 #  else /* not STREAMS_TLI */
 495                 if (ioctl(vs, SIOCGIFADDR, (char *)&ifreq) < 0)
 496                 {
 497                         if (errno != ENXIO)
 498                             msyslog(LOG_ERR, "create_sockets: ioctl(SIOCGIFADDR) failed: %m");
 499                         continue;
 500                 }
 501 #  endif /* not STREAMS_TLI */
 502 # endif /* not SYS_WINNT */
 503 #endif /* 0 */
 504 # if defined(SYS_WINNT)
 505                 {int TODO_FillInTheNameWithSomeThingReasonble;}
 506 # else
 507                 (void)strncpy(inter_list[i].name, ifreq.ifr_name,
 508                               sizeof(inter_list[i].name));
 509 # endif
 510                 inter_list[i].sin = *(struct sockaddr_in *)&ifr->ifr_addr;
 511                 inter_list[i].sin.sin_family = AF_INET;
 512                 inter_list[i].sin.sin_port = port;
 513
 514 # if defined(SUN_3_3_STINKS)
 515                 /*
 516                  * Oh, barf!  I'm too disgusted to even explain this
 517                  */
 518                 if (SRCADR(&inter_list[i].sin) == 0x7f000001)
 519                 {
 520                         inter_list[i].flags |= INT_LOOPBACK;
 521                         if (loopback_interface == 0)
 522                             loopback_interface = &inter_list[i];
 523                 }
 524 # endif /* SUN_3_3_STINKS */
 525 # if !defined SYS_WINNT && !defined SYS_CYGWIN32 /* no interface flags on NT */
 526                 if (inter_list[i].flags & INT_BROADCAST) {
 527 #  ifdef STREAMS_TLI
 528                         ioc.ic_cmd = SIOCGIFBRDADDR;
 529                         ioc.ic_timout = 0;
 530                         ioc.ic_dp = (caddr_t)&ifreq;
 531                         ioc.ic_len = sizeof(struct ifreq);
 532                         if(ioctl(vs, I_STR, &ioc)) {
 533                                 msyslog(LOG_ERR, "create_sockets: ioctl(I_STR:SIOCGIFBRDADDR) failed: %m");
 534                                 exit(1);
 535                         }
 536 #  else /* not STREAMS_TLI */
 537                         if (ioctl(vs, SIOCGIFBRDADDR, (char *)&ifreq) < 0) {
 538                                 msyslog(LOG_ERR, "create_sockets: ioctl(SIOCGIFBRDADDR) failed: %m");
 539                                 exit(1);
 540                         }
 541 #  endif /* not STREAMS_TLI */
 542
 543 #  ifndef ifr_broadaddr
 544                         inter_list[i].bcast =
 545                             *(struct sockaddr_in *)&ifreq.ifr_addr;
 546 #  else
 547                         inter_list[i].bcast =
 548                             *(struct sockaddr_in *)&ifreq.ifr_broadaddr;
 549 #  endif /* ifr_broadaddr */
 550                         inter_list[i].bcast.sin_family = AF_INET;
 551                         inter_list[i].bcast.sin_port = port;
 552                 }
 553
 554 #  ifdef STREAMS_TLI
 555                 ioc.ic_cmd = SIOCGIFNETMASK;
 556                 ioc.ic_timout = 0;
 557                 ioc.ic_dp = (caddr_t)&ifreq;
 558                 ioc.ic_len = sizeof(struct ifreq);
 559                 if(ioctl(vs, I_STR, &ioc)) {
 560                         msyslog(LOG_ERR, "create_sockets: ioctl(I_STR:SIOCGIFNETMASK) failed: %m");
 561                         exit(1);
 562                 }
 563 #  else /* not STREAMS_TLI */
 564                 if (ioctl(vs, SIOCGIFNETMASK, (char *)&ifreq) < 0) {
 565                         msyslog(LOG_ERR, "create_sockets: ioctl(SIOCGIFNETMASK) failed: %m");
 566                         exit(1);
 567                 }
 568 #  endif /* not STREAMS_TLI */
 569                 inter_list[i].mask                 = *(struct sockaddr_in *)&ifreq.ifr_addr;
 570 # else
 571                 /* winnt here */
 572                 inter_list[i].bcast                = ifreq.ifr_broadaddr;
 573                 inter_list[i].bcast.sin_family     = AF_INET;
 574                 inter_list[i].bcast.sin_port       = port;
 575                 inter_list[i].mask                 = ifreq.ifr_mask;
 576 # endif /* not SYS_WINNT */
 577
 578                 /*
 579                  * look for an already existing source interface address.  If
 580                  * the machine has multiple point to point interfaces, then
 581                  * the local address may appear more than once.
 582                  */
 583                 for (j=0; j < i; j++)
 584                     if (inter_list[j].sin.sin_addr.s_addr ==
 585                         inter_list[i].sin.sin_addr.s_addr) {
 586                             break;
 587                     }
 588                 if (j == i)
 589                     i++;
 590                 if (i > MAXINTERFACES)
 591                     break;
 592         }
 593         closesocket(vs);
 594 #endif  /* _BSDI_VERSION >= 199510 */
 595
 596         ninterfaces = i;
 597         maxactivefd = 0;
 598         FD_ZERO(&activefds);
 599         for (i = 0; i < ninterfaces; i++) {
 600                 inter_list[i].fd = open_socket(&inter_list[i].sin,
 601                     inter_list[i].flags & INT_BROADCAST, 0);
 602         }
 603
 604         /*
 605          * Now that we have opened all the sockets, turn off the reuse flag for
 606          * security.
 607          */
 608         for (i = 0; i < ninterfaces; i++) {
 609                 int off = 0;
 610
 611                 /*
 612                  * if inter_list[ n ].fd  is -1, we might have a adapter
 613                  * configured but not present
 614                  */
 615                 if ( inter_list[ i ].fd != -1 ) {
 616                         if (setsockopt(inter_list[i].fd, SOL_SOCKET,
 617                                        SO_REUSEADDR, (char *)&off,
 618                                        sizeof(off))) {
 619                                 msyslog(LOG_ERR, "create_sockets: setsockopt(SO_REUSEADDR,off) failed: %m");
 620                         }
 621                 }
 622         }
 623
 624 #if defined(MCAST)
 625         /*
 626          * enable possible multicast reception on the broadcast socket
 627          */
 628         inter_list[0].bcast.sin_addr.s_addr = htonl(INADDR_ANY);
 629         inter_list[0].bcast.sin_family = AF_INET;
 630         inter_list[0].bcast.sin_port = port;
 631 #endif /* MCAST */
 632
 633         /*
 634          * Blacklist all bound interface addresses
 635          */
 636         resmask.sin_addr.s_addr = ~ (u_int32)0;
 637         for (i = 1; i < ninterfaces; i++)
 638                 hack_restrict(RESTRICT_FLAGS, &inter_list[i].sin, &resmask,
 639                     RESM_NTPONLY|RESM_INTERFACE, RES_IGNORE);
 640 #ifdef DEBUG
 641         if (debug > 1) {
 642                 printf("create_sockets: ninterfaces=%d\n", ninterfaces);
 643                 for (i = 0; i < ninterfaces; i++) {
 644                         printf("interface %d:  fd=%d,  bfd=%d,  name=%.8s,  flags=0x%x\n",
 645                                i,
 646                                inter_list[i].fd,
 647                                inter_list[i].bfd,
 648                                inter_list[i].name,
 649                                inter_list[i].flags);
 650                         /* Leave these as three printf calls. */
 651                         printf("              sin=%s",
 652                                inet_ntoa((inter_list[i].sin.sin_addr)));
 653                         if (inter_list[i].flags & INT_BROADCAST)
 654                             printf("  bcast=%s,",
 655                                    inet_ntoa((inter_list[i].bcast.sin_addr)));
 656                         printf("  mask=%s\n",
 657                                inet_ntoa((inter_list[i].mask.sin_addr)));
 658                 }
 659         }
 660 #endif
 661 #if defined (HAVE_IO_COMPLETION_PORT)
 662         for (i = 0; i < ninterfaces; i++) {
 663                 io_completion_port_add_socket(&inter_list[i]);
 664         }
 665 #endif
 666         return ninterfaces;
 667 }
 668
 669 /*
 670  * io_setbclient - open the broadcast client sockets
 671  */
 672 void
 673 io_setbclient(void)
 674 {
 675         int i;
 676
 677         for (i = 1; i < ninterfaces; i++) {
 678                 if (!(inter_list[i].flags & INT_BROADCAST))
 679                         continue;
 680
 681                 if (inter_list[i].flags & INT_BCASTOPEN)
 682                         continue;
 683
 684 #ifdef  SYS_SOLARIS
 685                 inter_list[i].bcast.sin_addr.s_addr = htonl(INADDR_ANY);
 686 #endif
 687 #ifdef OPEN_BCAST_SOCKET /* Was: !SYS_DOMAINOS && !SYS_LINUX */
 688                 inter_list[i].bfd = open_socket(&inter_list[i].bcast,
 689                     INT_BROADCAST, 1);
 690                 inter_list[i].flags |= INT_BCASTOPEN;
 691 #endif
 692         }
 693 }
 694
 695
 696 /*
 697  * io_multicast_add() - add multicast group address
 698  */
 699 void
 700 io_multicast_add(
 701         u_int32 addr
 702         )
 703 {
 704 #ifdef MCAST
 705         struct ip_mreq mreq;
 706         int i = ninterfaces;    /* Use the next interface */
 707         u_int32 haddr = ntohl(addr);
 708         struct in_addr iaddr;
 709         int s;
 710         struct sockaddr_in *sinp;
 711
 712         iaddr.s_addr = addr;
 713         if (!IN_CLASSD(haddr)) {
 714                 msyslog(LOG_ERR,
 715                     "multicast address %s not class D",
 716                         inet_ntoa(iaddr));
 717                 return;
 718         }
 719         for (i = 0; i < ninterfaces; i++) {
 720                 /* Already have this address */
 721                 if (inter_list[i].sin.sin_addr.s_addr == addr)
 722                         return;
 723                 /* found a free slot */
 724                 if (inter_list[i].sin.sin_addr.s_addr == 0 &&
 725                     inter_list[i].fd <= 0 && inter_list[i].bfd <= 0 &&
 726                     inter_list[i].flags == 0)
 727                 break;
 728         }
 729         sinp = &(inter_list[i].sin);
 730         memset((char *)&mreq, 0, sizeof(mreq));
 731         memset((char *)&inter_list[i], 0, sizeof inter_list[0]);
 732         sinp->sin_family = AF_INET;
 733         sinp->sin_addr = iaddr;
 734         sinp->sin_port = htons(123);
 735
 736         /*
 737          * Try opening a socket for the specified class D address. This
 738          * works under SunOS 4.x, but not OSF1 .. :-(
 739          */
 740         s = open_socket(sinp, 0, 1);
 741         if (s < 0) {
 742                 memset((char *)&inter_list[i], 0, sizeof inter_list[0]);
 743                 i = 0;
 744                 /* HACK ! -- stuff in an address */
 745                 inter_list[i].bcast.sin_addr.s_addr = addr;
 746                 msyslog(LOG_ERR,
 747                     "...multicast address %s using wildcard socket",
 748                     inet_ntoa(iaddr));
 749         } else {
 750                 inter_list[i].fd = s;
 751                 inter_list[i].bfd = -1;
 752                 (void) strncpy(inter_list[i].name, "multicast",
 753                     sizeof(inter_list[i].name));
 754                 inter_list[i].mask.sin_addr.s_addr = htonl(~(u_int32)0);
 755         }
 756
 757         /*
 758          * enable reception of multicast packets
 759          */
 760         mreq.imr_multiaddr = iaddr;
 761         mreq.imr_interface.s_addr = htonl(INADDR_ANY);
 762         if (setsockopt(inter_list[i].fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 763             (char *)&mreq, sizeof(mreq)) == -1)
 764                 msyslog(LOG_ERR,
 765                     "setsockopt IP_ADD_MEMBERSHIP fails: %m for %x / %x (%s)",
 766                     mreq.imr_multiaddr.s_addr,
 767                     mreq.imr_interface.s_addr, inet_ntoa(iaddr));
 768         inter_list[i].flags |= INT_MULTICAST;
 769         if (i >= ninterfaces)
 770             ninterfaces = i+1;
 771 #else /* MCAST */
 772         struct in_addr iaddr;
 773
 774         iaddr.s_addr = addr;
 775         msyslog(LOG_ERR,
 776             "cannot add multicast address %s as no MCAST support",
 777             inet_ntoa(iaddr));
 778 #endif /* MCAST */
 779 }
 780
 781 /*
 782  * io_unsetbclient - close the broadcast client sockets
 783  */
 784 void
 785 io_unsetbclient(void)
 786 {
 787         int i;
 788
 789         for (i = 1; i < ninterfaces; i++)
 790         {
 791                 if (!(inter_list[i].flags & INT_BCASTOPEN))
 792                     continue;
 793                 close_socket(inter_list[i].bfd);
 794                 inter_list[i].bfd = -1;
 795                 inter_list[i].flags &= ~INT_BCASTOPEN;
 796         }
 797 }
 798
 799
 800 /*
 801  * io_multicast_del() - delete multicast group address
 802  */
 803 void
 804 io_multicast_del(
 805         u_int32 addr
 806         )
 807 {
 808 #ifdef MCAST
 809         int i;
 810         struct ip_mreq mreq;
 811         u_int32 haddr = ntohl(addr);
 812         struct sockaddr_in sinaddr;
 813
 814         if (!IN_CLASSD(haddr))
 815         {
 816                 sinaddr.sin_addr.s_addr = addr;
 817                 msyslog(LOG_ERR,
 818                         "invalid multicast address %s", ntoa(&sinaddr));
 819                 return;
 820         }
 821
 822         /*
 823          * Disable reception of multicast packets
 824          */
 825         mreq.imr_multiaddr.s_addr = addr;
 826         mreq.imr_interface.s_addr = htonl(INADDR_ANY);
 827         for (i = 0; i < ninterfaces; i++)
 828         {
 829                 if (!(inter_list[i].flags & INT_MULTICAST))
 830                     continue;
 831                 if (!(inter_list[i].fd < 0))
 832                     continue;
 833                 if (addr != inter_list[i].sin.sin_addr.s_addr)
 834                     continue;
 835                 if (i != 0)
 836                 {
 837                         /* we have an explicit fd, so we can close it */
 838                         close_socket(inter_list[i].fd);
 839                         memset((char *)&inter_list[i], 0, sizeof inter_list[0]);
 840                         inter_list[i].fd = -1;
 841                         inter_list[i].bfd = -1;
 842                 }
 843                 else
 844                 {
 845                         /* We are sharing "any address" port :-(  Don't close it! */
 846                         if (setsockopt(inter_list[i].fd, IPPROTO_IP, IP_DROP_MEMBERSHIP,
 847                                        (char *)&mreq, sizeof(mreq)) == -1)
 848                             msyslog(LOG_ERR, "setsockopt IP_DROP_MEMBERSHIP fails: %m");
 849                         /* This is **WRONG** -- there may be others ! */
 850                         /* There should be a count of users ... */
 851                         inter_list[i].flags &= ~INT_MULTICAST;
 852                 }
 853         }
 854 #else /* not MCAST */
 855         msyslog(LOG_ERR, "this function requires multicast kernel");
 856 #endif /* not MCAST */
 857 }
 858
 859
 860 /*
 861  * open_socket - open a socket, returning the file descriptor
 862  */
 863 static int
 864 open_socket(
 865         struct sockaddr_in *addr,
 866         int flags,
 867         int turn_off_reuse
 868         )
 869 {
 870         int fd;
 871         int on = 1, off = 0;
 872 #if defined(IPTOS_LOWDELAY) && defined(IPPROTO_IP) && defined(IP_TOS)
 873         int tos;
 874 #endif /* IPTOS_LOWDELAY && IPPROTO_IP && IP_TOS */
 875
 876         /* create a datagram (UDP) socket */
 877         if (  (fd = socket(AF_INET, SOCK_DGRAM, 0))
 878 #ifndef SYS_WINNT
 879               < 0
 880 #else
 881               == INVALID_SOCKET
 882 #endif /* SYS_WINNT */
 883               )
 884         {
 885                 msyslog(LOG_ERR, "socket(AF_INET, SOCK_DGRAM, 0) failed: %m");
 886                 exit(1);
 887                 /*NOTREACHED*/
 888         }
 889
 890         /* set SO_REUSEADDR since we will be binding the same port
 891            number on each interface */
 892         if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
 893                        (char *)&on, sizeof(on)))
 894         {
 895                 msyslog(LOG_ERR, "setsockopt SO_REUSEADDR on fails: %m");
 896         }
 897
 898 #if defined(IPTOS_LOWDELAY) && defined(IPPROTO_IP) && defined(IP_TOS)
 899         /* set IP_TOS to minimize packet delay */
 900         tos = IPTOS_LOWDELAY;
 901         if (setsockopt(fd, IPPROTO_IP, IP_TOS, (char *) &tos, sizeof(tos)) < 0)
 902         {
 903                 msyslog(LOG_ERR, "setsockopt IPTOS_LOWDELAY on fails: %m");
 904         }
 905 #endif /* IPTOS_LOWDELAY && IPPROTO_IP && IP_TOS */
 906
 907         /*
 908          * bind the local address.
 909          */
 910         if (bind(fd, (struct sockaddr *)addr, sizeof(*addr)) < 0) {
 911                 char buff[160];
 912                 sprintf(buff,
 913                         "bind() fd %d, family %d, port %d, addr %s, in_classd=%d flags=%d fails: %%m",
 914                         fd, addr->sin_family, (int)ntohs(addr->sin_port),
 915                         ntoa(addr),
 916                         IN_CLASSD(ntohl(addr->sin_addr.s_addr)), flags);
 917                 msyslog(LOG_ERR, buff);
 918                 closesocket(fd);
 919
 920                 /*
 921                  * soft fail if opening a class D address
 922                  */
 923                 if (IN_CLASSD(ntohl(addr->sin_addr.s_addr)))
 924                     return -1;
 925 #if 0
 926                 exit(1);
 927 #else
 928                 return -1;
 929 #endif
 930         }
 931 #ifdef DEBUG
 932         if (debug)
 933             printf("bind() fd %d, family %d, port %d, addr %s, flags=%d\n",
 934                    fd,
 935                    addr->sin_family,
 936                    (int)ntohs(addr->sin_port),
 937                    ntoa(addr),
 938                    flags);
 939 #endif
 940         if (fd > maxactivefd)
 941             maxactivefd = fd;
 942         FD_SET(fd, &activefds);
 943
 944         /*
 945          * set non-blocking,
 946          */
 947
 948 #ifdef USE_FIONBIO
 949         /* in vxWorks we use FIONBIO, but the others are defined for old systems, so
 950          * all hell breaks loose if we leave them defined
 951          */
 952 #undef O_NONBLOCK
 953 #undef FNDELAY
 954 #undef O_NDELAY
 955 #endif
 956
 957 #if defined(O_NONBLOCK) /* POSIX */
 958         if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
 959         {
 960                 msyslog(LOG_ERR, "fcntl(O_NONBLOCK) fails: %m");
 961                 exit(1);
 962                 /*NOTREACHED*/
 963         }
 964 #elif defined(FNDELAY)
 965         if (fcntl(fd, F_SETFL, FNDELAY) < 0)
 966         {
 967                 msyslog(LOG_ERR, "fcntl(FNDELAY) fails: %m");
 968                 exit(1);
 969                 /*NOTREACHED*/
 970         }
 971 #elif defined(O_NDELAY) /* generally the same as FNDELAY */
 972         if (fcntl(fd, F_SETFL, O_NDELAY) < 0)
 973         {
 974                 msyslog(LOG_ERR, "fcntl(O_NDELAY) fails: %m");
 975                 exit(1);
 976                 /*NOTREACHED*/
 977         }
 978 #elif defined(FIONBIO)
 979         if (
 980 # if defined(VMS)
 981                 (ioctl(fd,FIONBIO,&1) < 0)
 982 # elif defined(SYS_WINNT)
 983                 (ioctlsocket(fd,FIONBIO,(u_long *) &on) == SOCKET_ERROR)
 984 # else
 985                 (ioctl(fd,FIONBIO,&on) < 0)
 986 # endif
 987            )
 988         {
 989                 msyslog(LOG_ERR, "ioctl(FIONBIO) fails: %m");
 990                 exit(1);
 991                 /*NOTREACHED*/
 992         }
 993 #elif defined(FIOSNBIO)
 994         if (ioctl(fd,FIOSNBIO,&on) < 0)
 995         {
 996                 msyslog(LOG_ERR, "ioctl(FIOSNBIO) fails: %m");
 997                 exit(1);
 998                 /*NOTREACHED*/
 999         }
1000 #else
1001 # include "Bletch: Need non-blocking I/O!"
1002 #endif
1003
1004 #ifdef HAVE_SIGNALED_IO
1005         init_socket_sig(fd);
1006 #endif /* not HAVE_SIGNALED_IO */
1007
1008         /*
1009          *      Turn off the SO_REUSEADDR socket option.  It apparently
1010          *      causes heartburn on systems with multicast IP installed.
1011          *      On normal systems it only gets looked at when the address
1012          *      is being bound anyway..
1013          */
1014         if (turn_off_reuse)
1015             if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1016                            (char *)&off, sizeof(off)))
1017             {
1018                     msyslog(LOG_ERR, "setsockopt SO_REUSEADDR off fails: %m");
1019             }
1020
1021 #ifdef SO_BROADCAST
1022         /* if this interface can support broadcast, set SO_BROADCAST */
1023         if (flags & INT_BROADCAST)
1024         {
1025                 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST,
1026                                (char *)&on, sizeof(on)))
1027                 {
1028                         msyslog(LOG_ERR, "setsockopt(SO_BROADCAST): %m");
1029                 }
1030         }
1031 #endif /* SO_BROADCAST */
1032
1033 #if !defined(SYS_WINNT) && !defined(VMS)
1034 # ifdef DEBUG
1035         if (debug > 1)
1036             printf("flags for fd %d: 0%o\n", fd,
1037                    fcntl(fd, F_GETFL, 0));
1038 # endif
1039 #endif /* SYS_WINNT || VMS */
1040
1041         return fd;
1042 }
1043
1044
1045 /*
1046  * close_socket - close a socket and remove from the activefd list
1047  */
1048 static void
1049 close_socket(
1050         int fd
1051         )
1052 {
1053         int i, newmax;
1054
1055         (void) closesocket(fd);
1056         FD_CLR( (u_int) fd, &activefds);
1057
1058         if (fd >= maxactivefd) {
1059                 newmax = 0;
1060                 for (i = 0; i < maxactivefd; i++)
1061                         if (FD_ISSET(i, &activefds))
1062                                 newmax = i;
1063                 maxactivefd = newmax;
1064         }
1065 }
1066
1067
1068 /*
1069  * close_file - close a file and remove from the activefd list
1070  * added 1/31/1997 Greg Schueman for Windows NT portability
1071  */
1072 static void
1073 close_file(
1074         int fd
1075         )
1076 {
1077         int i, newmax;
1078
1079         (void) close(fd);
1080         FD_CLR( (u_int) fd, &activefds);
1081
1082         if (fd >= maxactivefd) {
1083                 newmax = 0;
1084                 for (i = 0; i < maxactivefd; i++)
1085                         if (FD_ISSET(i, &activefds))
1086                                 newmax = i;
1087                 maxactivefd = newmax;
1088         }
1089 }
1090
1091
1092 /* XXX ELIMINATE sendpkt similar in ntpq.c, ntpdc.c, ntp_io.c, ntptrace.c */
1093 /*
1094  * sendpkt - send a packet to the specified destination. Maintain a
1095  * send error cache so that only the first consecutive error for a
1096  * destination is logged.
1097  */
1098 void
1099 sendpkt(
1100         struct sockaddr_in *dest,
1101         struct interface *inter,
1102         int ttl,
1103         struct pkt *pkt,
1104         int len
1105         )
1106 {
1107         int cc, slot;
1108 #ifdef SYS_WINNT
1109         DWORD err;
1110 #endif /* SYS_WINNT */
1111
1112         /*
1113          * Send error cache. Empty slots have port == 0
1114          * Set ERRORCACHESIZE to 0 to disable
1115          */
1116         struct cache {
1117                 u_short port;
1118                 struct  in_addr addr;
1119         };
1120
1121 #ifndef ERRORCACHESIZE
1122 #define ERRORCACHESIZE 8
1123 #endif
1124 #if ERRORCACHESIZE > 0
1125         static struct cache badaddrs[ERRORCACHESIZE];
1126 #else
1127 #define badaddrs ((struct cache *)0)            /* Only used in empty loops! */
1128 #endif
1129 #ifdef DEBUG
1130         if (debug > 1)
1131             printf("%ssendpkt(fd=%d dst=%s, src=%s, ttl=%d, len=%d)\n",
1132                    (ttl >= 0) ? "\tMCAST\t*****" : "",
1133                    inter->fd, ntoa(dest),
1134                    ntoa(&inter->sin), ttl, len);
1135 #endif
1136
1137 #ifdef MCAST
1138         /*
1139          * for the moment we use the bcast option to set multicast ttl
1140          */
1141         if (ttl > 0 && ttl != inter->last_ttl) {
1142                 char mttl = ttl;
1143
1144                 /*
1145                  * set the multicast ttl for outgoing packets
1146                  */
1147                 if (setsockopt(inter->fd, IPPROTO_IP, IP_MULTICAST_TTL,
1148                     &mttl, sizeof(mttl)) == -1)
1149                         msyslog(LOG_ERR, "setsockopt IP_MULTICAST_TTL fails: %m");
1150                 else
1151                         inter->last_ttl = ttl;
1152         }
1153 #endif /* MCAST */
1154
1155         for (slot = ERRORCACHESIZE; --slot >= 0; )
1156             if (badaddrs[slot].port == dest->sin_port &&
1157                 badaddrs[slot].addr.s_addr == dest->sin_addr.s_addr)
1158                 break;
1159
1160 #if defined(HAVE_IO_COMPLETION_PORT)
1161         err = io_completion_port_sendto(inter, pkt, len, dest);
1162         if (err != ERROR_SUCCESS)
1163 #else
1164         cc = sendto(inter->fd, (char *)pkt, (size_t)len, 0, (struct sockaddr *)dest,
1165                     sizeof(struct sockaddr_in));
1166         if (cc == -1)
1167 #endif
1168         {
1169                 inter->notsent++;
1170                 packets_notsent++;
1171 #if defined(HAVE_IO_COMPLETION_PORT)
1172                 if (err != WSAEWOULDBLOCK && err != WSAENOBUFS && slot < 0)
1173 #else
1174                 if (errno != EWOULDBLOCK && errno != ENOBUFS && slot < 0)
1175 #endif
1176                 {
1177                         /*
1178                          * Remember this, if there's an empty slot
1179                          */
1180                         for (slot = ERRORCACHESIZE; --slot >= 0; )
1181                             if (badaddrs[slot].port == 0)
1182                             {
1183                                     badaddrs[slot].port = dest->sin_port;
1184                                     badaddrs[slot].addr = dest->sin_addr;
1185                                     break;
1186                             }
1187                         msyslog(LOG_ERR, "sendto(%s): %m", ntoa(dest));
1188                 }
1189         }
1190         else
1191         {
1192                 inter->sent++;
1193                 packets_sent++;
1194                 /*
1195                  * He's not bad any more
1196                  */
1197                 if (slot >= 0)
1198                 {
1199                         msyslog(LOG_INFO, "Connection re-established to %s", ntoa(dest));
1200                         badaddrs[slot].port = 0;
1201                 }
1202         }
1203 }
1204
1205 #if !defined(HAVE_IO_COMPLETION_PORT)
1206 /*
1207  * fdbits - generate ascii representation of fd_set (FAU debug support)
1208  * HFDF format - highest fd first.
1209  */
1210 static char *
1211 fdbits(
1212         int count,
1213         fd_set *set
1214         )
1215 {
1216         static char buffer[256];
1217         char * buf = buffer;
1218
1219         count = (count < 256) ? count : 255;
1220
1221         while (count >= 0)
1222         {
1223                 *buf++ = FD_ISSET(count, set) ? '#' : '-';
1224                 count--;
1225         }
1226         *buf = '\0';
1227
1228         return buffer;
1229 }
1230
1231 /*
1232  * input_handler - receive packets asynchronously
1233  */
1234 extern void
1235 input_handler(
1236         l_fp *cts
1237         )
1238 {
1239         register int i, n;
1240         register struct recvbuf *rb;
1241         register int doing;
1242         register int fd;
1243         struct timeval tvzero;
1244         int fromlen;
1245         l_fp ts;                        /* Timestamp at BOselect() gob */
1246         l_fp ts_e;                      /* Timestamp at EOselect() gob */
1247         fd_set fds;
1248         int select_count = 0;
1249         static int handler_count = 0;
1250
1251         ++handler_count;
1252         if (handler_count != 1)
1253             msyslog(LOG_ERR, "input_handler: handler_count is %d!", handler_count);
1254         handler_calls++;
1255         ts = *cts;
1256
1257         for (;;)
1258         {
1259                 /*
1260                  * Do a poll to see who has data
1261                  */
1262
1263                 fds = activefds;
1264                 tvzero.tv_sec = tvzero.tv_usec = 0;
1265
1266                 /*
1267                  * If we have something to do, freeze a timestamp.
1268                  * See below for the other cases (nothing (left) to do or error)
1269                  */
1270                 while (0 < (n = select(maxactivefd+1, &fds, (fd_set *)0, (fd_set *)0, &tvzero)))
1271                 {
1272                         ++select_count;
1273                         ++handler_pkts;
1274
1275 #ifdef REFCLOCK
1276                         /*
1277                          * Check out the reference clocks first, if any
1278                          */
1279                         if (refio != 0)
1280                         {
1281                                 register struct refclockio *rp;
1282
1283                                 for (rp = refio; rp != 0 && n > 0; rp = rp->next)
1284                                 {
1285                                         fd = rp->fd;
1286                                         if (FD_ISSET(fd, &fds))
1287                                         {
1288                                                 n--;
1289                                                 if (free_recvbuffs() == 0)
1290                                                 {
1291                                                         char buf[RX_BUFF_SIZE];
1292
1293                                                         (void) read(fd, buf, sizeof buf);
1294                                                         packets_dropped++;
1295                                                         goto select_again;
1296                                                 }
1297
1298                                                 rb = get_free_recv_buffer();
1299
1300                                                 i = (rp->datalen == 0
1301                                                      || rp->datalen > sizeof(rb->recv_space))
1302                                                     ? sizeof(rb->recv_space) : rp->datalen;
1303                                                 rb->recv_length =
1304                                                     read(fd, (char *)&rb->recv_space, (unsigned)i);
1305
1306                                                 if (rb->recv_length == -1)
1307                                                 {
1308                                                         msyslog(LOG_ERR, "clock read fd %d: %m", fd);
1309                                                         freerecvbuf(rb);
1310                                                         goto select_again;
1311                                                 }
1312
1313                                                 /*
1314                                                  * Got one.  Mark how and when it got here,
1315                                                  * put it on the full list and do bookkeeping.
1316                                                  */
1317                                                 rb->recv_srcclock = rp->srcclock;
1318                                                 rb->dstadr = 0;
1319                                                 rb->fd = fd;
1320                                                 rb->recv_time = ts;
1321                                                 rb->receiver = rp->clock_recv;
1322
1323                                                 if (rp->io_input)
1324                                                 {
1325                                                         /*
1326                                                          * have direct input routine for refclocks
1327                                                          */
1328                                                         if (rp->io_input(rb) == 0)
1329                                                         {
1330                                                                 /*
1331                                                                  * data was consumed - nothing to pass up
1332                                                                  * into block input machine
1333                                                                  */
1334                                                                 freerecvbuf(rb);
1335 #if 1
1336                                                                 goto select_again;
1337 #else
1338                                                                 continue;
1339 #endif
1340                                                         }
1341                                                 }
1342
1343                                                 add_full_recv_buffer(rb);
1344
1345                                                 rp->recvcount++;
1346                                                 packets_received++;
1347                                         }
1348                                 }
1349                         }
1350 #endif /* REFCLOCK */
1351
1352                         /*
1353                          * Loop through the interfaces looking for data to read.
1354                          */
1355                         for (i = ninterfaces - 1; (i >= 0) && (n > 0); i--)
1356                         {
1357                                 for (doing = 0; (doing < 2) && (n > 0); doing++)
1358                                 {
1359                                         if (doing == 0)
1360                                         {
1361                                                 fd = inter_list[i].fd;
1362                                         }
1363                                         else
1364                                         {
1365                                                 if (!(inter_list[i].flags & INT_BCASTOPEN))
1366                                                     break;
1367                                                 fd = inter_list[i].bfd;
1368                                         }
1369                                         if (fd < 0) continue;
1370                                         if (FD_ISSET(fd, &fds))
1371                                         {
1372                                                 n--;
1373
1374                                                 /*
1375                                                  * Get a buffer and read the frame.  If we
1376                                                  * haven't got a buffer, or this is received
1377                                                  * on the wild card socket, just dump the
1378                                                  * packet.
1379                                                  */
1380                                                 if (
1381 #ifdef UDP_WILDCARD_DELIVERY
1382                                 /*
1383                                  * these guys manage to put properly addressed
1384                                  * packets into the wildcard queue
1385                                  */
1386                                                         (free_recvbuffs() == 0)
1387 #else
1388                                                         ((i == 0) || (free_recvbuffs() == 0))
1389 #endif
1390                                                         )
1391         {
1392                 char buf[RX_BUFF_SIZE];
1393                 struct sockaddr from;
1394
1395                 fromlen = sizeof from;
1396                 (void) recvfrom(fd, buf, sizeof(buf), 0, &from, &fromlen);
1397 #ifdef DEBUG
1398                 if (debug)
1399                     printf("%s on %d(%lu) fd=%d from %s\n",
1400                            (i) ? "drop" : "ignore",
1401                            i, free_recvbuffs(), fd,
1402                            inet_ntoa(((struct sockaddr_in *) &from)->sin_addr));
1403 #endif
1404                 if (i == 0)
1405                     packets_ignored++;
1406                 else
1407                     packets_dropped++;
1408                 goto select_again;
1409         }
1410
1411         rb = get_free_recv_buffer();
1412
1413         fromlen = sizeof(struct sockaddr_in);
1414         rb->recv_length = recvfrom(fd,
1415                                    (char *)&rb->recv_space,
1416                                    sizeof(rb->recv_space), 0,
1417                                    (struct sockaddr *)&rb->recv_srcadr,
1418                                    &fromlen);
1419         if (rb->recv_length == 0
1420 #ifdef EWOULDBLOCK
1421                  || errno==EWOULDBLOCK
1422 #endif
1423 #ifdef EAGAIN
1424                  || errno==EAGAIN
1425 #endif
1426                  ) {
1427                 freerecvbuf(rb);
1428             continue;
1429         }
1430         else if (rb->recv_length < 0)
1431         {
1432                 msyslog(LOG_ERR, "recvfrom(%s) fd=%d: %m",
1433                         inet_ntoa(rb->recv_srcadr.sin_addr), fd);
1434 #ifdef DEBUG
1435                 if (debug)
1436                     printf("input_handler: fd=%d dropped (bad recvfrom)\n", fd);
1437 #endif
1438                 freerecvbuf(rb);
1439                 continue;
1440         }
1441 #ifdef DEBUG
1442         if (debug > 2)
1443             printf("input_handler: if=%d fd=%d length %d from %08lx %s\n",
1444                    i, fd, rb->recv_length,
1445                    (u_long)ntohl(rb->recv_srcadr.sin_addr.s_addr) &
1446                    0x00000000ffffffff,
1447                    inet_ntoa(rb->recv_srcadr.sin_addr));
1448 #endif
1449
1450         /*
1451          * Got one.  Mark how and when it got here,
1452          * put it on the full list and do bookkeeping.
1453          */
1454         rb->dstadr = &inter_list[i];
1455         rb->fd = fd;
1456         rb->recv_time = ts;
1457         rb->receiver = receive;
1458
1459         add_full_recv_buffer(rb);
1460
1461         inter_list[i].received++;
1462         packets_received++;
1463         goto select_again;
1464                                         }
1465                                         /* Check more interfaces */
1466                                 }
1467                         }
1468                 select_again:;
1469                         /*
1470                          * Done everything from that select.  Poll again.
1471                          */
1472                 }
1473
1474                 /*
1475                  * If nothing more to do, try again.
1476                  * If nothing to do, just return.
1477                  * If an error occurred, complain and return.
1478                  */
1479                 if (n == 0)
1480                 {
1481                         if (select_count == 0) /* We really had nothing to do */
1482                         {
1483                                 if (debug)
1484                                     msyslog(LOG_DEBUG, "input_handler: select() returned 0");
1485                                 --handler_count;
1486                                 return;
1487                         }
1488                         /* We've done our work */
1489                         get_systime(&ts_e);
1490                         /*
1491                          * (ts_e - ts) is the amount of time we spent processing
1492                          * this gob of file descriptors.  Log it.
1493                          */
1494                         L_SUB(&ts_e, &ts);
1495                         if (debug > 3)
1496                             msyslog(LOG_INFO, "input_handler: Processed a gob of fd's in %s msec", lfptoms(&ts_e, 6));
1497
1498                         /* just bail. */
1499                         --handler_count;
1500                         return;
1501                 }
1502                 else if (n == -1)
1503                 {
1504                         int err = errno;
1505
1506                         /*
1507                          * extended FAU debugging output
1508                          */
1509                         msyslog(LOG_ERR, "select(%d, %s, 0L, 0L, &0.000000) error: %m",
1510                                 maxactivefd+1, fdbits(maxactivefd, &activefds));
1511                         if (err == EBADF) {
1512                                 int j, b;
1513
1514                                 fds = activefds;
1515                                 for (j = 0; j <= maxactivefd; j++)
1516                                     if (
1517                                             (FD_ISSET(j, &fds) && (read(j, &b, 0) == -1))
1518                                             )
1519                                         msyslog(LOG_ERR, "Bad file descriptor %d", j);
1520                         }
1521                         --handler_count;
1522                         return;
1523                 }
1524         }
1525         msyslog(LOG_ERR, "input_handler: fell out of infinite for(;;) loop!");
1526         --handler_count;
1527         return;
1528 }
1529
1530 #endif
1531
1532 /*
1533  * findinterface - find interface corresponding to address
1534  */
1535 struct interface *
1536 findinterface(
1537         struct sockaddr_in *addr
1538         )
1539 {
1540         int s, rtn, i;
1541         struct sockaddr_in saddr;
1542         int saddrlen = sizeof(saddr);
1543         u_int32 xaddr;
1544
1545         /*
1546          * This is considerably hoke. We open a socket, connect to it
1547          * and slap a getsockname() on it. If anything breaks, as it
1548          * probably will in some j-random knockoff, we just return the
1549          * wildcard interface.
1550          */
1551         saddr.sin_family = AF_INET;
1552         saddr.sin_addr.s_addr = addr->sin_addr.s_addr;
1553         saddr.sin_port = htons(2000);
1554         s = socket(AF_INET, SOCK_DGRAM, 0);
1555         if (s < 0)
1556                 return (any_interface);
1557
1558         rtn = connect(s, (struct sockaddr *)&saddr, sizeof(saddr));
1559         if (rtn < 0)
1560                 return (any_interface);
1561
1562         rtn = getsockname(s, (struct sockaddr *)&saddr, &saddrlen);
1563         if (rtn < 0)
1564                 return (any_interface);
1565
1566         close(s);
1567         xaddr = NSRCADR(&saddr);
1568         for (i = 1; i < ninterfaces; i++) {
1569
1570                 /*
1571                  * We match the unicast address only.
1572                  */
1573                 if (NSRCADR(&inter_list[i].sin) == xaddr)
1574                         return (&inter_list[i]);
1575         }
1576         return (any_interface);
1577 }
1578
1579
1580 /*
1581  * findbcastinter - find broadcast interface corresponding to address
1582  */
1583 struct interface *
1584 findbcastinter(
1585         struct sockaddr_in *addr
1586         )
1587 {
1588 #if defined(SIOCGIFCONF) || defined(SYS_WINNT)
1589         register int i;
1590         register u_int32 xaddr;
1591
1592         xaddr = NSRCADR(addr);
1593         for (i = 1; i < ninterfaces; i++) {
1594
1595                 /*
1596                  * We match only those interfaces marked as
1597                  * broadcastable and either the explicit broadcast
1598                  * address or the network portion of the IP address.
1599                  * Sloppy.
1600                  */
1601                 if (!(inter_list[i].flags & INT_BROADCAST))
1602                         continue;
1603                 if (NSRCADR(&inter_list[i].bcast) == xaddr)
1604                         return (&inter_list[i]);
1605                 if ((NSRCADR(&inter_list[i].sin) &
1606                     NSRCADR(&inter_list[i].mask)) == (xaddr &
1607                     NSRCADR(&inter_list[i].mask)))
1608                         return (&inter_list[i]);
1609         }
1610 #endif /* SIOCGIFCONF */
1611         return (any_interface);
1612 }
1613
1614
1615 /*
1616  * io_clr_stats - clear I/O module statistics
1617  */
1618 void
1619 io_clr_stats(void)
1620 {
1621         packets_dropped = 0;
1622         packets_ignored = 0;
1623         packets_received = 0;
1624         packets_sent = 0;
1625         packets_notsent = 0;
1626
1627         handler_calls = 0;
1628         handler_pkts = 0;
1629         io_timereset = current_time;
1630 }
1631
1632
1633 #ifdef REFCLOCK
1634 /*
1635  * This is a hack so that I don't have to fool with these ioctls in the
1636  * pps driver ... we are already non-blocking and turn on SIGIO thru
1637  * another mechanisim
1638  */
1639 int
1640 io_addclock_simple(
1641         struct refclockio *rio
1642         )
1643 {
1644         BLOCKIO();
1645         /*
1646          * Stuff the I/O structure in the list and mark the descriptor
1647          * in use.      There is a harmless (I hope) race condition here.
1648          */
1649         rio->next = refio;
1650         refio = rio;
1651
1652         if (rio->fd > maxactivefd)
1653             maxactivefd = rio->fd;
1654         FD_SET(rio->fd, &activefds);
1655         UNBLOCKIO();
1656         return 1;
1657 }
1658
1659 /*
1660  * io_addclock - add a reference clock to the list and arrange that we
1661  *                               get SIGIO interrupts from it.
1662  */
1663 int
1664 io_addclock(
1665         struct refclockio *rio
1666         )
1667 {
1668         BLOCKIO();
1669         /*
1670          * Stuff the I/O structure in the list and mark the descriptor
1671          * in use.      There is a harmless (I hope) race condition here.
1672          */
1673         rio->next = refio;
1674         refio = rio;
1675
1676 # ifdef HAVE_SIGNALED_IO
1677         if (init_clock_sig(rio))
1678         {
1679                 refio = rio->next;
1680                 UNBLOCKIO();
1681                 return 0;
1682         }
1683 # elif defined(HAVE_IO_COMPLETION_PORT)
1684         if (io_completion_port_add_clock_io(rio))
1685         {
1686                 refio = rio->next;
1687                 UNBLOCKIO();
1688                 return 0;
1689         }
1690 # endif
1691
1692         if (rio->fd > maxactivefd)
1693             maxactivefd = rio->fd;
1694         FD_SET(rio->fd, &activefds);
1695
1696         UNBLOCKIO();
1697         return 1;
1698 }
1699
1700 /*
1701  * io_closeclock - close the clock in the I/O structure given
1702  */
1703 void
1704 io_closeclock(
1705         struct refclockio *rio
1706         )
1707 {
1708         /*
1709          * Remove structure from the list
1710          */
1711         if (refio == rio)
1712         {
1713                 refio = rio->next;
1714         }
1715         else
1716         {
1717                 register struct refclockio *rp;
1718
1719                 for (rp = refio; rp != 0; rp = rp->next)
1720                     if (rp->next == rio)
1721                     {
1722                             rp->next = rio->next;
1723                             break;
1724                     }
1725
1726                 if (rp == 0)
1727                 {
1728                         /*
1729                          * Internal error.      Report it.
1730                          */
1731                         msyslog(LOG_ERR,
1732                                 "internal error: refclockio structure not found");
1733                         return;
1734                 }
1735         }
1736
1737         /*
1738          * Close the descriptor.
1739          */
1740         close_file(rio->fd);
1741 }
1742 #endif  /* REFCLOCK */
1743
1744 void
1745 kill_asyncio(void)
1746 {
1747         int i;
1748
1749         BLOCKIO();
1750         for (i = 0; i <= maxactivefd; i++)
1751             (void)close_socket(i);
1752 }