← Back to branch summary

~ubuntu-branches/debian/squeeze/ntp/squeeze-201010051545

« back to all changes in this revision

Viewing changes to ntpdate/ntpdate.c

  • Committer: Bazaar Package Importer
  • Author(s): Matt Zimmerman
  • Date: 2004-10-11 16:10:27 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20041011161027-icyjbji8ujym633o
Tags: 1:4.2.0a-10ubuntu2
Use ntp.ubuntulinux.org instead of pool.ntp.org

Show diffs side-by-side

added added

removed removed

Lines of Context:
ntpdate/ntpdate.c
10
10
#include <netinfo/ni.h>
11
11
#endif
12
12
 
 
13
#include "ntp_machine.h"
13
14
#include "ntp_fp.h"
14
15
#include "ntp.h"
15
16
#include "ntp_io.h"
32
33
#endif
33
34
#ifndef SYS_WINNT
34
35
# include <netdb.h>
35
 
# include <sys/signal.h>
 
36
# ifdef HAVE_SYS_SIGNAL_H
 
37
#  include <sys/signal.h>
 
38
# else
 
39
#  include <signal.h>
 
40
# endif
36
41
# ifdef HAVE_SYS_IOCTL_H
37
42
#  include <sys/ioctl.h>
38
43
# endif
41
46
# include <sys/resource.h>
42
47
#endif /* HAVE_SYS_RESOURCE_H */
43
48
 
 
49
#include <arpa/inet.h>
 
50
 
 
51
#ifdef __QNXNTO__
 
52
# include "adjtime.h"
 
53
#endif
 
54
 
44
55
#ifdef SYS_VXWORKS
45
56
# include "ioLib.h"
46
57
# include "sockLib.h"
52
63
struct timeval timeout = {60,0};
53
64
#endif
54
65
 
 
66
#ifdef HAVE_NETINFO
 
67
#include <netinfo/ni.h>
 
68
#endif
 
69
 
55
70
#include "recvbuff.h"
56
71
 
57
72
#ifdef SYS_WINNT
58
 
# define TARGET_RESOLUTION 1  /* Try for 1-millisecond accuracy
 
73
#define EPROTONOSUPPORT WSAEPROTONOSUPPORT
 
74
#define EAFNOSUPPORT    WSAEAFNOSUPPORT
 
75
#define EPFNOSUPPORT    WSAEPFNOSUPPORT
 
76
#define TARGET_RESOLUTION 1  /* Try for 1-millisecond accuracy
59
77
                                on Windows NT timers. */
60
78
#pragma comment(lib, "winmm")
61
79
#endif /* SYS_WINNT */
93
111
/*
94
112
 * File descriptor masks etc. for call to select
95
113
 */
96
 
int fd;
 
114
 
 
115
int ai_fam_templ;
 
116
int nbsock;
 
117
SOCKET fd[MAX_AF];      /* support up to 2 sockets */
 
118
int fd_family[MAX_AF];  /* to remember the socket family */
97
119
#ifdef HAVE_POLL_H
98
 
struct pollfd fdmask;
 
120
struct pollfd fdmask[MAX_AF];
99
121
#else
100
122
fd_set fdmask;
 
123
int maxfd;
101
124
#endif
 
125
int polltest = 0;
102
126
 
103
127
/*
104
128
 * Initializing flag.  All async routines watch this and only do their
179
203
int never_step = 0;
180
204
 
181
205
int     ntpdatemain P((int, char **));
 
206
 
182
207
static  void    transmit        P((struct server *));
183
208
static  void    receive         P((struct recvbuf *));
184
209
static  void    server_data P((struct server *, s_fp, l_fp *, u_fp));
186
211
static  struct server *clock_select P((void));
187
212
static  int clock_adjust        P((void));
188
213
static  void    addserver       P((char *));
189
 
static  struct server *findserver P((struct sockaddr_in *));
 
214
static  struct server *findserver P((struct sockaddr_storage *));
190
215
                void    timer           P((void));
191
216
static  void    init_alarm      P((void));
192
217
#ifndef SYS_WINNT
193
218
static  RETSIGTYPE alarming P((int));
194
219
#endif /* SYS_WINNT */
195
220
static  void    init_io         P((void));
196
 
static  void    sendpkt         P((struct sockaddr_in *, struct pkt *, int));
 
221
static  void    sendpkt         P((struct sockaddr_storage *, struct pkt *, int));
197
222
void    input_handler   P((void));
198
223
 
199
224
static  int l_adj_systime       P((l_fp *));
200
225
static  int l_step_systime      P((l_fp *));
201
226
 
202
 
static  int getnetnum   P((const char *, u_int32 *));
203
227
static  void    printserver P((struct server *, FILE *));
204
228
 
205
229
#ifdef SYS_WINNT
300
324
        l_fp tmp;
301
325
        int errflg;
302
326
        int c;
 
327
        int nfound;
 
328
 
303
329
#ifdef HAVE_NETINFO
304
330
        ni_namelist *netinfoservers;
305
331
#endif
308
334
 
309
335
        wVersionRequested = MAKEWORD(1,1);
310
336
        if (WSAStartup(wVersionRequested, &wsaData)) {
311
 
                msyslog(LOG_ERR, "No useable winsock.dll: %m");
 
337
                netsyslog(LOG_ERR, "No useable winsock.dll: %m");
312
338
                exit(1);
313
339
        }
314
340
 
331
357
        /*
332
358
         * Decode argument list
333
359
         */
334
 
        while ((c = ntp_getopt(argc, argv, "a:bBde:k:o:p:qr:st:uv")) != EOF)
 
360
        while ((c = ntp_getopt(argc, argv, "46a:bBde:k:o:p:qr:st:uv")) != EOF)
335
361
                switch (c)
336
362
                {
 
363
                case '4':
 
364
                        ai_fam_templ = AF_INET;
 
365
                        break;
 
366
                case '6':
 
367
                        ai_fam_templ = AF_INET6;
 
368
                        break;
337
369
                case 'a':
338
370
                        c = atoi(ntp_optarg);
339
371
                        sys_authenticate = 1;
423
455
        
424
456
        if (errflg) {
425
457
                (void) fprintf(stderr,
426
 
                                   "usage: %s [-bBdqsv] [-a key#] [-e delay] [-k file] [-p samples] [-o version#] [-r rate] [-t timeo] server ...\n",
427
 
                                   progname);
 
458
                    "usage: %s [-46bBdqsuv] [-a key#] [-e delay] [-k file] [-p samples] [-o version#] [-r rate] [-t timeo] server ...\n",
 
459
                    progname);
428
460
                exit(2);
429
461
        }
430
462
 
533
565
        }
534
566
#endif /* SYS_WINNT */
535
567
 
 
568
 
 
569
 
536
570
        initializing = 0;
537
 
 
538
571
        was_alarmed = 0;
539
572
        rbuflist = (struct recvbuf *)0;
 
573
 
540
574
        while (complete_servers < sys_numservers) {
541
575
#ifdef HAVE_POLL_H
542
 
                struct pollfd rdfdes;
 
576
                struct pollfd* rdfdes;
 
577
                rdfdes = fdmask;
543
578
#else
544
579
                fd_set rdfdes;
 
580
                rdfdes = fdmask;
545
581
#endif
546
 
                int nfound;
547
582
 
548
583
                if (alarm_flag) {               /* alarmed? */
549
584
                        was_alarmed = 1;
555
590
                        /*
556
591
                         * Nothing to do.        Wait for something.
557
592
                         */
558
 
                        rdfdes = fdmask;
559
593
#ifdef HAVE_POLL_H
560
 
                        nfound = poll(&rdfdes, 1, timeout.tv_sec * 1000);
 
594
                        nfound = poll(rdfdes, (unsigned int)nbsock, timeout.tv_sec * 1000);
 
595
 
561
596
#else
562
 
                        nfound = select(fd+1, &rdfdes, (fd_set *)0,
 
597
                        nfound = select(maxfd, &rdfdes, (fd_set *)0,
563
598
                                        (fd_set *)0, &timeout);
564
599
#endif
565
600
                        if (nfound > 0)
574
609
#ifndef SYS_WINNT
575
610
                                if (errno != EINTR)
576
611
#endif
577
 
                                        msyslog(LOG_ERR,
 
612
                                        netsyslog(LOG_ERR,
578
613
#ifdef HAVE_POLL_H
579
614
                                                "poll() error: %m"
580
615
#else
583
618
                                                );
584
619
                        } else {
585
620
#ifndef SYS_VXWORKS
586
 
                                msyslog(LOG_DEBUG,
 
621
                                netsyslog(LOG_DEBUG,
587
622
#ifdef HAVE_POLL_H
588
623
                                        "poll(): nfound = %d, error: %m",
589
624
#else
634
669
        close (fd);
635
670
        timer_delete(ntpdate_timerid);
636
671
#endif
 
672
 
637
673
        return clock_adjust();
638
674
}
639
675
 
640
676
 
641
677
/*
642
678
 * transmit - transmit a packet to the given server, or mark it completed.
643
 
 *                This is called by the timeout routine and by the receive
644
 
 *                procedure.
 
679
 *              This is called by the timeout routine and by the receive
 
680
 *              procedure.
645
681
 */
646
682
static void
647
683
transmit(
651
687
        struct pkt xpkt;
652
688
 
653
689
        if (debug)
654
 
                printf("transmit(%s)\n", ntoa(&server->srcadr));
 
690
                printf("transmit(%s)\n", stoa(&(server->srcadr)));
655
691
 
656
692
        if (server->filter_nextpt < server->xmtcnt) {
657
693
                l_fp ts;
674
710
        }
675
711
 
676
712
        /*
677
 
         * If we're here, send another message to the server.    Fill in
 
713
         * If we're here, send another message to the server.  Fill in
678
714
         * the packet and let 'er rip.
679
715
         */
680
716
        xpkt.li_vn_mode = PKT_LI_VN_MODE(LEAP_NOTINSYNC,
706
742
 
707
743
                if (debug > 1)
708
744
                        printf("transmit auth to %s\n",
709
 
                           ntoa(&(server->srcadr)));
 
745
                           stoa(&(server->srcadr)));
710
746
        } else {
711
747
                get_systime(&(server->xmt));
712
748
                HTONL_FP(&server->xmt, &xpkt.xmt);
713
749
                sendpkt(&(server->srcadr), &xpkt, LEN_PKT_NOMAC);
714
750
 
715
751
                if (debug > 1)
716
 
                        printf("transmit to %s\n", ntoa(&(server->srcadr)));
 
752
                        printf("transmit to %s\n", stoa(&(server->srcadr)));
717
753
        }
718
754
 
719
755
        /*
735
771
        register struct pkt *rpkt;
736
772
        register struct server *server;
737
773
        register s_fp di;
738
 
        l_fp t10, t23;
 
774
        l_fp t10, t23, tmp;
739
775
        l_fp org;
740
776
        l_fp rec;
741
777
        l_fp ci;
743
779
        int is_authentic;
744
780
 
745
781
        if (debug)
746
 
                printf("receive(%s)\n", ntoa(&rbufp->recv_srcadr));
 
782
                printf("receive(%s)\n", stoa(&rbufp->recv_srcadr));
747
783
        /*
748
784
         * Check to see if the packet basically looks like something
749
785
         * intended for us.
857
893
        L_SUB(&t23, &org);              /* pkt->org == t3 */
858
894
 
859
895
        /* now have (t2 - t3) and (t0 - t1).    Calculate (ci) and (di) */
 
896
        /*
 
897
         * Calculate (ci) = ((t1 - t0) / 2) + ((t2 - t3) / 2)
 
898
         * For large offsets this may prevent an overflow on '+'
 
899
         */
860
900
        ci = t10;
861
 
        L_ADD(&ci, &t23);
862
901
        L_RSHIFT(&ci);
 
902
        tmp = t23;
 
903
        L_RSHIFT(&tmp);
 
904
        L_ADD(&ci, &tmp);
863
905
 
864
906
        /*
865
907
         * Calculate di in t23 in full precision, then truncate
900
942
        u_fp e
901
943
        )
902
944
{
903
 
        register int i;
 
945
        u_short i;
904
946
 
905
947
        i = server->filter_nextpt;
906
948
        if (i < NTP_SHIFT) {
908
950
                server->filter_offset[i] = *c;
909
951
                server->filter_soffset[i] = LFPTOFP(c);
910
952
                server->filter_error[i] = e;
911
 
                server->filter_nextpt = i + 1;
 
953
                server->filter_nextpt = (u_short)(i + 1);
912
954
        }
913
955
}
914
956
 
1015
1057
         */
1016
1058
        nlist = 0;      /* none yet */
1017
1059
        for (server = sys_servers; server != NULL; server = server->next_server) {
1018
 
                if (server->delay == 0)
 
1060
                if (server->delay == 0) {
 
1061
                        if (debug)
 
1062
                                printf("%s: Server dropped: no data\n", ntoa(&server->srcadr));
1019
1063
                        continue;       /* no data */
1020
 
                if (server->stratum > NTP_INFIN)
 
1064
                }
 
1065
                if (server->stratum > NTP_INFIN) {
 
1066
                        if (debug)
 
1067
                                printf("%s: Server dropped: strata too high\n", ntoa(&server->srcadr));
1021
1068
                        continue;       /* stratum no good */
 
1069
                }
1022
1070
                if (server->delay > NTP_MAXWGT) {
 
1071
                        if (debug)
 
1072
                                printf("%s: Server dropped: server too far away\n", 
 
1073
                                        ntoa(&server->srcadr));
1023
1074
                        continue;       /* too far away */
1024
1075
                }
1025
 
                if (server->leap == LEAP_NOTINSYNC)
 
1076
                if (server->leap == LEAP_NOTINSYNC) {
 
1077
                        if (debug)
 
1078
                                printf("%s: Server dropped: Leap not in sync\n", ntoa(&server->srcadr));
1026
1079
                        continue;       /* he's in trouble */
 
1080
                }
1027
1081
                if (!L_ISHIS(&server->org, &server->reftime)) {
 
1082
                        if (debug)
 
1083
                                printf("%s: Server dropped: server is very broken\n", 
 
1084
                                       ntoa(&server->srcadr));
1028
1085
                        continue;       /* very broken host */
1029
1086
                }
1030
1087
                if ((server->org.l_ui - server->reftime.l_ui)
1031
 
                        >= NTP_MAXAGE) {
 
1088
                    >= NTP_MAXAGE) {
 
1089
                        if (debug)
 
1090
                                printf("%s: Server dropped: Server has gone too long without sync\n", 
 
1091
                                       ntoa(&server->srcadr));
1032
1092
                        continue;       /* too long without sync */
1033
1093
                }
1034
1094
                if (server->trust != 0) {
 
1095
                        if (debug)
 
1096
                                printf("%s: Server dropped: Server is untrusted\n",
 
1097
                                       ntoa(&server->srcadr));
1035
1098
                        continue;
1036
1099
                }
1037
1100
 
1176
1239
        }
1177
1240
 
1178
1241
        /*
1179
 
         * That's it.    Return our server.
 
1242
         * That's it.  Return our server.
1180
1243
         */
1181
1244
        return sys_server;
1182
1245
}
1216
1279
                absoffset = server->soffset;
1217
1280
                if (absoffset < 0)
1218
1281
                        absoffset = -absoffset;
1219
 
                dostep = (absoffset >= NTPDATE_THRESHOLD);
 
1282
                dostep = (absoffset >= NTPDATE_THRESHOLD || absoffset < 0);
1220
1283
        }
1221
1284
 
1222
1285
        if (dostep) {
1223
1286
                if (simple_query || l_step_systime(&server->offset)) {
1224
1287
                        msyslog(LOG_NOTICE, "step time server %s offset %s sec",
1225
 
                                ntoa(&server->srcadr),
 
1288
                                stoa(&server->srcadr),
1226
1289
                                lfptoa(&server->offset, 6));
1227
1290
                }
1228
1291
        } else {
1229
1292
#if !defined SYS_WINNT && !defined SYS_CYGWIN32
1230
1293
                if (simple_query || l_adj_systime(&server->offset)) {
1231
1294
                        msyslog(LOG_NOTICE, "adjust time server %s offset %s sec",
1232
 
                                ntoa(&server->srcadr),
 
1295
                                stoa(&server->srcadr),
1233
1296
                                lfptoa(&server->offset, 6));
1234
1297
                }
1235
1298
#else
1253
1316
/* XXX ELIMINATE: merge BIG slew into adj_systime in lib/systime.c */
1254
1317
/*
1255
1318
 * addserver - determine a server's address and allocate a new structure
1256
 
 *                 for it.
 
1319
 *              for it.
1257
1320
 */
1258
1321
static void
1259
1322
addserver(
1261
1324
        )
1262
1325
{
1263
1326
        register struct server *server;
1264
 
        u_int32 netnum;
1265
 
 
1266
 
        if (!getnetnum(serv, &netnum)) {
 
1327
        /* Address infos structure to store result of getaddrinfo */
 
1328
        struct addrinfo *addrResult;
 
1329
        /* Address infos structure to store hints for getaddrinfo */
 
1330
        struct addrinfo hints;
 
1331
        /* Error variable for getaddrinfo */
 
1332
        int error;
 
1333
        /* Service name */
 
1334
        char service[5];
 
1335
        strcpy(service, "ntp");
 
1336
 
 
1337
        /* Get host address. Looking for UDP datagram connection. */
 
1338
        memset(&hints, 0, sizeof(hints));
 
1339
        hints.ai_family = ai_fam_templ;
 
1340
        hints.ai_socktype = SOCK_DGRAM;
 
1341
 
 
1342
#ifdef DEBUG
 
1343
        if (debug)
 
1344
                printf("Looking for host %s and service %s\n", serv, service);
 
1345
#endif
 
1346
 
 
1347
        error = getaddrinfo(serv, service, &hints, &addrResult);
 
1348
        if (error != 0) {
 
1349
                fprintf(stderr, "Error : %s\n", gai_strerror(error));
1267
1350
                msyslog(LOG_ERR, "can't find host %s\n", serv);
1268
1351
                return;
1269
1352
        }
 
1353
#ifdef DEBUG
 
1354
        else if (debug) {
 
1355
                fprintf(stderr, "host found : %s\n", stohost((struct sockaddr_storage*)addrResult->ai_addr));
 
1356
        }
 
1357
#endif
1270
1358
 
1271
1359
        server = (struct server *)emalloc(sizeof(struct server));
1272
1360
        memset((char *)server, 0, sizeof(struct server));
1273
1361
 
1274
 
        server->srcadr.sin_family = AF_INET;
1275
 
        server->srcadr.sin_addr.s_addr = netnum;
1276
 
        server->srcadr.sin_port = htons(NTP_PORT);
1277
 
 
 
1362
        /* For now we only get the first returned server of the addrinfo list */
 
1363
        memset(&(server->srcadr), 0, sizeof(struct sockaddr_storage));
 
1364
        memcpy(&(server->srcadr), addrResult->ai_addr, addrResult->ai_addrlen);
1278
1365
        server->event_time = ++sys_numservers;
1279
1366
        if (sys_servers == NULL)
1280
1367
                sys_servers = server;
1290
1377
 
1291
1378
/*
1292
1379
 * findserver - find a server in the list given its address
 
1380
 * ***(For now it isn't totally AF-Independant, to check later..)
1293
1381
 */
1294
1382
static struct server *
1295
1383
findserver(
1296
 
        struct sockaddr_in *addr
 
1384
        struct sockaddr_storage *addr
1297
1385
        )
1298
1386
{
1299
 
        register u_int32 netnum;
1300
1387
        struct server *server;
1301
1388
        struct server *mc_server;
1302
1389
 
1303
1390
        mc_server = NULL;
1304
 
        if (htons(addr->sin_port) != NTP_PORT)
 
1391
        if (htons(((struct sockaddr_in*)addr)->sin_port) != NTP_PORT)
1305
1392
                return 0;
1306
 
        netnum = addr->sin_addr.s_addr;
1307
1393
 
1308
1394
        for (server = sys_servers; server != NULL; 
1309
1395
             server = server->next_server) {
1310
 
                register u_int32 servnum;
1311
1396
                
1312
 
                servnum = server->srcadr.sin_addr.s_addr;
1313
 
                if (netnum == servnum)
 
1397
                if (memcmp(addr, &server->srcadr, SOCKLEN(addr))==0)
1314
1398
                        return server;
1315
 
                if (IN_MULTICAST(ntohl(servnum)))
 
1399
                /* Multicast compatibility to verify here... I'm not sure it's working */
 
1400
                if(addr->ss_family == AF_INET) {
 
1401
                        if (IN_MULTICAST(ntohl(((struct sockaddr_in*)addr)->sin_addr.s_addr)))
 
1402
                                mc_server = server;
 
1403
                }
 
1404
                else {
 
1405
#ifdef AF_INET6
 
1406
                        if (IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)(&server->srcadr))->sin6_addr))
1316
1407
                        mc_server = server;
 
1408
#else
 
1409
                        return 0;
 
1410
#endif
 
1411
                }
1317
1412
        }
1318
1413
 
1319
1414
        if (mc_server != NULL) {        
 
1415
 
1320
1416
                struct server *sp;
1321
1417
 
1322
1418
                if (mc_server->event_time != 0) {
1323
1419
                        mc_server->event_time = 0;
1324
1420
                        complete_servers++;
1325
1421
                }
 
1422
 
1326
1423
                server = (struct server *)emalloc(sizeof(struct server));
1327
1424
                memset((char *)server, 0, sizeof(struct server));
1328
1425
 
1329
 
                server->srcadr.sin_family = AF_INET;
1330
 
                server->srcadr.sin_addr.s_addr = netnum;
1331
 
                server->srcadr.sin_port = htons(NTP_PORT);
 
1426
                memcpy(&server->srcadr, &addr, sizeof(struct sockaddr_storage));
1332
1427
 
1333
1428
                server->event_time = ++sys_numservers;
 
1429
 
1334
1430
                for (sp = sys_servers; sp->next_server != NULL;
1335
1431
                     sp = sp->next_server) ;
1336
1432
                sp->next_server = server;
1453
1549
        itimer.it_interval.tv_sec = itimer.it_value.tv_sec = 0;
1454
1550
        itimer.it_interval.tv_usec = 1000000/TIMER_HZ;
1455
1551
        itimer.it_value.tv_usec = 1000000/(TIMER_HZ<<1);
 
1552
 
1456
1553
        setitimer(ITIMER_REAL, &itimer, (struct itimerval *)0);
1457
1554
# endif
1458
1555
#if defined SYS_CYGWIN32
1467
1564
        }
1468
1565
        /* get the LUID for system-time privilege. */
1469
1566
        LookupPrivilegeValue(NULL, SE_SYSTEMTIME_NAME, &tkp.Privileges[0].Luid);
1470
 
        tkp.PrivilegeCount = 1;  /* one privilege to set */
 
1567
        tkp.PrivilegeCount = 1;         /* one privilege to set */
1471
1568
        tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
1472
1569
        /* get set-time privilege for this process. */
1473
1570
        AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,(PTOKEN_PRIVILEGES) NULL, 0);
1489
1586
        }
1490
1587
        /* get the LUID for system-time privilege. */
1491
1588
        LookupPrivilegeValue(NULL, SE_SYSTEMTIME_NAME, &tkp.Privileges[0].Luid);
1492
 
        tkp.PrivilegeCount = 1;  /* one privilege to set */
 
1589
        tkp.PrivilegeCount = 1;         /* one privilege to set */
1493
1590
        tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
1494
1591
        /* get set-time privilege for this process. */
1495
1592
        AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,(PTOKEN_PRIVILEGES) NULL, 0);
1515
1612
 
1516
1613
        /* start the timer event */
1517
1614
        wTimerID = timeSetEvent(
1518
 
                (UINT) (1000/TIMER_HZ),    /* Delay */
1519
 
                wTimerRes,                       /* Resolution */
1520
 
                (LPTIMECALLBACK) alarming, /* Callback function */
1521
 
                (DWORD) dwUser,          /* User data */
1522
 
                TIME_PERIODIC);          /* Event type (periodic) */
 
1615
                (UINT) (1000/TIMER_HZ),         /* Delay */
 
1616
                wTimerRes,                      /* Resolution */
 
1617
                (LPTIMECALLBACK) alarming,      /* Callback function */
 
1618
                (DWORD) dwUser,                 /* User data */
 
1619
                TIME_PERIODIC);                 /* Event type (periodic) */
1523
1620
        if (wTimerID == 0) {
1524
1621
                msyslog(LOG_ERR, "timeSetEvent failed: %m");
1525
1622
                exit(1);
1550
1647
static void
1551
1648
init_io(void)
1552
1649
{
 
1650
        struct addrinfo *res, *ressave;
 
1651
        struct addrinfo hints;
 
1652
        char service[5];
 
1653
        int optval = 1;
 
1654
 
1553
1655
        /*
1554
1656
         * Init buffer free list and stat counters
1555
1657
         */
1556
1658
        init_recvbuff(sys_numservers + 2);
 
1659
 
1557
1660
        /*
1558
1661
         * Open the socket
1559
1662
         */
1560
1663
 
 
1664
        strcpy(service, "ntp");
 
1665
 
 
1666
        /*
 
1667
         * Init hints addrinfo structure
 
1668
         */
 
1669
        memset(&hints, 0, sizeof(hints));
 
1670
        hints.ai_flags = AI_PASSIVE;
 
1671
        hints.ai_socktype = SOCK_DGRAM;
 
1672
 
 
1673
        if(getaddrinfo(NULL, service, &hints, &res) != 0) {
 
1674
               msyslog(LOG_ERR, "getaddrinfo() failed: %m");
 
1675
               exit(1);
 
1676
               /*NOTREACHED*/
 
1677
        }
 
1678
 
 
1679
        /* Remember the address of the addrinfo structure chain */
 
1680
        ressave = res;
 
1681
 
 
1682
        /*
 
1683
         * For each structure returned, open and bind socket
 
1684
         */
 
1685
        for(nbsock = 0; (nbsock < MAX_AF) && res ; res = res->ai_next) {
1561
1686
        /* create a datagram (UDP) socket */
1562
 
        if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
1563
 
                msyslog(LOG_ERR, "socket() failed: %m");
 
1687
           if ((fd[nbsock] = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) < 0) {
 
1688
                if (errno == EPROTONOSUPPORT || errno == EAFNOSUPPORT ||
 
1689
                    errno == EPFNOSUPPORT)
 
1690
                        continue;
 
1691
                netsyslog(LOG_ERR, "socket() failed: %m");
1564
1692
                exit(1);
1565
1693
                /*NOTREACHED*/
1566
 
        }
 
1694
           }
 
1695
           /* set socket to reuse address */
 
1696
           if (setsockopt(fd[nbsock], SOL_SOCKET, SO_REUSEADDR, (void*) &optval, sizeof(optval)) < 0) {
 
1697
                   netsyslog(LOG_ERR, "setsockopt() SO_REUSEADDR failed: %m");
 
1698
                   exit(1);
 
1699
                   /*NOTREACHED*/
 
1700
           }
 
1701
#ifdef IPV6_V6ONLY
 
1702
           /* Restricts AF_INET6 socket to IPv6 communications (see RFC 2553bis-03) */
 
1703
           if (res->ai_family == AF_INET6)
 
1704
                if (setsockopt(fd[nbsock], IPPROTO_IPV6, IPV6_V6ONLY, (void*) &optval, sizeof(optval)) < 0) {
 
1705
                           netsyslog(LOG_ERR, "setsockopt() IPV6_V6ONLY failed: %m");
 
1706
                           exit(1);
 
1707
                           /*NOTREACHED*/
 
1708
                }
 
1709
#endif
 
1710
 
 
1711
           /* Remember the socket family in fd_family structure */
 
1712
           fd_family[nbsock] = res->ai_family;
1567
1713
 
1568
1714
        /*
1569
1715
         * bind the socket to the NTP port
1570
1716
         */
1571
 
        if (!debug && !simple_query && !unpriv_port) {
1572
 
                struct sockaddr_in addr;
1573
 
 
1574
 
                memset((char *)&addr, 0, sizeof addr);
1575
 
                addr.sin_family = AF_INET;
1576
 
                addr.sin_port = htons(NTP_PORT);
1577
 
                addr.sin_addr.s_addr = htonl(INADDR_ANY);
1578
 
                if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 
1717
        if (!simple_query && !unpriv_port) {
 
1718
                if (bind(fd[nbsock], res->ai_addr, SOCKLEN(res->ai_addr)) < 0) {
1579
1719
#ifndef SYS_WINNT
1580
1720
                        if (errno == EADDRINUSE)
1581
1721
#else
1582
1722
                                if (WSAGetLastError() == WSAEADDRINUSE)
1583
1723
#endif /* SYS_WINNT */
1584
 
                                msyslog(LOG_ERR,
 
1724
                                netsyslog(LOG_ERR,
1585
1725
                                        "the NTP socket is in use, exiting");
1586
1726
                                else
1587
 
                                msyslog(LOG_ERR, "bind() fails: %m");
 
1727
                                netsyslog(LOG_ERR, "bind() fails: %m");
1588
1728
                        exit(1);
1589
1729
                }
1590
1730
        }
1591
1731
 
1592
1732
#ifdef HAVE_POLL_H
1593
 
        fdmask.fd = fd;
1594
 
        fdmask.events = POLLIN;
 
1733
            fdmask[nbsock].fd = fd[nbsock];
 
1734
            fdmask[nbsock].events = POLLIN;
1595
1735
#else
1596
 
        FD_ZERO(&fdmask);
1597
 
        FD_SET(fd, &fdmask);
 
1736
            FD_SET(fd[nbsock], &fdmask);
 
1737
            if ((SOCKET) maxfd < fd[nbsock]+1) {
 
1738
                maxfd = fd[nbsock]+1;
 
1739
            }
1598
1740
#endif
1599
1741
 
1600
1742
        /*
1605
1747
  {
1606
1748
        int on = TRUE;
1607
1749
 
1608
 
        if (ioctl(fd,FIONBIO, &on) == ERROR) {
1609
 
          msyslog(LOG_ERR, "ioctl(FIONBIO) fails: %m");
 
1750
        if (ioctl(fd[nbsock],FIONBIO, &on) == ERROR) {
 
1751
          netsyslog(LOG_ERR, "ioctl(FIONBIO) fails: %m");
1610
1752
          exit(1);
1611
1753
        }
1612
1754
  }
1613
1755
# else /* not SYS_VXWORKS */
1614
1756
#  if defined(O_NONBLOCK)
1615
 
        if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
1616
 
                msyslog(LOG_ERR, "fcntl(FNDELAY|FASYNC) fails: %m");
 
1757
           if (fcntl(fd[nbsock], F_SETFL, O_NONBLOCK) < 0) {
 
1758
                netsyslog(LOG_ERR, "fcntl(FNDELAY|FASYNC) fails: %m");
1617
1759
                exit(1);
1618
1760
                /*NOTREACHED*/
1619
1761
        }
1620
1762
#  else /* not O_NONBLOCK */
1621
1763
#       if defined(FNDELAY)
1622
 
        if (fcntl(fd, F_SETFL, FNDELAY) < 0) {
1623
 
                msyslog(LOG_ERR, "fcntl(FNDELAY|FASYNC) fails: %m");
 
1764
           if (fcntl(fd[nbsock], F_SETFL, FNDELAY) < 0) {
 
1765
                netsyslog(LOG_ERR, "fcntl(FNDELAY|FASYNC) fails: %m");
1624
1766
                exit(1);
1625
1767
                /*NOTREACHED*/
1626
1768
        }
1630
1772
#  endif /* not O_NONBLOCK */
1631
1773
# endif /* SYS_VXWORKS */
1632
1774
#else /* SYS_WINNT */
1633
 
        if (ioctlsocket(fd, FIONBIO, (u_long *) &on) == SOCKET_ERROR) {
1634
 
                msyslog(LOG_ERR, "ioctlsocket(FIONBIO) fails: %m");
 
1775
        if (ioctlsocket(fd[nbsock], FIONBIO, (u_long *) &on) == SOCKET_ERROR) {
 
1776
                netsyslog(LOG_ERR, "ioctlsocket(FIONBIO) fails: %m");
1635
1777
                exit(1);
1636
1778
        }
1637
1779
#endif /* SYS_WINNT */
 
1780
        nbsock++;
 
1781
    }
 
1782
    freeaddrinfo(ressave);
1638
1783
}
1639
1784
 
1640
 
 
1641
1785
/*
1642
1786
 * sendpkt - send a packet to the specified destination
1643
1787
 */
1644
1788
static void
1645
1789
sendpkt(
1646
 
        struct sockaddr_in *dest,
 
1790
        struct sockaddr_storage *dest,
1647
1791
        struct pkt *pkt,
1648
1792
        int len
1649
1793
        )
1650
1794
{
 
1795
        int i;
1651
1796
        int cc;
 
1797
        SOCKET sock = 0;
1652
1798
 
1653
1799
#ifdef SYS_WINNT
1654
1800
        DWORD err;
1655
1801
#endif /* SYS_WINNT */
1656
1802
 
1657
 
        cc = sendto(fd, (char *)pkt, (size_t)len, 0, (struct sockaddr *)dest,
1658
 
                        sizeof(struct sockaddr_in));
 
1803
        /* Find a local family compatible socket to send ntp packet to ntp server */
 
1804
        for(i = 0; (i < MAX_AF); i++) {
 
1805
                if(dest->ss_family == fd_family[i]) {
 
1806
                        sock = fd[i];
 
1807
                break;
 
1808
                }
 
1809
        }
 
1810
 
 
1811
        if ( sock == 0 ) {
 
1812
                netsyslog(LOG_ERR, "cannot find family compatible socket to send ntp packet");
 
1813
                exit(1);
 
1814
                /*NOTREACHED*/
 
1815
        }
 
1816
 
 
1817
        cc = sendto(sock, (char *)pkt, len, 0, (struct sockaddr *)dest,
 
1818
                        SOCKLEN(dest));
 
1819
 
1659
1820
#ifndef SYS_WINNT
1660
1821
        if (cc == -1) {
1661
1822
                if (errno != EWOULDBLOCK && errno != ENOBUFS)
1664
1825
                err = WSAGetLastError();
1665
1826
                if (err != WSAEWOULDBLOCK && err != WSAENOBUFS)
1666
1827
#endif /* SYS_WINNT */
1667
 
                        msyslog(LOG_ERR, "sendto(%s): %m", ntoa(dest));
 
1828
                        netsyslog(LOG_ERR, "sendto(%s): %m", stohost(dest));
1668
1829
        }
1669
1830
}
1670
1831
 
1680
1841
        struct timeval tvzero;
1681
1842
        int fromlen;
1682
1843
        l_fp ts;
 
1844
        int i;
1683
1845
#ifdef HAVE_POLL_H
1684
 
        struct pollfd fds;
 
1846
        struct pollfd fds[MAX_AF];
1685
1847
#else
1686
1848
        fd_set fds;
1687
1849
#endif
 
1850
        int fdc = 0;
1688
1851
 
1689
1852
        /*
1690
1853
         * Do a poll to see if we have data
1691
1854
         */
1692
1855
        for (;;) {
 
1856
                tvzero.tv_sec = tvzero.tv_usec = 0;
 
1857
#ifdef HAVE_POLL_H
 
1858
                memcpy(fds, fdmask, sizeof(fdmask));
 
1859
                n = poll(fds, (unsigned int)nbsock, tvzero.tv_sec * 1000);
 
1860
 
 
1861
                /*
 
1862
                 * Determine which socket received data
 
1863
                 */
 
1864
 
 
1865
                for(i=0; i < nbsock; i++) {
 
1866
                        if(fds[i].revents & POLLIN) {
 
1867
                                fdc = fd[i];
 
1868
                                break;
 
1869
                        }
 
1870
                }
 
1871
 
 
1872
#else
1693
1873
                fds = fdmask;
1694
 
                tvzero.tv_sec = tvzero.tv_usec = 0;
1695
 
#ifdef HAVE_POLL_H
1696
 
                n = poll(&fds, 1, tvzero.tv_sec * 1000);
1697
 
#else
1698
 
                n = select(fd+1, &fds, (fd_set *)0, (fd_set *)0, &tvzero);
 
1874
                n = select(maxfd, &fds, (fd_set *)0, (fd_set *)0, &tvzero);
 
1875
 
 
1876
                /*
 
1877
                 * Determine which socket received data
 
1878
                 */
 
1879
 
 
1880
                for(i=0; i < maxfd; i++) {
 
1881
                        if(FD_ISSET(fd[i], &fds)) {
 
1882
                                 fdc = fd[i];
 
1883
                                 break;
 
1884
                        }
 
1885
                }
 
1886
 
1699
1887
#endif
1700
1888
 
1701
1889
                /*
1707
1895
                        return;
1708
1896
                else if (n == -1) {
1709
1897
                        if (errno != EINTR)
1710
 
                                msyslog(LOG_ERR,
 
1898
                                netsyslog(LOG_ERR,
1711
1899
#ifdef HAVE_POLL_H
1712
1900
                                        "poll() error: %m"
1713
1901
#else
1726
1914
                if (initializing || free_recvbuffs() == 0) {
1727
1915
                        char buf[100];
1728
1916
 
 
1917
 
1729
1918
#ifndef SYS_WINNT
1730
 
                        (void) read(fd, buf, sizeof buf);
 
1919
                        (void) read(fdc, buf, sizeof buf);
1731
1920
#else
1732
1921
                        /* NT's _read does not operate on nonblocking sockets
1733
1922
                         * either recvfrom or ReadFile() has to be used here.
1734
1923
                         * ReadFile is used in [ntpd]ntp_intres() and ntpdc,
1735
1924
                         * just to be different use recvfrom() here
1736
1925
                         */
1737
 
                        recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *)0, NULL);
 
1926
                        recvfrom(fdc, buf, sizeof(buf), 0, (struct sockaddr *)0, NULL);
1738
1927
#endif /* SYS_WINNT */
1739
1928
                        continue;
1740
1929
                }
1741
1930
 
1742
1931
                rb = get_free_recv_buffer();
1743
1932
 
1744
 
                fromlen = sizeof(struct sockaddr_in);
1745
 
                rb->recv_length = recvfrom(fd, (char *)&rb->recv_pkt,
 
1933
                fromlen = sizeof(struct sockaddr_storage);
 
1934
                rb->recv_length = recvfrom(fdc, (char *)&rb->recv_pkt,
1746
1935
                   sizeof(rb->recv_pkt), 0,
1747
1936
                   (struct sockaddr *)&rb->recv_srcadr, &fromlen);
1748
1937
                if (rb->recv_length == -1) {
1805
1994
                adjtv.tv_usec = -adjtv.tv_usec;
1806
1995
        }
1807
1996
 
1808
 
        if (adjtv.tv_usec != 0 && !debug) {
 
1997
        if (adjtv.tv_usec != 0) {
1809
1998
                if (adjtime(&adjtv, &oadjtv) < 0) {
1810
1999
                        msyslog(LOG_ERR, "Can't adjust the time of day: %m");
1811
2000
                        return 0;
1832
2021
        int isneg;
1833
2022
        int n;
1834
2023
 
1835
 
        if (debug) return 1;
1836
2024
        /*
1837
2025
         * Take the absolute value of the offset
1838
2026
         */
1859
2047
         * line.
1860
2048
         */
1861
2049
#endif
1862
 
        if (debug)
1863
 
                return 1;
1864
2050
#ifdef FORCE_NTPDATE_STEP
1865
2051
        LFPTOD(ts, dtemp);
1866
2052
        return step_systime(dtemp);
1868
2054
        l_adj_systime(ts);
1869
2055
        return 1;
1870
2056
#endif
1871
 
#else /* SLEWALWAYS  */
1872
 
        if (debug)
1873
 
                return 1;
 
2057
#else /* SLEWALWAYS */
1874
2058
        LFPTOD(ts, dtemp);
1875
2059
        return step_systime(dtemp);
1876
2060
#endif  /* SLEWALWAYS */
1877
2061
}
1878
2062
 
1879
 
/*
1880
 
 * getnetnum - given a host name, return its net number
1881
 
 */
1882
 
static int
1883
 
getnetnum(
1884
 
        const char *host,
1885
 
        u_int32 *num
1886
 
        )
1887
 
{
1888
 
        struct hostent *hp;
1889
 
 
1890
 
        if (decodenetnum(host, num)) {
1891
 
                return 1;
1892
 
        } else if ((hp = gethostbyname(host)) != 0) {
1893
 
                memmove((char *)num, hp->h_addr, sizeof(u_int32));
1894
 
                return (1);
1895
 
        }
1896
 
        return (0);
1897
 
}
1898
2063
 
1899
2064
/* XXX ELIMINATE printserver similar in ntptrace.c, ntpdate.c */
1900
2065
/*
1912
2077
 
1913
2078
        if (!debug) {
1914
2079
                (void) fprintf(fp, "server %s, stratum %d, offset %s, delay %s\n",
1915
 
                                   ntoa(&pp->srcadr), pp->stratum,
 
2080
                                   stoa(&pp->srcadr), pp->stratum,
1916
2081
                                   lfptoa(&pp->offset, 6), fptoa((s_fp)pp->delay, 5));
1917
2082
                return;
1918
2083
        }
1919
2084
 
1920
2085
        (void) fprintf(fp, "server %s, port %d\n",
1921
 
                           ntoa(&pp->srcadr), ntohs(pp->srcadr.sin_port));
 
2086
                           stoa(&pp->srcadr), ntohs(((struct sockaddr_in*)&(pp->srcadr))->sin_port));
1922
2087
 
1923
2088
        (void) fprintf(fp, "stratum %d, precision %d, leap %c%c, trust %03o\n",
1924
2089
                           pp->stratum, pp->precision,
1931
2096
                memmove(junk, (char *)&pp->refid, 4);
1932
2097
                str = junk;
1933
2098
        } else {
1934
 
                str = numtoa(pp->refid);
 
2099
                str = stoa(&pp->srcadr);
1935
2100
        }
1936
2101
        (void) fprintf(fp,
1937
2102
                           "refid [%s], delay %s, dispersion %s\n",