← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ntpd/ntp_control.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:
ntpd/ntp_control.c
18
18
#include <netinet/in.h>
19
19
#include <arpa/inet.h>
20
20
 
21
 
#ifdef PUBKEY
22
 
#include "ntp_crypto.h"
23
 
#endif /* PUBKEY */
24
 
 
25
21
/*
26
22
 * Structure to hold request procedure information
27
23
 */
46
42
 * Request processing routines
47
43
 */
48
44
static  void    ctl_error       P((int));
 
45
#ifdef REFCLOCK
49
46
static  u_short ctlclkstatus    P((struct refclockstat *));
 
47
#endif
50
48
static  void    ctl_flushpkt    P((int));
51
49
static  void    ctl_putdata     P((const char *, unsigned int, int));
52
50
static  void    ctl_putstr      P((const char *, const char *,
56
54
static  void    ctl_puthex      P((const char *, u_long));
57
55
static  void    ctl_putint      P((const char *, long));
58
56
static  void    ctl_putts       P((const char *, l_fp *));
59
 
static  void    ctl_putadr      P((const char *, u_int32));
 
57
static  void    ctl_putadr      P((const char *, u_int32, struct sockaddr_storage*));
60
58
static  void    ctl_putid       P((const char *, char *));
61
59
static  void    ctl_putarray    P((const char *, double *, int));
62
60
static  void    ctl_putsys      P((int));
74
72
static  void    write_clock_status P((struct recvbuf *, int));
75
73
static  void    set_trap        P((struct recvbuf *, int));
76
74
static  void    unset_trap      P((struct recvbuf *, int));
77
 
static  struct ctl_trap *ctlfindtrap P((struct sockaddr_in *,
 
75
static  struct ctl_trap *ctlfindtrap P((struct sockaddr_storage *,
78
76
                                    struct interface *));
79
77
 
80
78
static  struct ctl_proc control_codes[] = {
108
106
        { CS_OFFSET,    RO, "offset" },         /* 11 */
109
107
        { CS_DRIFT,     RO, "frequency" },      /* 12 */
110
108
        { CS_JITTER,    RO, "jitter" },         /* 13 */
111
 
        { CS_CLOCK,     RO, "clock" },          /* 14 */
112
 
        { CS_PROCESSOR, RO, "processor" },      /* 15 */
113
 
        { CS_SYSTEM,    RO, "system" },         /* 16 */
114
 
        { CS_VERSION,   RO, "version" },        /* 17 */
115
 
        { CS_STABIL,    RO, "stability" },      /* 18 */
116
 
        { CS_VARLIST,   RO, "sys_var_list" },   /* 19 */
117
 
#ifdef PUBKEY
118
 
        { CS_FLAGS,     RO, "flags" },          /* 20 */
119
 
        { CS_HOST,      RO, "hostname" },       /* 21 */
120
 
        { CS_PUBLIC,    RO, "publickey" },      /* 22 */
121
 
        { CS_CERTIF,    RO, "certificate" },    /* 23 */
122
 
        { CS_DHPARAMS,  RO, "params" },         /* 24 */
 
109
        { CS_ERROR,     RO, "error" },          /* 14 */
 
110
        { CS_CLOCK,     RO, "clock" },          /* 15 */
 
111
        { CS_PROCESSOR, RO, "processor" },      /* 16 */
 
112
        { CS_SYSTEM,    RO, "system" },         /* 17 */
 
113
        { CS_VERSION,   RO, "version" },        /* 18 */
 
114
        { CS_STABIL,    RO, "stability" },      /* 19 */
 
115
        { CS_VARLIST,   RO, "sys_var_list" },   /* 20 */
 
116
#ifdef OPENSSL
 
117
        { CS_FLAGS,     RO, "flags" },          /* 21 */
 
118
        { CS_HOST,      RO, "hostname" },       /* 22 */
 
119
        { CS_PUBLIC,    RO, "hostkey" },        /* 23 */
 
120
        { CS_CERTIF,    RO, "cert" },           /* 24 */
123
121
        { CS_REVTIME,   RO, "refresh" },        /* 25 */
124
122
        { CS_LEAPTAB,   RO, "leapseconds" },    /* 26 */
125
 
        { CS_TAI,       RO, "tai"},             /* 27 */
126
 
#endif /* PUBKEY */
127
 
        { 0,            EOV, "" }               /* 28 */
 
123
        { CS_TAI,       RO, "tai" },            /* 27 */
 
124
        { CS_DIGEST,    RO, "signature" },      /* 28 */
 
125
#endif /* OPENSSL */
 
126
        { 0,            EOV, "" }               /* 29 */
128
127
};
129
128
 
130
129
static struct ctl_var *ext_sys_var = (struct ctl_var *)0;
150
149
        CS_STATE,
151
150
        CS_OFFSET,
152
151
        CS_DRIFT,
 
152
        CS_ERROR,
153
153
        CS_JITTER,
154
154
        CS_STABIL,
155
 
#ifdef PUBKEY
 
155
#ifdef OPENSSL
 
156
        CS_HOST,
 
157
        CS_DIGEST,
156
158
        CS_FLAGS,
157
 
        CS_HOST,
158
 
        CS_CERTIF,
159
 
        CS_DHPARAMS,
 
159
        CS_PUBLIC,
160
160
        CS_REVTIME,
161
161
        CS_LEAPTAB,
162
 
#endif /* PUBKEY */
 
162
        CS_CERTIF,
 
163
#endif /* OPENSSL */
163
164
        0
164
165
};
165
166
 
205
206
        { CP_FILTERROR, RO, "filtdisp=" },      /* 34 */
206
207
        { CP_FLASH,     RO, "flash" },          /* 35 */
207
208
        { CP_TTL,       RO, "ttl" },            /* 36 */
208
 
        { CP_TTLMAX,    RO, "ttlmax" },         /* 37 */
 
209
        { CP_RANK,      RO, "rank" },           /* 37 */
209
210
        { CP_VARLIST,   RO, "peer_var_list" },  /* 38 */
210
 
#ifdef PUBKEY
211
 
        { CP_FLAGS,     RO, "flags" },          /* 38 */
212
 
        { CP_HOST,      RO, "hostname" },       /* 39 */
213
 
        { CP_PUBLIC,    RO, "publickey" },      /* 40 */
214
 
        { CP_CERTIF,    RO, "certificate" },    /* 41 */
215
 
        { CP_SESKEY,    RO, "pcookie" },        /* 42 */
216
 
        { CP_SASKEY,    RO, "hcookie" },        /* 43 */
217
 
        { CP_INITSEQ,   RO, "initsequence" },   /* 44 */
218
 
        { CP_INITKEY,   RO, "initkey" },        /* 45 */
219
 
        { CP_INITTSP,   RO, "timestamp" },      /* 46 */
220
 
#endif /* PUBKEY */
221
 
        { 0,            EOV, ""  }              /* 47 */
 
211
#ifdef OPENSSL
 
212
        { CP_FLAGS,     RO, "flags" },          /* 39 */
 
213
        { CP_HOST,      RO, "hostname" },       /* 40 */
 
214
        { CP_INITSEQ,   RO, "initsequence" },   /* 41 */
 
215
        { CP_INITKEY,   RO, "initkey" },        /* 42 */
 
216
        { CP_INITTSP,   RO, "timestamp" },      /* 43 */
 
217
        { CP_DIGEST,    RO, "signature" },      /* 44 */
 
218
        { CP_IDENT,     RO, "identity" },       /* 45 */
 
219
#endif /* OPENSSL */
 
220
        { 0,            EOV, "" }               /* 39/46 */
222
221
};
223
222
 
224
223
 
245
244
        CP_FLASH,
246
245
        CP_KEYID,
247
246
        CP_TTL,
248
 
        CP_TTLMAX,
249
247
        CP_OFFSET,
250
248
        CP_DELAY,
251
249
        CP_DISPERSION,
257
255
        CP_FILTDELAY,
258
256
        CP_FILTOFFSET,
259
257
        CP_FILTERROR,
260
 
#ifdef PUBKEY
 
258
#ifdef OPENSSL
 
259
        CP_HOST,
 
260
        CP_DIGEST,
261
261
        CP_FLAGS,
262
 
        CP_HOST,
263
 
        CP_CERTIF,
264
 
        CP_SESKEY,
 
262
        CP_IDENT,
265
263
        CP_INITSEQ,
266
 
#endif /* PUBKEY */
 
264
#endif /* OPENSSL */
267
265
        0
268
266
};
269
267
 
395
393
        CTL_SST_TS_LF,          /* REFCLK_FG (37) */
396
394
        CTL_SST_TS_UHF,         /* REFCLK_HOPF_SERIAL (38) */
397
395
        CTL_SST_TS_UHF,         /* REFCLK_HOPF_PCI (39) */
 
396
        CTL_SST_TS_LF,          /* REFCLK_JJY (40) */
 
397
        CTL_SST_TS_UHF,         /* REFCLK_TT560 (41) */
 
398
        CTL_SST_TS_UHF,         /* REFCLK_ZYFER (42) */
 
399
        CTL_SST_TS_UHF,         /* REFCLK_RIPENCC (43) */
 
400
        CTL_SST_TS_UHF,         /* REFCLK_NEOCLOCK4X (44) */
398
401
};
399
402
 
400
403
 
445
448
static u_char * dataend;
446
449
static int      datalinelen;
447
450
static int      datanotbinflag;
448
 
static struct sockaddr_in *rmt_addr;
 
451
static struct sockaddr_storage *rmt_addr;
449
452
static struct interface *lcl_inter;
450
453
 
451
454
static u_char   res_authenticate;
730
733
/*
731
734
 * ctlclkstatus - return a status word for this clock
732
735
 */
 
736
#ifdef REFCLOCK
733
737
static u_short
734
738
ctlclkstatus(
735
739
        struct refclockstat *this_clock
736
740
        )
737
741
{
738
 
        return ((u_short)(this_clock->currentstatus) << 8) |
739
 
            (u_short)(this_clock->lastevent);
 
742
        return ((u_short)(((this_clock->currentstatus) << 8) |
 
743
            (this_clock->lastevent)));
740
744
}
 
745
#endif
741
746
 
742
747
 
743
748
/*
1069
1074
 
1070
1075
 
1071
1076
/*
1072
 
 * ctl_putadr - write a dotted quad IP address into the response
 
1077
 * ctl_putadr - write an IP address into the response
1073
1078
 */
1074
1079
static void
1075
1080
ctl_putadr(
1076
1081
        const char *tag,
1077
 
        u_int32 addr
 
1082
        u_int32 addr32,
 
1083
        struct sockaddr_storage* addr
1078
1084
        )
1079
1085
{
1080
1086
        register char *cp;
1087
1093
                *cp++ = *cq++;
1088
1094
 
1089
1095
        *cp++ = '=';
1090
 
        cq = numtoa(addr);
 
1096
        if (addr == NULL)
 
1097
                cq = numtoa(addr32);
 
1098
        else
 
1099
                cq = stoa(addr);
1091
1100
        while (*cq != '\0')
1092
1101
                *cp++ = *cq++;
1093
1102
        ctl_putdata(buffer, (unsigned)( cp - buffer ), 0);
1134
1143
        register const char *cq;
1135
1144
        char buffer[200];
1136
1145
        int i;
1137
 
 
1138
1146
        cp = buffer;
1139
1147
        cq = tag;
1140
1148
        while (*cq != '\0')
1161
1169
        )
1162
1170
{
1163
1171
        l_fp tmp;
1164
 
#ifdef HAVE_UNAME
1165
1172
        char str[256];
1166
 
#endif
 
1173
#ifdef OPENSSL
 
1174
        struct cert_info *cp;
 
1175
        char cbuf[256];
 
1176
#endif /* OPENSSL */
1167
1177
 
1168
1178
        switch (varid) {
1169
1179
 
1190
1200
                break;
1191
1201
 
1192
1202
        case CS_REFID:
1193
 
                if (sys_stratum > 1)
1194
 
                        ctl_putadr(sys_var[CS_REFID].text, sys_refid);
 
1203
                if (sys_stratum > 1 && sys_stratum < STRATUM_UNSPEC)
 
1204
                        ctl_putadr(sys_var[CS_REFID].text, sys_refid, NULL);
1195
1205
                else
1196
1206
                        ctl_putid(sys_var[CS_REFID].text,
1197
1207
                            (char *)&sys_refid);
1229
1239
                ctl_putdbl(sys_var[CS_JITTER].text, sys_jitter * 1e3);
1230
1240
                break;
1231
1241
 
 
1242
        case CS_ERROR:
 
1243
                ctl_putdbl(sys_var[CS_ERROR].text, sys_error * 1e3);
 
1244
                break;
 
1245
 
1232
1246
        case CS_CLOCK:
1233
1247
                get_systime(&tmp);
1234
1248
                ctl_putts(sys_var[CS_CLOCK].text, &tmp);
1249
1263
                ctl_putstr(sys_var[CS_SYSTEM].text, str_system,
1250
1264
                    sizeof(str_system) - 1);
1251
1265
#else
1252
 
                (void)strcpy(str, utsnamebuf.sysname);
1253
 
                (void)strcat(str, utsnamebuf.release);
 
1266
                sprintf(str, "%s/%s", utsnamebuf.sysname, utsnamebuf.release);
1254
1267
                ctl_putstr(sys_var[CS_SYSTEM].text, str, strlen(str));
1255
1268
#endif /* HAVE_UNAME */
1256
1269
                break;
1328
1341
                }
1329
1342
                break;
1330
1343
 
1331
 
#ifdef PUBKEY
 
1344
#ifdef OPENSSL
1332
1345
        case CS_FLAGS:
1333
 
                if (crypto_flags)
1334
 
                        ctl_puthex(sys_var[CS_FLAGS].text,
1335
 
                            crypto_flags);
 
1346
                if (crypto_flags) {
 
1347
                        ctl_puthex(sys_var[CS_FLAGS].text, crypto_flags);
 
1348
                }
 
1349
                break;
 
1350
 
 
1351
        case CS_DIGEST:
 
1352
                if (crypto_flags) {
 
1353
                        const EVP_MD *dp;
 
1354
 
 
1355
                        dp = EVP_get_digestbynid(crypto_flags >> 16);
 
1356
                        strcpy(str, OBJ_nid2ln(EVP_MD_pkey_type(dp)));
 
1357
                        ctl_putstr(sys_var[CS_DIGEST].text, str,
 
1358
                            strlen(str));
 
1359
                }
1336
1360
                break;
1337
1361
 
1338
1362
        case CS_HOST:
1339
 
                ctl_putstr(sys_var[CS_HOST].text, sys_hostname,
1340
 
                        strlen(sys_hostname));
1341
 
                if (host.fstamp != 0)
 
1363
                if (sys_hostname != NULL)
 
1364
                        ctl_putstr(sys_var[CS_HOST].text, sys_hostname,
 
1365
                            strlen(sys_hostname));
 
1366
                break;
 
1367
 
 
1368
        case CS_CERTIF:
 
1369
                for (cp = cinfo; cp != NULL; cp = cp->link) {
 
1370
                        sprintf(cbuf, "%s %s 0x%x %u", cp->subject,
 
1371
                            cp->issuer, cp->flags,
 
1372
                            ntohl(cp->cert.fstamp));
 
1373
                        ctl_putstr(sys_var[CS_CERTIF].text, cbuf,
 
1374
                            strlen(cbuf));
 
1375
                }
 
1376
                break;
 
1377
 
 
1378
        case CS_PUBLIC:
 
1379
                if (hostval.fstamp != 0)
1342
1380
                        ctl_putuint(sys_var[CS_PUBLIC].text,
1343
 
                            ntohl(host.fstamp));
1344
 
                break;
1345
 
 
1346
 
        case CS_CERTIF:
1347
 
                if (certif.fstamp != 0)
1348
 
                        ctl_putuint(sys_var[CS_CERTIF].text,
1349
 
                            ntohl(certif.fstamp));
1350
 
                break;
1351
 
 
1352
 
        case CS_DHPARAMS:
1353
 
                if (dhparam.fstamp != 0)
1354
 
                        ctl_putuint(sys_var[CS_DHPARAMS].text,
1355
 
                            ntohl(dhparam.fstamp));
 
1381
                            ntohl(hostval.fstamp));
1356
1382
                break;
1357
1383
 
1358
1384
        case CS_REVTIME:
1359
 
                if (host.tstamp != 0)
 
1385
                if (hostval.tstamp != 0)
1360
1386
                        ctl_putuint(sys_var[CS_REVTIME].text,
1361
 
                            ntohl(host.tstamp));
 
1387
                            ntohl(hostval.tstamp));
1362
1388
                break;
1363
1389
 
1364
1390
        case CS_LEAPTAB:
1368
1394
                if (sys_tai != 0)
1369
1395
                        ctl_putuint(sys_var[CS_TAI].text, sys_tai);
1370
1396
                break;
1371
 
#endif /* PUBKEY */
 
1397
#endif /* OPENSSL */
1372
1398
        }
1373
1399
}
1374
1400
 
1382
1408
        struct peer *peer
1383
1409
        )
1384
1410
{
 
1411
#ifdef OPENSSL
 
1412
        char str[256];
 
1413
        struct autokey *ap;
 
1414
#endif /* OPENSSL */
 
1415
 
1385
1416
        switch (varid) {
1386
1417
 
1387
1418
        case CP_CONFIG:
1400
1431
                break;
1401
1432
 
1402
1433
        case CP_SRCADR:
1403
 
                ctl_putadr(peer_var[CP_SRCADR].text,
1404
 
                    peer->srcadr.sin_addr.s_addr);
 
1434
                ctl_putadr(peer_var[CP_SRCADR].text, 0,
 
1435
                    &peer->srcadr);
1405
1436
                break;
1406
1437
 
1407
1438
        case CP_SRCPORT:
1408
1439
                ctl_putuint(peer_var[CP_SRCPORT].text,
1409
 
                    ntohs(peer->srcadr.sin_port));
 
1440
                    ntohs(((struct sockaddr_in*)&peer->srcadr)->sin_port));
1410
1441
                break;
1411
1442
 
1412
1443
        case CP_DSTADR:
1413
 
                ctl_putadr(peer_var[CP_DSTADR].text,
1414
 
                    peer->dstadr->sin.sin_addr.s_addr);
 
1444
                ctl_putadr(peer_var[CP_DSTADR].text, 0,
 
1445
                    &(peer->dstadr->sin));
1415
1446
                break;
1416
1447
 
1417
1448
        case CP_DSTPORT:
1418
1449
                ctl_putuint(peer_var[CP_DSTPORT].text,
1419
1450
                    (u_long)(peer->dstadr ?
1420
 
                    ntohs(peer->dstadr->sin.sin_port) : 0));
 
1451
                    ntohs(((struct sockaddr_in*)&peer->dstadr->sin)->sin_port) : 0));
1421
1452
                break;
1422
1453
 
1423
1454
        case CP_LEAP:
1456
1487
                break;
1457
1488
 
1458
1489
        case CP_REFID:
1459
 
                if (peer->stratum > 1) {
1460
 
                        if (peer->flags & FLAG_REFCLOCK)
1461
 
                            ctl_putadr(peer_var[CP_REFID].text,
1462
 
                                peer->srcadr.sin_addr.s_addr);
 
1490
                if (peer->flags & FLAG_REFCLOCK) {
 
1491
                        if (peer->stratum > 0 && peer->stratum <
 
1492
                            STRATUM_UNSPEC)
 
1493
                                ctl_putadr(peer_var[CP_REFID].text,
 
1494
                                    peer->refid, NULL);
1463
1495
                        else
1464
 
                            ctl_putadr(peer_var[CP_REFID].text,
1465
 
                                peer->refid);
 
1496
                                ctl_putid(peer_var[CP_REFID].text,
 
1497
                                   (char *)&peer->refid);
1466
1498
                } else {
1467
 
                        ctl_putid(peer_var[CP_REFID].text,
1468
 
                            (char *)&peer->refid);
 
1499
                        if (peer->stratum > 1 && peer->stratum <
 
1500
                            STRATUM_UNSPEC)
 
1501
                                ctl_putadr(peer_var[CP_REFID].text,
 
1502
                                    peer->refid, NULL);
 
1503
                        else
 
1504
                                ctl_putid(peer_var[CP_REFID].text,
 
1505
                                    (char *)&peer->refid);
1469
1506
                }
1470
1507
                break;
1471
1508
 
1494
1531
                break;
1495
1532
 
1496
1533
        case CP_TTL:
1497
 
                if (!(peer->cast_flags & MDF_ACAST))
1498
 
                        break;
1499
 
                ctl_putint(peer_var[CP_TTL].text, peer->ttl);
1500
 
                break;
1501
 
 
1502
 
        case CP_TTLMAX:
1503
 
                if (!(peer->cast_flags & (MDF_MCAST | MDF_ACAST)))
1504
 
                        break;
1505
 
                ctl_putint(peer_var[CP_TTLMAX].text, peer->ttlmax);
 
1534
                ctl_putint(peer_var[CP_TTL].text, sys_ttl[peer->ttl]);
1506
1535
                break;
1507
1536
 
1508
1537
        case CP_VALID:
1509
1538
                ctl_putuint(peer_var[CP_VALID].text, peer->unreach);
1510
1539
                break;
1511
1540
 
 
1541
        case CP_RANK:
 
1542
                ctl_putuint(peer_var[CP_RANK].text, peer->rank);
 
1543
                break;
 
1544
 
1512
1545
        case CP_TIMER:
1513
1546
                ctl_putuint(peer_var[CP_TIMER].text,
1514
1547
                    peer->nextdate - current_time);
1602
1635
                        ctl_putdata(buf, (unsigned)(s - buf), 0);
1603
1636
                }
1604
1637
                break;
1605
 
#ifdef PUBKEY
 
1638
#ifdef OPENSSL
1606
1639
        case CP_FLAGS:
1607
1640
                if (peer->crypto)
1608
1641
                        ctl_puthex(peer_var[CP_FLAGS].text, peer->crypto);
1609
1642
                break;
1610
1643
 
 
1644
        case CP_DIGEST:
 
1645
                if (peer->crypto) {
 
1646
                        const EVP_MD *dp;
 
1647
 
 
1648
                        dp = EVP_get_digestbynid(peer->crypto >> 16);
 
1649
                        strcpy(str, OBJ_nid2ln(EVP_MD_pkey_type(dp)));
 
1650
                        ctl_putstr(peer_var[CP_DIGEST].text, str,
 
1651
                             strlen(str));
 
1652
                }
 
1653
                break;
 
1654
 
1611
1655
        case CP_HOST:
1612
 
                if (peer->keystr != NULL)
1613
 
                        ctl_putstr(peer_var[CP_HOST].text, peer->keystr,
1614
 
                            strlen(peer->keystr));
1615
 
                if (peer->pubkey.fstamp != 0)
1616
 
                        ctl_putuint(peer_var[CP_PUBLIC].text,
1617
 
                            peer->pubkey.fstamp);
1618
 
                break;
1619
 
 
1620
 
        case CP_CERTIF:
1621
 
                if (peer->certif.fstamp != 0)
1622
 
                        ctl_putuint(peer_var[CP_CERTIF].text,
1623
 
                            peer->certif.fstamp);
1624
 
                break;
1625
 
 
1626
 
        case CP_SESKEY:
1627
 
                if (peer->pcookie.key != 0)
1628
 
                        ctl_puthex(peer_var[CP_SESKEY].text,
1629
 
                            peer->pcookie.key);
1630
 
                if (peer->hcookie != 0)
1631
 
                        ctl_puthex(peer_var[CP_SASKEY].text,
1632
 
                            peer->hcookie);
 
1656
                if (peer->subject != NULL)
 
1657
                        ctl_putstr(peer_var[CP_HOST].text, peer->subject,
 
1658
                            strlen(peer->subject));
 
1659
                break;
 
1660
 
 
1661
        case CP_IDENT:
 
1662
                if (peer->issuer != NULL)
 
1663
                        ctl_putstr(peer_var[CP_IDENT].text, peer->issuer,
 
1664
                            strlen(peer->issuer));
1633
1665
                break;
1634
1666
 
1635
1667
        case CP_INITSEQ:
1636
 
                if (peer->recauto.key == 0)
 
1668
                if ((ap = (struct autokey *)peer->recval.ptr) == NULL)
1637
1669
                        break;
1638
 
                ctl_putint(peer_var[CP_INITSEQ].text,
1639
 
                    peer->recauto.seq);
1640
 
                ctl_puthex(peer_var[CP_INITKEY].text,
1641
 
                    peer->recauto.key);
 
1670
                ctl_putint(peer_var[CP_INITSEQ].text, ap->seq);
 
1671
                ctl_puthex(peer_var[CP_INITKEY].text, ap->key);
1642
1672
                ctl_putuint(peer_var[CP_INITTSP].text,
1643
 
                    peer->recauto.tstamp);
 
1673
                    ntohl(peer->recval.tstamp));
1644
1674
                break;
1645
 
#endif /* PUBKEY */
 
1675
#endif /* OPENSSL */
1646
1676
        }
1647
1677
}
1648
1678
 
1712
1742
                if (mustput || (clock_stat->haveflags & CLK_HAVEVAL2)) {
1713
1743
                        if (clock_stat->fudgeval1 > 1)
1714
1744
                                ctl_putadr(clock_var[CC_FUDGEVAL2].text,
1715
 
                                    (u_int32)clock_stat->fudgeval2);
 
1745
                                    (u_int32)clock_stat->fudgeval2, NULL);
1716
1746
                        else
1717
1747
                                ctl_putid(clock_var[CC_FUDGEVAL2].text,
1718
1748
                                    (char *)&clock_stat->fudgeval2);
1871
1901
                                                        numctlbadpkts++;
1872
1902
                                                        msyslog(LOG_WARNING,
1873
1903
                "Possible 'ntpdx' exploit from %s:%d (possibly spoofed)\n",
1874
 
                inet_ntoa(rmt_addr->sin_addr), ntohs(rmt_addr->sin_port)
 
1904
                stoa(rmt_addr), SRCPORT(rmt_addr)
1875
1905
                                                                );
1876
1906
                                                        return (0);
1877
1907
                                                }
1879
1909
                                        if (cp < reqend)
1880
1910
                                                cp++;
1881
1911
                                        *tp-- = '\0';
1882
 
                                        while (tp > buf) {
1883
 
                                                *tp-- = '\0';
 
1912
                                        while (tp >= buf) {
1884
1913
                                                if (!isspace((int)(*tp)))
1885
1914
                                                        break;
 
1915
                                                *tp-- = '\0';
1886
1916
                                        }
1887
1917
                                        reqpt = cp;
1888
1918
                                        *data = buf;
1956
1986
 
1957
1987
                n = 0;
1958
1988
                rpkt.status = htons(ctlsysstatus());
1959
 
                for (i = 0; i < HASH_SIZE; i++) {
 
1989
                for (i = 0; i < NTP_HASH_SIZE; i++) {
1960
1990
                        for (peer = assoc_hash[i]; peer != 0;
1961
1991
                                peer = peer->ass_next) {
1962
1992
                                ass_stat[n++] = htons(peer->associd);
2125
2155
        register struct ctl_var *v;
2126
2156
        register int ext_var;
2127
2157
        char *valuep;
2128
 
        long val;
 
2158
        long val = 0;
2129
2159
 
2130
2160
        /*
2131
2161
         * If he's trying to write into a peer tell him no way
2251
2281
                        peer = sys_peer;
2252
2282
                } else {
2253
2283
                        peer = 0;
2254
 
                        for (i = 0; peer == 0 && i < HASH_SIZE; i++) {
 
2284
                        for (i = 0; peer == 0 && i < NTP_HASH_SIZE; i++) {
2255
2285
                                for (peer = assoc_hash[i]; peer != 0;
2256
2286
                                        peer = peer->ass_next) {
2257
2287
                                        if (peer->flags & FLAG_REFCLOCK)
2429
2459
 */
2430
2460
int
2431
2461
ctlsettrap(
2432
 
        struct sockaddr_in *raddr,
 
2462
        struct sockaddr_storage *raddr,
2433
2463
        struct interface *linter,
2434
2464
        int traptype,
2435
2465
        int version
2534
2564
        tptouse->tr_sequence = 1;
2535
2565
        tptouse->tr_addr = *raddr;
2536
2566
        tptouse->tr_localaddr = linter;
2537
 
        tptouse->tr_version = version;
 
2567
        tptouse->tr_version = (u_char) version;
2538
2568
        tptouse->tr_flags = TRAP_INUSE;
2539
2569
        if (traptype == TRAP_TYPE_CONFIG)
2540
2570
                tptouse->tr_flags |= TRAP_CONFIGURED;
2550
2580
 */
2551
2581
int
2552
2582
ctlclrtrap(
2553
 
        struct sockaddr_in *raddr,
 
2583
        struct sockaddr_storage *raddr,
2554
2584
        struct interface *linter,
2555
2585
        int traptype
2556
2586
        )
2575
2605
 */
2576
2606
static struct ctl_trap *
2577
2607
ctlfindtrap(
2578
 
        struct sockaddr_in *raddr,
 
2608
        struct sockaddr_storage *raddr,
2579
2609
        struct interface *linter
2580
2610
        )
2581
2611
{
2582
2612
        register struct ctl_trap *tp;
2583
2613
 
2584
2614
        for (tp = ctl_trap; tp < &ctl_trap[CTL_MAXTRAPS]; tp++) {
2585
 
                if (tp->tr_flags & TRAP_INUSE && NSRCADR(raddr) ==
2586
 
                    NSRCADR(&tp->tr_addr) && NSRCPORT(raddr) ==
2587
 
                    NSRCPORT(&tp->tr_addr) && linter ==
2588
 
                    tp->tr_localaddr)
2589
 
                        return (tp);
 
2615
                if ((tp->tr_flags & TRAP_INUSE)
 
2616
                    && (NSRCPORT(raddr) == NSRCPORT(&tp->tr_addr))
 
2617
                    && SOCKCMP(raddr, &tp->tr_addr)
 
2618
                    && (linter == tp->tr_localaddr) )
 
2619
                return (tp);
2590
2620
        }
2591
2621
        return (struct ctl_trap *)NULL;
2592
2622
}
2607
2637
         * Record error code in proper spots, but have mercy on the
2608
2638
         * log file.
2609
2639
         */
2610
 
        if (!(err & PEER_EVENT)) {
 
2640
        if (!(err & (PEER_EVENT | CRPT_EVENT))) {
2611
2641
                if (ctl_sys_num_events < CTL_SYS_MAXEVENTS)
2612
2642
                        ctl_sys_num_events++;
2613
2643
                if (ctl_sys_last_event != (u_char)err) {
2629
2659
 
2630
2660
#ifdef REFCLOCK
2631
2661
                if (ISREFCLOCKADR(&peer->srcadr))
2632
 
                        src = refnumtoa(peer->srcadr.sin_addr.s_addr);
 
2662
                        src = refnumtoa(&peer->srcadr);
2633
2663
                else
2634
2664
#endif
2635
 
                        src = ntoa(&peer->srcadr);
 
2665
                        src = stoa(&peer->srcadr);
2636
2666
 
2637
2667
                peer->last_event = (u_char)(err & ~PEER_EVENT);
2638
2668
                if (peer->num_events < CTL_PEER_MAXEVENTS)
2685
2715
                 * variables. Don't send crypto strings.
2686
2716
                 */
2687
2717
                for (i = 1; i <= CS_MAXCODE; i++) {
2688
 
#ifdef PUBKEY
 
2718
#ifdef OPENSSL
2689
2719
                        if (i > CS_VARLIST)
2690
2720
                                continue;
2691
 
#endif /* PUBKEY */
 
2721
#endif /* OPENSSL */
2692
2722
                        ctl_putsys(i);
2693
2723
                }
2694
2724
#ifdef REFCLOCK
2714
2744
                                            strlen(kv->text), 0);
2715
2745
                        free_varlist(clock_stat.kv_list);
2716
2746
                }
2717
 
#endif /*REFCLOCK*/
 
2747
#endif /* REFCLOCK */
2718
2748
        } else {
2719
2749
                rpkt.associd = htons(peer->associd);
2720
2750
                rpkt.status = htons(ctlpeerstatus(peer));
2722
2752
                /*
2723
2753
                 * Dump it all. Later, maybe less.
2724
2754
                 */
2725
 
                for (i = 1; i <= CP_MAXCODE; i++)
2726
 
#ifdef PUBKEY
 
2755
                for (i = 1; i <= CP_MAXCODE; i++) {
 
2756
#ifdef OPENSSL
2727
2757
                        if (i > CP_VARLIST)
2728
2758
                                continue;
2729
 
#endif /* PUBKEY */
 
2759
#endif /* OPENSSL */
2730
2760
                        ctl_putpeer(i, peer);
 
2761
                }
2731
2762
#ifdef REFCLOCK
2732
2763
                /*
2733
2764
                 * for clock exception events: add clock variables to
2753
2784
                                            strlen(kv->text), 0);
2754
2785
                        free_varlist(clock_stat.kv_list);
2755
2786
                }
2756
 
#endif /*REFCLOCK*/
 
2787
#endif /* REFCLOCK */
2757
2788
        }
2758
2789
 
2759
2790
        /*
2807
2838
add_var(
2808
2839
        struct ctl_var **kv,
2809
2840
        u_long size,
2810
 
        int def
 
2841
        u_short def
2811
2842
        )
2812
2843
{
2813
2844
        register u_long c;
2836
2867
        struct ctl_var **kv,
2837
2868
        const char *data,
2838
2869
        u_long size,
2839
 
        int def
 
2870
        u_short def
2840
2871
        )
2841
2872
{
2842
2873
        register struct ctl_var *k;
2847
2878
        if (!data || !size)
2848
2879
                return;
2849
2880
 
2850
 
        if ((k = *kv)) {
 
2881
        k = *kv;
 
2882
        if (k != NULL) {
2851
2883
                while (!(k->flags & EOV)) {
2852
2884
                        s = data;
2853
2885
                        t = k->text;
2882
2914
set_sys_var(
2883
2915
        char *data,
2884
2916
        u_long size,
2885
 
        int def
 
2917
        u_short def
2886
2918
        )
2887
2919
{
2888
2920
        set_var(&ext_sys_var, data, size, def);