← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ntpd/ntp_config.c

  • Committer: Bazaar Package Importer
  • Author(s): Kurt Roeckx
  • Date: 2009-01-05 21:10:03 UTC
  • mfrom: (1.2.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20090105211003-mh6zc3um4k1uhsj7
Tags: 1:4.2.4p4+dfsg-8
It did not properly check the return value of EVP_VerifyFinal
which results in an malformed DSA signature being treated as
a good signature rather than as an error.  (CVE-2009-0021)

Show diffs side-by-side

added added

removed removed

Lines of Context:
ntpd/ntp_config.c
15
15
#include "ntp_refclock.h"
16
16
#include "ntp_filegen.h"
17
17
#include "ntp_stdlib.h"
18
 
#include "ntp_config.h"
19
 
#include "ntp_cmdargs.h"
 
18
#include <ntp_random.h>
 
19
#include <isc/net.h>
 
20
#include <isc/result.h>
20
21
 
21
22
#include <stdio.h>
22
23
#include <ctype.h>
35
36
 
36
37
#ifdef SYS_WINNT
37
38
# include <io.h>
38
 
extern HANDLE ResolverThreadHandle;
 
39
HANDLE ResolverThreadHandle = NULL;
39
40
#endif /* SYS_WINNT */
40
41
 
41
 
#include <netdb.h>
 
42
/*
 
43
 * [Bug 467]: Some linux headers collide with CONFIG_PHONE and CONFIG_KEYS
 
44
 * so #include these later.
 
45
 */
 
46
 
 
47
#include "ntp_config.h"
 
48
#include "ntp_cmdargs.h"
42
49
 
43
50
extern int priority_done;
44
51
 
73
80
        { "disable",            CONFIG_DISABLE },
74
81
        { "driftfile",          CONFIG_DRIFTFILE },
75
82
        { "enable",             CONFIG_ENABLE },
 
83
        { "end",                CONFIG_END },
76
84
        { "filegen",            CONFIG_FILEGEN },
77
85
        { "fudge",              CONFIG_FUDGE },
78
86
        { "includefile",        CONFIG_INCLUDEFILE },
115
123
        { "minpoll",            CONF_MOD_MINPOLL },
116
124
        { "mode",               CONF_MOD_MODE },    /* refclocks */
117
125
        { "noselect",           CONF_MOD_NOSELECT },
 
126
        { "preempt",            CONF_MOD_PREEMPT },
 
127
        { "true",               CONF_MOD_TRUE },
118
128
        { "prefer",             CONF_MOD_PREFER },
119
129
        { "ttl",                CONF_MOD_TTL },     /* NTP peers */
120
130
        { "version",            CONF_MOD_VERSION },
 
131
        { "dynamic",            CONF_MOD_DYNAMIC },
121
132
        { "",                   CONFIG_UNKNOWN }
122
133
};
123
134
 
158
169
        { "flag2",              CONF_FDG_FLAG2 },
159
170
        { "flag3",              CONF_FDG_FLAG3 },
160
171
        { "flag4",              CONF_FDG_FLAG4 },
161
 
        { "refid",              CONF_FDG_REFID },
 
172
        { "refid",              CONF_FDG_REFID }, /* this mapping should be cleaned up (endianness, \0) - kd 20041031 */
162
173
        { "stratum",            CONF_FDG_STRATUM },
163
174
        { "time1",              CONF_FDG_TIME1 },
164
175
        { "time2",              CONF_FDG_TIME2 },
202
213
        { "kernel",             PROTO_KERNEL },
203
214
        { "monitor",            PROTO_MONITOR },
204
215
        { "ntp",                PROTO_NTP },
205
 
        { "pps",                PROTO_PPS },
206
216
        { "stats",              PROTO_FILEGEN },
207
217
        { "",                   CONFIG_UNKNOWN }
208
218
};
236
246
 */
237
247
static struct keyword tos_keywords[] = {
238
248
        { "minclock",           CONF_TOS_MINCLOCK },
 
249
        { "maxclock",           CONF_TOS_MAXCLOCK },
239
250
        { "minsane",            CONF_TOS_MINSANE },
240
251
        { "floor",              CONF_TOS_FLOOR },
241
252
        { "ceiling",            CONF_TOS_CEILING },
242
253
        { "cohort",             CONF_TOS_COHORT },
 
254
        { "mindist",            CONF_TOS_MINDISP },
 
255
        { "maxdist",            CONF_TOS_MAXDIST },
 
256
        { "maxhop",             CONF_TOS_MAXHOP },
 
257
        { "beacon",             CONF_TOS_BEACON },
 
258
        { "orphan",             CONF_TOS_ORPHAN },
243
259
        { "",                   CONFIG_UNKNOWN }
244
260
};
245
261
 
251
267
        { "cert",               CONF_CRYPTO_CERT },
252
268
        { "gqpar",              CONF_CRYPTO_GQPAR },
253
269
        { "host",               CONF_CRYPTO_RSA },
 
270
        { "ident",              CONF_CRYPTO_IDENT },
254
271
        { "iffpar",             CONF_CRYPTO_IFFPAR },
255
272
        { "leap",               CONF_CRYPTO_LEAP },
256
273
        { "mvpar",              CONF_CRYPTO_MVPAR },
309
326
 */
310
327
#define MAXTOKENS       20      /* 20 tokens on line */
311
328
#define MAXLINE         1024    /* maximum length of line */
312
 
#define MAXPHONE        5       /* maximum number of phone strings */
 
329
#define MAXPHONE        10      /* maximum number of phone strings */
313
330
#define MAXPPS          20      /* maximum length of PPS device string */
314
331
#define MAXINCLUDELEVEL 5       /* maximum include file levels */
315
332
 
339
356
/*
340
357
 * Definitions of things either imported from or exported to outside
341
358
 */
342
 
char const *progname;
343
 
char    sys_phone[MAXPHONE][MAXDIAL]; /* ACTS phone numbers */
 
359
 
 
360
short default_ai_family = AF_UNSPEC;    /* Default either IPv4 or IPv6 */
 
361
char    *sys_phone[MAXPHONE] = {NULL}; /* ACTS phone numbers */
344
362
char    *keysdir = NTP_KEYSDIR; /* crypto keys directory */
345
 
char    pps_device[MAXPPS + 1]; /* PPS device name */
346
363
#if defined(HAVE_SCHED_SETSCHEDULER)
347
364
int     config_priority_override = 0;
348
365
int     config_priority;
386
403
#endif
387
404
static  int gettokens P((FILE *, char *, char **, int *));
388
405
static  int matchkey P((char *, struct keyword *, int));
389
 
static  int getnetnum P((const char *, struct sockaddr_storage *, int));
 
406
enum gnn_type {
 
407
        t_UNK,          /* Unknown */
 
408
        t_REF,          /* Refclock */
 
409
        t_MSK           /* Network Mask */
 
410
        };
 
411
static  int getnetnum P((const char *, struct sockaddr_storage *, int,
 
412
                         enum gnn_type));
390
413
static  void save_resolve P((char *, int, int, int, int, u_int, int,
391
414
    keyid_t, u_char *));
392
415
static  void do_resolve_internal P((void));
472
495
        register int i;
473
496
        int c;
474
497
        int errflg;
 
498
        int status;
475
499
        int istart;
476
500
        int peerversion;
477
501
        int minpoll;
501
525
         * Initialize, initialize
502
526
         */
503
527
        errflg = 0;
504
 
        /* HMS: don't initialize debug to 0 here! */
 
528
        
505
529
#ifndef SYS_WINNT
506
530
        config_file = CONFIG_FILE;
507
531
#else
520
544
        alt_config_file = alt_config_file_storage;
521
545
 
522
546
#endif /* SYS_WINNT */
523
 
        progname = argv[0];
524
547
        res_fp = NULL;
525
 
        memset((char *)sys_phone, 0, sizeof(sys_phone));
526
548
        ntp_syslogmask = NLOG_SYNCMASK; /* set more via logconfig */
527
549
 
528
550
        /*
573
595
        }
574
596
 
575
597
        for (;;) {
 
598
                if (tok == CONFIG_END) 
 
599
                        break;
576
600
                if (fp[includelevel])
577
601
                        tok = gettokens(fp[includelevel], line, tokens, &ntokens);
578
602
#ifdef HAVE_NETINFO
612
636
 
613
637
                        istart = 1;
614
638
                        memset((char *)&peeraddr, 0, sizeof(peeraddr));
 
639
                        peeraddr.ss_family = default_ai_family;
615
640
                        switch (matchkey(tokens[istart], addr_type, 0)) {
616
641
                        case CONF_ADDR_IPV4:
617
642
                                peeraddr.ss_family = AF_INET;
623
648
                                break;
624
649
                        }
625
650
 
626
 
                        if (!getnetnum(tokens[istart], &peeraddr, 0)) {
 
651
                        status = getnetnum(tokens[istart], &peeraddr, 0, t_UNK);
 
652
                        if (status == -1)
 
653
                                break;          /* Found IPv6 address */
 
654
                        if(status != 1) {
627
655
                                errflg = -1;
628
656
                        } else {
629
657
                                errflg = 0;
684
712
                                        }
685
713
                                }
686
714
                        }
687
 
                        
 
715
                        if (peeraddr.ss_family == AF_INET6 &&
 
716
                            isc_net_probeipv6() != ISC_R_SUCCESS)
 
717
                                break;
 
718
 
688
719
                        peerversion = NTP_VERSION;
689
720
                        minpoll = NTP_MINDPOLL;
690
721
                        maxpoll = NTP_MAXDPOLL;
760
791
                                    peerflags |= FLAG_PREFER;
761
792
                                    break;
762
793
 
 
794
                                case CONF_MOD_PREEMPT:
 
795
                                    peerflags |= FLAG_PREEMPT;
 
796
                                    break;
 
797
 
763
798
                                case CONF_MOD_NOSELECT:
764
799
                                    peerflags |= FLAG_NOSELECT;
765
800
                                    break;
766
801
 
 
802
                                case CONF_MOD_TRUE:
 
803
                                    peerflags |= FLAG_TRUE;
 
804
 
767
805
                                case CONF_MOD_BURST:
768
806
                                    peerflags |= FLAG_BURST;
769
807
                                    break;
771
809
                                case CONF_MOD_IBURST:
772
810
                                    peerflags |= FLAG_IBURST;
773
811
                                    break;
 
812
 
 
813
                                case CONF_MOD_DYNAMIC:
 
814
                                    peerflags |= FLAG_DYNAMIC;
 
815
                                    break;
 
816
 
774
817
#ifdef OPENSSL
775
818
                                case CONF_MOD_SKEY:
776
819
                                    peerflags |= FLAG_SKEY |
821
864
                                                "configuration of %s failed",
822
865
                                                stoa(&peeraddr));
823
866
                            }
824
 
                            if (tok == CONFIG_MANYCASTCLIENT)
825
 
                                proto_config(PROTO_MULTICAST_ADD,
826
 
                                    0, 0., &peeraddr);
827
 
        
828
867
                        } else if (errflg == -1) {
829
868
                                save_resolve(tokens[1], hmode, peerversion,
830
869
                                    minpoll, maxpoll, peerflags, ttl,
837
876
                            stats_config(STATS_FREQ_FILE, tokens[1]);
838
877
                        else
839
878
                            stats_config(STATS_FREQ_FILE, (char *)0);
 
879
                        stats_write_period = stats_write_tolerance = 0;
 
880
                        if (ntokens >= 3)
 
881
                             stats_write_period = 60 * atol(tokens[2]);
 
882
                        if (stats_write_period <= 0)
 
883
                             stats_write_period = 3600;
 
884
                        if (ntokens >= 4) {
 
885
                             double ftemp;
 
886
                             sscanf(tokens[3], "%lf", &ftemp);
 
887
                             stats_write_tolerance = ftemp / 100;
 
888
                        }
840
889
                        break;
841
890
        
842
891
                    case CONFIG_PIDFILE:
846
895
                            stats_config(STATS_PID_FILE, (char *)0);
847
896
                        break;
848
897
 
 
898
                    case CONFIG_END:
 
899
                        for ( i = 0; i <= includelevel; i++ ) {
 
900
                                fclose(fp[i]);
 
901
                        }
 
902
                        break;
 
903
                        
849
904
                    case CONFIG_INCLUDEFILE:
850
905
                        if (ntokens < 2) {
851
906
                            msyslog(LOG_ERR, "includefile needs one argument");
937
992
                        if (ntokens > 1) {
938
993
                                istart = 1;
939
994
                                memset((char *)&peeraddr, 0, sizeof(peeraddr));
 
995
                                peeraddr.ss_family = default_ai_family;
940
996
                                switch (matchkey(tokens[istart],
941
997
                                    addr_type, 0)) {
942
998
                                case CONF_ADDR_IPV4:
959
1015
                                        memset((char *)&peeraddr, 0,
960
1016
                                            sizeof(peeraddr));
961
1017
                                        peeraddr.ss_family = maskaddr.ss_family;
962
 
                                        if (getnetnum(tokens[i], &peeraddr, 1))
 
1018
                                        if (getnetnum(tokens[i], &peeraddr, 1,
 
1019
                                                      t_UNK)  == 1)
963
1020
                                            proto_config(PROTO_MULTICAST_ADD,
964
1021
                                                         0, 0., &peeraddr);
965
1022
                                }
967
1024
                            proto_config(PROTO_MULTICAST_ADD,
968
1025
                                         0, 0., NULL);
969
1026
                        if (tok == CONFIG_MULTICASTCLIENT)
970
 
                                sys_bclient = 1;
 
1027
                                proto_config(PROTO_MULTICAST_ADD, 1, 0., NULL);
971
1028
                        else if (tok == CONFIG_MANYCASTSERVER)
972
1029
                                sys_manycastserver = 1;
973
1030
                        break;
984
1041
                                "Keys directory name required");
985
1042
                            break;
986
1043
                        }
987
 
                        keysdir = emalloc(strlen(tokens[1]) + 1);
 
1044
                        keysdir = (char *)emalloc(strlen(tokens[1]) + 1);
988
1045
                        strcpy(keysdir, tokens[1]);
989
1046
                        break;
990
1047
 
1042
1099
                            temp = matchkey(tokens[i++], tos_keywords, 1);
1043
1100
                            if (i > ntokens - 1) {
1044
1101
                                msyslog(LOG_ERR,
1045
 
                                    "tinker: missing argument");
 
1102
                                    "tos: missing argument");
1046
1103
                                errflg++;
1047
1104
                                break;
1048
1105
                            }
1053
1110
                                proto_config(PROTO_MINCLOCK, 0, ftemp, NULL);
1054
1111
                                break;
1055
1112
 
 
1113
                            case CONF_TOS_MAXCLOCK:
 
1114
                                proto_config(PROTO_MAXCLOCK, 0, ftemp, NULL);
 
1115
                                break;
 
1116
 
1056
1117
                            case CONF_TOS_MINSANE:
1057
1118
                                proto_config(PROTO_MINSANE, 0, ftemp, NULL);
1058
1119
                                break;
1068
1129
                            case CONF_TOS_COHORT:
1069
1130
                                proto_config(PROTO_COHORT, 0, ftemp, NULL);
1070
1131
                                break;
 
1132
 
 
1133
                            case CONF_TOS_MINDISP:
 
1134
                                proto_config(PROTO_MINDISP, 0, ftemp, NULL);
 
1135
                                break;
 
1136
 
 
1137
                            case CONF_TOS_MAXDIST:
 
1138
                                proto_config(PROTO_MAXDIST, 0, ftemp, NULL);
 
1139
                                break;
 
1140
 
 
1141
                            case CONF_TOS_MAXHOP:
 
1142
                                proto_config(PROTO_MAXHOP, 0, ftemp, NULL);
 
1143
                                break;
 
1144
 
 
1145
                            case CONF_TOS_ORPHAN:
 
1146
                                proto_config(PROTO_ORPHAN, 0, ftemp, NULL);
 
1147
                                break;
 
1148
 
 
1149
                            case CONF_TOS_BEACON:
 
1150
                                proto_config(PROTO_BEACON, 0, ftemp, NULL);
 
1151
                                break;
1071
1152
                            }
1072
1153
                        }
1073
1154
                        break;
1151
1232
                                    tokens[i]);
1152
1233
                                break;
1153
1234
 
 
1235
                            case CONF_CRYPTO_IDENT:
 
1236
                                crypto_config(CRYPTO_CONF_IDENT,
 
1237
                                    tokens[i]);
 
1238
                                break;
 
1239
 
1154
1240
                            case CONF_CRYPTO_IFFPAR:
1155
1241
                                crypto_config(CRYPTO_CONF_IFFPAR,
1156
1242
                                    tokens[i]);
1202
1288
                        }
1203
1289
                        istart = 1;
1204
1290
                        memset((char *)&peeraddr, 0, sizeof(peeraddr));
 
1291
                        peeraddr.ss_family = default_ai_family;
1205
1292
                        switch (matchkey(tokens[istart], addr_type, 0)) {
1206
1293
                        case CONF_ADDR_IPV4:
1207
1294
                                peeraddr.ss_family = AF_INET;
1220
1307
                        if (STREQ(tokens[istart], "default")) {
1221
1308
                                if (peeraddr.ss_family == 0)
1222
1309
                                        peeraddr.ss_family = AF_INET;
1223
 
                        } else if (!getnetnum(tokens[istart], &peeraddr, 1))
 
1310
                        } else if (getnetnum(tokens[istart], &peeraddr, 1,
 
1311
                                              t_UNK) != 1)
1224
1312
                                break;
1225
1313
 
1226
1314
                        /*
1241
1329
                                                break;
1242
1330
                                        }
1243
1331
                                        i++;
1244
 
                                        if (!getnetnum(tokens[i], &maskaddr, 1))
 
1332
                                        if (getnetnum(tokens[i], &maskaddr, 1,
 
1333
                                                       t_MSK) != 1)
1245
1334
                                            errflg++;
1246
1335
                                        break;
1247
1336
 
1390
1479
                        }
1391
1480
                        istart = 1;
1392
1481
                        memset((char *)&peeraddr, 0, sizeof(peeraddr));
 
1482
                        peeraddr.ss_family = default_ai_family;
1393
1483
                        switch (matchkey(tokens[istart], addr_type, 0)) {
1394
1484
                        case CONF_ADDR_IPV4:
1395
1485
                                peeraddr.ss_family = AF_INET;
1401
1491
                                break;
1402
1492
                        }
1403
1493
 
1404
 
                        if (!getnetnum(tokens[istart], &peeraddr, 1))
 
1494
                        if (getnetnum(tokens[istart], &peeraddr, 1, t_UNK) != 1)
1405
1495
                            break;
1406
1496
 
1407
1497
                        /*
1441
1531
                                    memset((char *)&maskaddr, 0,
1442
1532
                                        sizeof(maskaddr));
1443
1533
                                    maskaddr.ss_family = peeraddr.ss_family;
1444
 
                                    if (!getnetnum(tokens[++i],
1445
 
                                                   &maskaddr, 1)) {
 
1534
                                    if (getnetnum(tokens[++i],
 
1535
                                                   &maskaddr, 1, t_UNK) != 1) {
1446
1536
                                            errflg = 1;
1447
1537
                                            break;
1448
1538
                                    }
1483
1573
                                break;
1484
1574
                        }
1485
1575
                        memset((char *)&peeraddr, 0, sizeof(peeraddr));
1486
 
                        if (!getnetnum(tokens[1], &peeraddr, 1))
 
1576
                        if (getnetnum(tokens[1], &peeraddr, 1, t_REF) != 1)
1487
1577
                            break;
1488
1578
 
1489
1579
                        if (!ISREFCLOCKADR(&peeraddr)) {
1538
1628
                                        break;
1539
1629
 
1540
1630
                                    case CONF_FDG_REFID:
1541
 
                                        /* HMS: Endianness and 0 bytes? */
1542
 
                                        /* XXX */
1543
 
                                        strncpy((char *)&clock_stat.fudgeval2,
1544
 
                                                tokens[++i], 4);
 
1631
                                        i++;
 
1632
                                        memcpy(&clock_stat.fudgeval2,
 
1633
                                            tokens[i], min(strlen(tokens[i]),
 
1634
                                            4));
1545
1635
                                        clock_stat.haveflags |= CLK_HAVEVAL2;
1546
1636
                                        break;
1547
1637
 
1750
1840
                        break;
1751
1841
 
1752
1842
                    case CONFIG_PHONE:
1753
 
                        for (i = 1; i < ntokens && i < MAXPHONE; i++) {
1754
 
                                (void)strncpy(sys_phone[i - 1],
1755
 
                                              tokens[i], MAXDIAL);
 
1843
                        for (i = 1; i < ntokens && i < MAXPHONE - 1; i++) {
 
1844
                                sys_phone[i - 1] =
 
1845
                                    emalloc(strlen(tokens[i]) + 1);
 
1846
                                strcpy(sys_phone[i - 1], tokens[i]);
1756
1847
                        }
1757
 
                        sys_phone[i - 1][0] = '\0';
 
1848
                        sys_phone[i] = NULL;
1758
1849
                        break;
1759
1850
 
1760
1851
                    case CONFIG_ADJ: {
1789
1880
 
1790
1881
                for (i = 0; i < 8; i++)
1791
1882
                        for (j = 1; j < 100; ++j) {
1792
 
                                rankey[i] = (char) (RANDOM & 0xff);
 
1883
                                rankey[i] = (char) (ntp_random() & 0xff);
1793
1884
                                if (rankey[i] != 0) break;
1794
1885
                        }
1795
1886
                rankey[8] = 0;
1956
2047
                                if (ISEOL(*tokens)) break;
1957
2048
                        }
1958
2049
                }
1959
 
                *ntokens = ntok + 1;
1960
 
                
1961
 
                config->val_index++;
 
2050
 
 
2051
                if (ntok == MAXTOKENS) {
 
2052
                        /* HMS: chomp it to lose the EOL? */
 
2053
                        msyslog(LOG_ERR,
 
2054
                            "gettokens_netinfo: too many tokens.  Ignoring: %s",
 
2055
                            tokens);
 
2056
                } else {
 
2057
                        *ntokens = ntok + 1;
 
2058
                }
 
2059
 
 
2060
                config->val_index++;    /* HMS: Should this be in the 'else'? */
1962
2061
 
1963
2062
                return keywords[prop_index].keytype;
1964
2063
        }
2028
2127
                }
2029
2128
        }
2030
2129
 
2031
 
        /*
2032
 
         * Return the match
2033
 
         */
2034
 
        *ntokens = ntok + 1;
2035
 
        ntok = matchkey(tokenlist[0], keywords, 1);
2036
 
        if (ntok == CONFIG_UNKNOWN)
2037
 
                goto again;
 
2130
     /* Heiko: Remove leading and trailing quotes around tokens */
 
2131
     {
 
2132
            int i,j = 0;
 
2133
            
 
2134
                
 
2135
                        for (i = 0; i < ntok; i++) {        
 
2136
                                        /* Now check if the first char is a quote and remove that */
 
2137
                                        if ( tokenlist[ntok][0] == '"' )
 
2138
                                                        tokenlist[ntok]++;
 
2139
 
 
2140
                                        /* Now check the last char ... */
 
2141
                                        j = strlen(tokenlist[ntok])-1;
 
2142
                                        if ( tokenlist[ntok][j] == '"' )
 
2143
                                                        tokenlist[ntok][j] = '\0';
 
2144
                        }
 
2145
                                                        
 
2146
    }
 
2147
 
 
2148
        if (ntok == MAXTOKENS) {
 
2149
                --ntok;
 
2150
                /* HMS: chomp it to lose the EOL? */
 
2151
                msyslog(LOG_ERR,
 
2152
                    "gettokens: too many tokens on the line. Ignoring %s",
 
2153
                    cp);
 
2154
        } else {
 
2155
                /*
 
2156
                 * Return the match
 
2157
                 */
 
2158
                *ntokens = ntok + 1;
 
2159
                ntok = matchkey(tokenlist[0], keywords, 1);
 
2160
                if (ntok == CONFIG_UNKNOWN)
 
2161
                        goto again;
 
2162
        }
 
2163
 
2038
2164
        return ntok;
2039
2165
}
2040
2166
 
2072
2198
getnetnum(
2073
2199
        const char *num,
2074
2200
        struct sockaddr_storage *addr,
2075
 
        int complain
 
2201
        int complain,
 
2202
        enum gnn_type a_type
2076
2203
        )
2077
2204
{
2078
2205
        struct addrinfo hints;
2079
2206
        struct addrinfo *ptr;
 
2207
        int retval;
 
2208
 
 
2209
#if 0
 
2210
        printf("getnetnum: <%s> is a %s (%d)\n",
 
2211
                num,
 
2212
                (a_type == t_UNK)
 
2213
                ? "t_UNK"
 
2214
                : (a_type == t_REF)
 
2215
                  ? "t_REF"
 
2216
                  : (a_type == t_MSK)
 
2217
                    ? "t_MSK"
 
2218
                    : "???",
 
2219
                a_type);
 
2220
#endif
2080
2221
 
2081
2222
        /* Get host address. Looking for UDP datagram connection */
2082
2223
        memset(&hints, 0, sizeof (hints));
2084
2225
            hints.ai_family = addr->ss_family;
2085
2226
        else
2086
2227
            hints.ai_family = AF_UNSPEC;
 
2228
        /*
 
2229
         * If we don't have an IPv6 stack, just look up IPv4 addresses
 
2230
         */
 
2231
        if (isc_net_probeipv6() != ISC_R_SUCCESS)
 
2232
                hints.ai_family = AF_INET;
2087
2233
 
2088
2234
        hints.ai_socktype = SOCK_DGRAM;
 
2235
 
 
2236
        if (a_type != t_UNK) {
 
2237
                hints.ai_flags = AI_NUMERICHOST;
 
2238
        }
 
2239
 
2089
2240
#ifdef DEBUG
2090
 
                if (debug > 3)
2091
 
                        printf("getaddrinfo %s\n", num);
 
2241
        if (debug > 3)
 
2242
                printf("getnetnum: calling getaddrinfo(%s,...)\n", num);
2092
2243
#endif
2093
 
        if (getaddrinfo(num, "ntp", &hints, &ptr)!=0) {
 
2244
        retval = getaddrinfo(num, "ntp", &hints, &ptr);
 
2245
        if (retval != 0 ||
 
2246
           (ptr->ai_family == AF_INET6 && isc_net_probeipv6() != ISC_R_SUCCESS)) {
2094
2247
                if (complain)
2095
2248
                        msyslog(LOG_ERR,
2096
2249
                                "getaddrinfo: \"%s\" invalid host address, ignored",
2097
2250
                                num);
2098
2251
#ifdef DEBUG
2099
 
                if (debug > 3)
 
2252
                if (debug > 0)
2100
2253
                        printf(
2101
2254
                                "getaddrinfo: \"%s\" invalid host address%s.\n",
2102
2255
                                num, (complain)
2103
2256
                                ? ", ignored"
2104
2257
                                : "");
2105
2258
#endif
2106
 
                return 0;
 
2259
                if (retval == 0 && 
 
2260
                    ptr->ai_family == AF_INET6 && 
 
2261
                    isc_net_probeipv6() != ISC_R_SUCCESS) 
 
2262
                {
 
2263
                        return -1;
 
2264
                }
 
2265
                else {
 
2266
                        return 0;
 
2267
                }
2107
2268
        }
2108
2269
 
2109
2270
        memcpy(addr, ptr->ai_addr, ptr->ai_addrlen);
2110
2271
#ifdef DEBUG
2111
2272
        if (debug > 1)
2112
 
                printf("getnetnum given %s, got %s \n",
2113
 
                   num, stoa(addr));
 
2273
                printf("getnetnum given %s, got %s (%s/%d)\n",
 
2274
                   num, stoa(addr),
 
2275
                        (a_type == t_UNK)
 
2276
                        ? "t_UNK"
 
2277
                        : (a_type == t_REF)
 
2278
                          ? "t_REF"
 
2279
                          : (a_type == t_MSK)
 
2280
                            ? "t_MSK"
 
2281
                            : "???",
 
2282
                        a_type);
2114
2283
#endif
2115
2284
        freeaddrinfo(ptr);
2116
2285
        return 1;