1 /* $NetBSD: ntp_control.c,v 1.14 2015/10/23 18:06:19 christos Exp $ */ 2 3 /* 4 * ntp_control.c - respond to mode 6 control messages and send async 5 * traps. Provides service to ntpq and others. 6 */ 7 8 #ifdef HAVE_CONFIG_H 9 # include <config.h> 10 #endif 11 12 #include <stdio.h> 13 #include <ctype.h> 14 #include <signal.h> 15 #include <sys/stat.h> 16 #ifdef HAVE_NETINET_IN_H 17 # include <netinet/in.h> 18 #endif 19 #include <arpa/inet.h> 20 21 #include "ntpd.h" 22 #include "ntp_io.h" 23 #include "ntp_refclock.h" 24 #include "ntp_control.h" 25 #include "ntp_unixtime.h" 26 #include "ntp_stdlib.h" 27 #include "ntp_config.h" 28 #include "ntp_crypto.h" 29 #include "ntp_assert.h" 30 #include "ntp_leapsec.h" 31 #include "ntp_md5.h" /* provides OpenSSL digest API */ 32 #include "lib_strbuf.h" 33 #include <rc_cmdlength.h> 34 #ifdef KERNEL_PLL 35 # include "ntp_syscall.h" 36 #endif 37 38 39 /* 40 * Structure to hold request procedure information 41 */ 42 43 struct ctl_proc { 44 short control_code; /* defined request code */ 45 #define NO_REQUEST (-1) 46 u_short flags; /* flags word */ 47 /* Only one flag. Authentication required or not. */ 48 #define NOAUTH 0 49 #define AUTH 1 50 void (*handler) (struct recvbuf *, int); /* handle request */ 51 }; 52 53 54 /* 55 * Request processing routines 56 */ 57 static void ctl_error (u_char); 58 #ifdef REFCLOCK 59 static u_short ctlclkstatus (struct refclockstat *); 60 #endif 61 static void ctl_flushpkt (u_char); 62 static void ctl_putdata (const char *, unsigned int, int); 63 static void ctl_putstr (const char *, const char *, size_t); 64 static void ctl_putdblf (const char *, int, int, double); 65 #define ctl_putdbl(tag, d) ctl_putdblf(tag, 1, 3, d) 66 #define ctl_putdbl6(tag, d) ctl_putdblf(tag, 1, 6, d) 67 #define ctl_putsfp(tag, sfp) ctl_putdblf(tag, 0, -1, \ 68 FPTOD(sfp)) 69 static void ctl_putuint (const char *, u_long); 70 static void ctl_puthex (const char *, u_long); 71 static void ctl_putint (const char *, long); 72 static void ctl_putts (const char *, l_fp *); 73 static void ctl_putadr (const char *, u_int32, 74 sockaddr_u *); 75 static void ctl_putrefid (const char *, u_int32); 76 static void ctl_putarray (const char *, double *, int); 77 static void ctl_putsys (int); 78 static void ctl_putpeer (int, struct peer *); 79 static void ctl_putfs (const char *, tstamp_t); 80 #ifdef REFCLOCK 81 static void ctl_putclock (int, struct refclockstat *, int); 82 #endif /* REFCLOCK */ 83 static const struct ctl_var *ctl_getitem(const struct ctl_var *, 84 char **); 85 static u_short count_var (const struct ctl_var *); 86 static void control_unspec (struct recvbuf *, int); 87 static void read_status (struct recvbuf *, int); 88 static void read_sysvars (void); 89 static void read_peervars (void); 90 static void read_variables (struct recvbuf *, int); 91 static void write_variables (struct recvbuf *, int); 92 static void read_clockstatus(struct recvbuf *, int); 93 static void write_clockstatus(struct recvbuf *, int); 94 static void set_trap (struct recvbuf *, int); 95 static void save_config (struct recvbuf *, int); 96 static void configure (struct recvbuf *, int); 97 static void send_mru_entry (mon_entry *, int); 98 static void send_random_tag_value(int); 99 static void read_mru_list (struct recvbuf *, int); 100 static void send_ifstats_entry(endpt *, u_int); 101 static void read_ifstats (struct recvbuf *); 102 static void sockaddrs_from_restrict_u(sockaddr_u *, sockaddr_u *, 103 restrict_u *, int); 104 static void send_restrict_entry(restrict_u *, int, u_int); 105 static void send_restrict_list(restrict_u *, int, u_int *); 106 static void read_addr_restrictions(struct recvbuf *); 107 static void read_ordlist (struct recvbuf *, int); 108 static u_int32 derive_nonce (sockaddr_u *, u_int32, u_int32); 109 static void generate_nonce (struct recvbuf *, char *, size_t); 110 static int validate_nonce (const char *, struct recvbuf *); 111 static void req_nonce (struct recvbuf *, int); 112 static void unset_trap (struct recvbuf *, int); 113 static struct ctl_trap *ctlfindtrap(sockaddr_u *, 114 struct interface *); 115 116 static const struct ctl_proc control_codes[] = { 117 { CTL_OP_UNSPEC, NOAUTH, control_unspec }, 118 { CTL_OP_READSTAT, NOAUTH, read_status }, 119 { CTL_OP_READVAR, NOAUTH, read_variables }, 120 { CTL_OP_WRITEVAR, AUTH, write_variables }, 121 { CTL_OP_READCLOCK, NOAUTH, read_clockstatus }, 122 { CTL_OP_WRITECLOCK, NOAUTH, write_clockstatus }, 123 { CTL_OP_SETTRAP, NOAUTH, set_trap }, 124 { CTL_OP_CONFIGURE, AUTH, configure }, 125 { CTL_OP_SAVECONFIG, AUTH, save_config }, 126 { CTL_OP_READ_MRU, NOAUTH, read_mru_list }, 127 { CTL_OP_READ_ORDLIST_A, AUTH, read_ordlist }, 128 { CTL_OP_REQ_NONCE, NOAUTH, req_nonce }, 129 { CTL_OP_UNSETTRAP, NOAUTH, unset_trap }, 130 { NO_REQUEST, 0, NULL } 131 }; 132 133 /* 134 * System variables we understand 135 */ 136 #define CS_LEAP 1 137 #define CS_STRATUM 2 138 #define CS_PRECISION 3 139 #define CS_ROOTDELAY 4 140 #define CS_ROOTDISPERSION 5 141 #define CS_REFID 6 142 #define CS_REFTIME 7 143 #define CS_POLL 8 144 #define CS_PEERID 9 145 #define CS_OFFSET 10 146 #define CS_DRIFT 11 147 #define CS_JITTER 12 148 #define CS_ERROR 13 149 #define CS_CLOCK 14 150 #define CS_PROCESSOR 15 151 #define CS_SYSTEM 16 152 #define CS_VERSION 17 153 #define CS_STABIL 18 154 #define CS_VARLIST 19 155 #define CS_TAI 20 156 #define CS_LEAPTAB 21 157 #define CS_LEAPEND 22 158 #define CS_RATE 23 159 #define CS_MRU_ENABLED 24 160 #define CS_MRU_DEPTH 25 161 #define CS_MRU_DEEPEST 26 162 #define CS_MRU_MINDEPTH 27 163 #define CS_MRU_MAXAGE 28 164 #define CS_MRU_MAXDEPTH 29 165 #define CS_MRU_MEM 30 166 #define CS_MRU_MAXMEM 31 167 #define CS_SS_UPTIME 32 168 #define CS_SS_RESET 33 169 #define CS_SS_RECEIVED 34 170 #define CS_SS_THISVER 35 171 #define CS_SS_OLDVER 36 172 #define CS_SS_BADFORMAT 37 173 #define CS_SS_BADAUTH 38 174 #define CS_SS_DECLINED 39 175 #define CS_SS_RESTRICTED 40 176 #define CS_SS_LIMITED 41 177 #define CS_SS_KODSENT 42 178 #define CS_SS_PROCESSED 43 179 #define CS_PEERADR 44 180 #define CS_PEERMODE 45 181 #define CS_BCASTDELAY 46 182 #define CS_AUTHDELAY 47 183 #define CS_AUTHKEYS 48 184 #define CS_AUTHFREEK 49 185 #define CS_AUTHKLOOKUPS 50 186 #define CS_AUTHKNOTFOUND 51 187 #define CS_AUTHKUNCACHED 52 188 #define CS_AUTHKEXPIRED 53 189 #define CS_AUTHENCRYPTS 54 190 #define CS_AUTHDECRYPTS 55 191 #define CS_AUTHRESET 56 192 #define CS_K_OFFSET 57 193 #define CS_K_FREQ 58 194 #define CS_K_MAXERR 59 195 #define CS_K_ESTERR 60 196 #define CS_K_STFLAGS 61 197 #define CS_K_TIMECONST 62 198 #define CS_K_PRECISION 63 199 #define CS_K_FREQTOL 64 200 #define CS_K_PPS_FREQ 65 201 #define CS_K_PPS_STABIL 66 202 #define CS_K_PPS_JITTER 67 203 #define CS_K_PPS_CALIBDUR 68 204 #define CS_K_PPS_CALIBS 69 205 #define CS_K_PPS_CALIBERRS 70 206 #define CS_K_PPS_JITEXC 71 207 #define CS_K_PPS_STBEXC 72 208 #define CS_KERN_FIRST CS_K_OFFSET 209 #define CS_KERN_LAST CS_K_PPS_STBEXC 210 #define CS_IOSTATS_RESET 73 211 #define CS_TOTAL_RBUF 74 212 #define CS_FREE_RBUF 75 213 #define CS_USED_RBUF 76 214 #define CS_RBUF_LOWATER 77 215 #define CS_IO_DROPPED 78 216 #define CS_IO_IGNORED 79 217 #define CS_IO_RECEIVED 80 218 #define CS_IO_SENT 81 219 #define CS_IO_SENDFAILED 82 220 #define CS_IO_WAKEUPS 83 221 #define CS_IO_GOODWAKEUPS 84 222 #define CS_TIMERSTATS_RESET 85 223 #define CS_TIMER_OVERRUNS 86 224 #define CS_TIMER_XMTS 87 225 #define CS_FUZZ 88 226 #define CS_WANDER_THRESH 89 227 #define CS_LEAPSMEARINTV 90 228 #define CS_LEAPSMEAROFFS 91 229 #define CS_MAX_NOAUTOKEY CS_LEAPSMEAROFFS 230 #ifdef AUTOKEY 231 #define CS_FLAGS (1 + CS_MAX_NOAUTOKEY) 232 #define CS_HOST (2 + CS_MAX_NOAUTOKEY) 233 #define CS_PUBLIC (3 + CS_MAX_NOAUTOKEY) 234 #define CS_CERTIF (4 + CS_MAX_NOAUTOKEY) 235 #define CS_SIGNATURE (5 + CS_MAX_NOAUTOKEY) 236 #define CS_REVTIME (6 + CS_MAX_NOAUTOKEY) 237 #define CS_IDENT (7 + CS_MAX_NOAUTOKEY) 238 #define CS_DIGEST (8 + CS_MAX_NOAUTOKEY) 239 #define CS_MAXCODE CS_DIGEST 240 #else /* !AUTOKEY follows */ 241 #define CS_MAXCODE CS_MAX_NOAUTOKEY 242 #endif /* !AUTOKEY */ 243 244 /* 245 * Peer variables we understand 246 */ 247 #define CP_CONFIG 1 248 #define CP_AUTHENABLE 2 249 #define CP_AUTHENTIC 3 250 #define CP_SRCADR 4 251 #define CP_SRCPORT 5 252 #define CP_DSTADR 6 253 #define CP_DSTPORT 7 254 #define CP_LEAP 8 255 #define CP_HMODE 9 256 #define CP_STRATUM 10 257 #define CP_PPOLL 11 258 #define CP_HPOLL 12 259 #define CP_PRECISION 13 260 #define CP_ROOTDELAY 14 261 #define CP_ROOTDISPERSION 15 262 #define CP_REFID 16 263 #define CP_REFTIME 17 264 #define CP_ORG 18 265 #define CP_REC 19 266 #define CP_XMT 20 267 #define CP_REACH 21 268 #define CP_UNREACH 22 269 #define CP_TIMER 23 270 #define CP_DELAY 24 271 #define CP_OFFSET 25 272 #define CP_JITTER 26 273 #define CP_DISPERSION 27 274 #define CP_KEYID 28 275 #define CP_FILTDELAY 29 276 #define CP_FILTOFFSET 30 277 #define CP_PMODE 31 278 #define CP_RECEIVED 32 279 #define CP_SENT 33 280 #define CP_FILTERROR 34 281 #define CP_FLASH 35 282 #define CP_TTL 36 283 #define CP_VARLIST 37 284 #define CP_IN 38 285 #define CP_OUT 39 286 #define CP_RATE 40 287 #define CP_BIAS 41 288 #define CP_SRCHOST 42 289 #define CP_TIMEREC 43 290 #define CP_TIMEREACH 44 291 #define CP_BADAUTH 45 292 #define CP_BOGUSORG 46 293 #define CP_OLDPKT 47 294 #define CP_SELDISP 48 295 #define CP_SELBROKEN 49 296 #define CP_CANDIDATE 50 297 #define CP_MAX_NOAUTOKEY CP_CANDIDATE 298 #ifdef AUTOKEY 299 #define CP_FLAGS (1 + CP_MAX_NOAUTOKEY) 300 #define CP_HOST (2 + CP_MAX_NOAUTOKEY) 301 #define CP_VALID (3 + CP_MAX_NOAUTOKEY) 302 #define CP_INITSEQ (4 + CP_MAX_NOAUTOKEY) 303 #define CP_INITKEY (5 + CP_MAX_NOAUTOKEY) 304 #define CP_INITTSP (6 + CP_MAX_NOAUTOKEY) 305 #define CP_SIGNATURE (7 + CP_MAX_NOAUTOKEY) 306 #define CP_IDENT (8 + CP_MAX_NOAUTOKEY) 307 #define CP_MAXCODE CP_IDENT 308 #else /* !AUTOKEY follows */ 309 #define CP_MAXCODE CP_MAX_NOAUTOKEY 310 #endif /* !AUTOKEY */ 311 312 /* 313 * Clock variables we understand 314 */ 315 #define CC_TYPE 1 316 #define CC_TIMECODE 2 317 #define CC_POLL 3 318 #define CC_NOREPLY 4 319 #define CC_BADFORMAT 5 320 #define CC_BADDATA 6 321 #define CC_FUDGETIME1 7 322 #define CC_FUDGETIME2 8 323 #define CC_FUDGEVAL1 9 324 #define CC_FUDGEVAL2 10 325 #define CC_FLAGS 11 326 #define CC_DEVICE 12 327 #define CC_VARLIST 13 328 #define CC_MAXCODE CC_VARLIST 329 330 /* 331 * System variable values. The array can be indexed by the variable 332 * index to find the textual name. 333 */ 334 static const struct ctl_var sys_var[] = { 335 { 0, PADDING, "" }, /* 0 */ 336 { CS_LEAP, RW, "leap" }, /* 1 */ 337 { CS_STRATUM, RO, "stratum" }, /* 2 */ 338 { CS_PRECISION, RO, "precision" }, /* 3 */ 339 { CS_ROOTDELAY, RO, "rootdelay" }, /* 4 */ 340 { CS_ROOTDISPERSION, RO, "rootdisp" }, /* 5 */ 341 { CS_REFID, RO, "refid" }, /* 6 */ 342 { CS_REFTIME, RO, "reftime" }, /* 7 */ 343 { CS_POLL, RO, "tc" }, /* 8 */ 344 { CS_PEERID, RO, "peer" }, /* 9 */ 345 { CS_OFFSET, RO, "offset" }, /* 10 */ 346 { CS_DRIFT, RO, "frequency" }, /* 11 */ 347 { CS_JITTER, RO, "sys_jitter" }, /* 12 */ 348 { CS_ERROR, RO, "clk_jitter" }, /* 13 */ 349 { CS_CLOCK, RO, "clock" }, /* 14 */ 350 { CS_PROCESSOR, RO, "processor" }, /* 15 */ 351 { CS_SYSTEM, RO, "system" }, /* 16 */ 352 { CS_VERSION, RO, "version" }, /* 17 */ 353 { CS_STABIL, RO, "clk_wander" }, /* 18 */ 354 { CS_VARLIST, RO, "sys_var_list" }, /* 19 */ 355 { CS_TAI, RO, "tai" }, /* 20 */ 356 { CS_LEAPTAB, RO, "leapsec" }, /* 21 */ 357 { CS_LEAPEND, RO, "expire" }, /* 22 */ 358 { CS_RATE, RO, "mintc" }, /* 23 */ 359 { CS_MRU_ENABLED, RO, "mru_enabled" }, /* 24 */ 360 { CS_MRU_DEPTH, RO, "mru_depth" }, /* 25 */ 361 { CS_MRU_DEEPEST, RO, "mru_deepest" }, /* 26 */ 362 { CS_MRU_MINDEPTH, RO, "mru_mindepth" }, /* 27 */ 363 { CS_MRU_MAXAGE, RO, "mru_maxage" }, /* 28 */ 364 { CS_MRU_MAXDEPTH, RO, "mru_maxdepth" }, /* 29 */ 365 { CS_MRU_MEM, RO, "mru_mem" }, /* 30 */ 366 { CS_MRU_MAXMEM, RO, "mru_maxmem" }, /* 31 */ 367 { CS_SS_UPTIME, RO, "ss_uptime" }, /* 32 */ 368 { CS_SS_RESET, RO, "ss_reset" }, /* 33 */ 369 { CS_SS_RECEIVED, RO, "ss_received" }, /* 34 */ 370 { CS_SS_THISVER, RO, "ss_thisver" }, /* 35 */ 371 { CS_SS_OLDVER, RO, "ss_oldver" }, /* 36 */ 372 { CS_SS_BADFORMAT, RO, "ss_badformat" }, /* 37 */ 373 { CS_SS_BADAUTH, RO, "ss_badauth" }, /* 38 */ 374 { CS_SS_DECLINED, RO, "ss_declined" }, /* 39 */ 375 { CS_SS_RESTRICTED, RO, "ss_restricted" }, /* 40 */ 376 { CS_SS_LIMITED, RO, "ss_limited" }, /* 41 */ 377 { CS_SS_KODSENT, RO, "ss_kodsent" }, /* 42 */ 378 { CS_SS_PROCESSED, RO, "ss_processed" }, /* 43 */ 379 { CS_PEERADR, RO, "peeradr" }, /* 44 */ 380 { CS_PEERMODE, RO, "peermode" }, /* 45 */ 381 { CS_BCASTDELAY, RO, "bcastdelay" }, /* 46 */ 382 { CS_AUTHDELAY, RO, "authdelay" }, /* 47 */ 383 { CS_AUTHKEYS, RO, "authkeys" }, /* 48 */ 384 { CS_AUTHFREEK, RO, "authfreek" }, /* 49 */ 385 { CS_AUTHKLOOKUPS, RO, "authklookups" }, /* 50 */ 386 { CS_AUTHKNOTFOUND, RO, "authknotfound" }, /* 51 */ 387 { CS_AUTHKUNCACHED, RO, "authkuncached" }, /* 52 */ 388 { CS_AUTHKEXPIRED, RO, "authkexpired" }, /* 53 */ 389 { CS_AUTHENCRYPTS, RO, "authencrypts" }, /* 54 */ 390 { CS_AUTHDECRYPTS, RO, "authdecrypts" }, /* 55 */ 391 { CS_AUTHRESET, RO, "authreset" }, /* 56 */ 392 { CS_K_OFFSET, RO, "koffset" }, /* 57 */ 393 { CS_K_FREQ, RO, "kfreq" }, /* 58 */ 394 { CS_K_MAXERR, RO, "kmaxerr" }, /* 59 */ 395 { CS_K_ESTERR, RO, "kesterr" }, /* 60 */ 396 { CS_K_STFLAGS, RO, "kstflags" }, /* 61 */ 397 { CS_K_TIMECONST, RO, "ktimeconst" }, /* 62 */ 398 { CS_K_PRECISION, RO, "kprecis" }, /* 63 */ 399 { CS_K_FREQTOL, RO, "kfreqtol" }, /* 64 */ 400 { CS_K_PPS_FREQ, RO, "kppsfreq" }, /* 65 */ 401 { CS_K_PPS_STABIL, RO, "kppsstab" }, /* 66 */ 402 { CS_K_PPS_JITTER, RO, "kppsjitter" }, /* 67 */ 403 { CS_K_PPS_CALIBDUR, RO, "kppscalibdur" }, /* 68 */ 404 { CS_K_PPS_CALIBS, RO, "kppscalibs" }, /* 69 */ 405 { CS_K_PPS_CALIBERRS, RO, "kppscaliberrs" }, /* 70 */ 406 { CS_K_PPS_JITEXC, RO, "kppsjitexc" }, /* 71 */ 407 { CS_K_PPS_STBEXC, RO, "kppsstbexc" }, /* 72 */ 408 { CS_IOSTATS_RESET, RO, "iostats_reset" }, /* 73 */ 409 { CS_TOTAL_RBUF, RO, "total_rbuf" }, /* 74 */ 410 { CS_FREE_RBUF, RO, "free_rbuf" }, /* 75 */ 411 { CS_USED_RBUF, RO, "used_rbuf" }, /* 76 */ 412 { CS_RBUF_LOWATER, RO, "rbuf_lowater" }, /* 77 */ 413 { CS_IO_DROPPED, RO, "io_dropped" }, /* 78 */ 414 { CS_IO_IGNORED, RO, "io_ignored" }, /* 79 */ 415 { CS_IO_RECEIVED, RO, "io_received" }, /* 80 */ 416 { CS_IO_SENT, RO, "io_sent" }, /* 81 */ 417 { CS_IO_SENDFAILED, RO, "io_sendfailed" }, /* 82 */ 418 { CS_IO_WAKEUPS, RO, "io_wakeups" }, /* 83 */ 419 { CS_IO_GOODWAKEUPS, RO, "io_goodwakeups" }, /* 84 */ 420 { CS_TIMERSTATS_RESET, RO, "timerstats_reset" },/* 85 */ 421 { CS_TIMER_OVERRUNS, RO, "timer_overruns" }, /* 86 */ 422 { CS_TIMER_XMTS, RO, "timer_xmts" }, /* 87 */ 423 { CS_FUZZ, RO, "fuzz" }, /* 88 */ 424 { CS_WANDER_THRESH, RO, "clk_wander_threshold" }, /* 89 */ 425 426 { CS_LEAPSMEARINTV, RO, "leapsmearinterval" }, /* 90 */ 427 { CS_LEAPSMEAROFFS, RO, "leapsmearoffset" }, /* 91 */ 428 429 #ifdef AUTOKEY 430 { CS_FLAGS, RO, "flags" }, /* 1 + CS_MAX_NOAUTOKEY */ 431 { CS_HOST, RO, "host" }, /* 2 + CS_MAX_NOAUTOKEY */ 432 { CS_PUBLIC, RO, "update" }, /* 3 + CS_MAX_NOAUTOKEY */ 433 { CS_CERTIF, RO, "cert" }, /* 4 + CS_MAX_NOAUTOKEY */ 434 { CS_SIGNATURE, RO, "signature" }, /* 5 + CS_MAX_NOAUTOKEY */ 435 { CS_REVTIME, RO, "until" }, /* 6 + CS_MAX_NOAUTOKEY */ 436 { CS_IDENT, RO, "ident" }, /* 7 + CS_MAX_NOAUTOKEY */ 437 { CS_DIGEST, RO, "digest" }, /* 8 + CS_MAX_NOAUTOKEY */ 438 #endif /* AUTOKEY */ 439 { 0, EOV, "" } /* 87/95 */ 440 }; 441 442 static struct ctl_var *ext_sys_var = NULL; 443 444 /* 445 * System variables we print by default (in fuzzball order, 446 * more-or-less) 447 */ 448 static const u_char def_sys_var[] = { 449 CS_VERSION, 450 CS_PROCESSOR, 451 CS_SYSTEM, 452 CS_LEAP, 453 CS_STRATUM, 454 CS_PRECISION, 455 CS_ROOTDELAY, 456 CS_ROOTDISPERSION, 457 CS_REFID, 458 CS_REFTIME, 459 CS_CLOCK, 460 CS_PEERID, 461 CS_POLL, 462 CS_RATE, 463 CS_OFFSET, 464 CS_DRIFT, 465 CS_JITTER, 466 CS_ERROR, 467 CS_STABIL, 468 CS_TAI, 469 CS_LEAPTAB, 470 CS_LEAPEND, 471 CS_LEAPSMEARINTV, 472 CS_LEAPSMEAROFFS, 473 #ifdef AUTOKEY 474 CS_HOST, 475 CS_IDENT, 476 CS_FLAGS, 477 CS_DIGEST, 478 CS_SIGNATURE, 479 CS_PUBLIC, 480 CS_CERTIF, 481 #endif /* AUTOKEY */ 482 0 483 }; 484 485 486 /* 487 * Peer variable list 488 */ 489 static const struct ctl_var peer_var[] = { 490 { 0, PADDING, "" }, /* 0 */ 491 { CP_CONFIG, RO, "config" }, /* 1 */ 492 { CP_AUTHENABLE, RO, "authenable" }, /* 2 */ 493 { CP_AUTHENTIC, RO, "authentic" }, /* 3 */ 494 { CP_SRCADR, RO, "srcadr" }, /* 4 */ 495 { CP_SRCPORT, RO, "srcport" }, /* 5 */ 496 { CP_DSTADR, RO, "dstadr" }, /* 6 */ 497 { CP_DSTPORT, RO, "dstport" }, /* 7 */ 498 { CP_LEAP, RO, "leap" }, /* 8 */ 499 { CP_HMODE, RO, "hmode" }, /* 9 */ 500 { CP_STRATUM, RO, "stratum" }, /* 10 */ 501 { CP_PPOLL, RO, "ppoll" }, /* 11 */ 502 { CP_HPOLL, RO, "hpoll" }, /* 12 */ 503 { CP_PRECISION, RO, "precision" }, /* 13 */ 504 { CP_ROOTDELAY, RO, "rootdelay" }, /* 14 */ 505 { CP_ROOTDISPERSION, RO, "rootdisp" }, /* 15 */ 506 { CP_REFID, RO, "refid" }, /* 16 */ 507 { CP_REFTIME, RO, "reftime" }, /* 17 */ 508 { CP_ORG, RO, "org" }, /* 18 */ 509 { CP_REC, RO, "rec" }, /* 19 */ 510 { CP_XMT, RO, "xleave" }, /* 20 */ 511 { CP_REACH, RO, "reach" }, /* 21 */ 512 { CP_UNREACH, RO, "unreach" }, /* 22 */ 513 { CP_TIMER, RO, "timer" }, /* 23 */ 514 { CP_DELAY, RO, "delay" }, /* 24 */ 515 { CP_OFFSET, RO, "offset" }, /* 25 */ 516 { CP_JITTER, RO, "jitter" }, /* 26 */ 517 { CP_DISPERSION, RO, "dispersion" }, /* 27 */ 518 { CP_KEYID, RO, "keyid" }, /* 28 */ 519 { CP_FILTDELAY, RO, "filtdelay" }, /* 29 */ 520 { CP_FILTOFFSET, RO, "filtoffset" }, /* 30 */ 521 { CP_PMODE, RO, "pmode" }, /* 31 */ 522 { CP_RECEIVED, RO, "received"}, /* 32 */ 523 { CP_SENT, RO, "sent" }, /* 33 */ 524 { CP_FILTERROR, RO, "filtdisp" }, /* 34 */ 525 { CP_FLASH, RO, "flash" }, /* 35 */ 526 { CP_TTL, RO, "ttl" }, /* 36 */ 527 { CP_VARLIST, RO, "peer_var_list" }, /* 37 */ 528 { CP_IN, RO, "in" }, /* 38 */ 529 { CP_OUT, RO, "out" }, /* 39 */ 530 { CP_RATE, RO, "headway" }, /* 40 */ 531 { CP_BIAS, RO, "bias" }, /* 41 */ 532 { CP_SRCHOST, RO, "srchost" }, /* 42 */ 533 { CP_TIMEREC, RO, "timerec" }, /* 43 */ 534 { CP_TIMEREACH, RO, "timereach" }, /* 44 */ 535 { CP_BADAUTH, RO, "badauth" }, /* 45 */ 536 { CP_BOGUSORG, RO, "bogusorg" }, /* 46 */ 537 { CP_OLDPKT, RO, "oldpkt" }, /* 47 */ 538 { CP_SELDISP, RO, "seldisp" }, /* 48 */ 539 { CP_SELBROKEN, RO, "selbroken" }, /* 49 */ 540 { CP_CANDIDATE, RO, "candidate" }, /* 50 */ 541 #ifdef AUTOKEY 542 { CP_FLAGS, RO, "flags" }, /* 1 + CP_MAX_NOAUTOKEY */ 543 { CP_HOST, RO, "host" }, /* 2 + CP_MAX_NOAUTOKEY */ 544 { CP_VALID, RO, "valid" }, /* 3 + CP_MAX_NOAUTOKEY */ 545 { CP_INITSEQ, RO, "initsequence" }, /* 4 + CP_MAX_NOAUTOKEY */ 546 { CP_INITKEY, RO, "initkey" }, /* 5 + CP_MAX_NOAUTOKEY */ 547 { CP_INITTSP, RO, "timestamp" }, /* 6 + CP_MAX_NOAUTOKEY */ 548 { CP_SIGNATURE, RO, "signature" }, /* 7 + CP_MAX_NOAUTOKEY */ 549 { CP_IDENT, RO, "ident" }, /* 8 + CP_MAX_NOAUTOKEY */ 550 #endif /* AUTOKEY */ 551 { 0, EOV, "" } /* 50/58 */ 552 }; 553 554 555 /* 556 * Peer variables we print by default 557 */ 558 static const u_char def_peer_var[] = { 559 CP_SRCADR, 560 CP_SRCPORT, 561 CP_SRCHOST, 562 CP_DSTADR, 563 CP_DSTPORT, 564 CP_OUT, 565 CP_IN, 566 CP_LEAP, 567 CP_STRATUM, 568 CP_PRECISION, 569 CP_ROOTDELAY, 570 CP_ROOTDISPERSION, 571 CP_REFID, 572 CP_REFTIME, 573 CP_REC, 574 CP_REACH, 575 CP_UNREACH, 576 CP_HMODE, 577 CP_PMODE, 578 CP_HPOLL, 579 CP_PPOLL, 580 CP_RATE, 581 CP_FLASH, 582 CP_KEYID, 583 CP_TTL, 584 CP_OFFSET, 585 CP_DELAY, 586 CP_DISPERSION, 587 CP_JITTER, 588 CP_XMT, 589 CP_BIAS, 590 CP_FILTDELAY, 591 CP_FILTOFFSET, 592 CP_FILTERROR, 593 #ifdef AUTOKEY 594 CP_HOST, 595 CP_FLAGS, 596 CP_SIGNATURE, 597 CP_VALID, 598 CP_INITSEQ, 599 CP_IDENT, 600 #endif /* AUTOKEY */ 601 0 602 }; 603 604 605 #ifdef REFCLOCK 606 /* 607 * Clock variable list 608 */ 609 static const struct ctl_var clock_var[] = { 610 { 0, PADDING, "" }, /* 0 */ 611 { CC_TYPE, RO, "type" }, /* 1 */ 612 { CC_TIMECODE, RO, "timecode" }, /* 2 */ 613 { CC_POLL, RO, "poll" }, /* 3 */ 614 { CC_NOREPLY, RO, "noreply" }, /* 4 */ 615 { CC_BADFORMAT, RO, "badformat" }, /* 5 */ 616 { CC_BADDATA, RO, "baddata" }, /* 6 */ 617 { CC_FUDGETIME1, RO, "fudgetime1" }, /* 7 */ 618 { CC_FUDGETIME2, RO, "fudgetime2" }, /* 8 */ 619 { CC_FUDGEVAL1, RO, "stratum" }, /* 9 */ 620 { CC_FUDGEVAL2, RO, "refid" }, /* 10 */ 621 { CC_FLAGS, RO, "flags" }, /* 11 */ 622 { CC_DEVICE, RO, "device" }, /* 12 */ 623 { CC_VARLIST, RO, "clock_var_list" }, /* 13 */ 624 { 0, EOV, "" } /* 14 */ 625 }; 626 627 628 /* 629 * Clock variables printed by default 630 */ 631 static const u_char def_clock_var[] = { 632 CC_DEVICE, 633 CC_TYPE, /* won't be output if device = known */ 634 CC_TIMECODE, 635 CC_POLL, 636 CC_NOREPLY, 637 CC_BADFORMAT, 638 CC_BADDATA, 639 CC_FUDGETIME1, 640 CC_FUDGETIME2, 641 CC_FUDGEVAL1, 642 CC_FUDGEVAL2, 643 CC_FLAGS, 644 0 645 }; 646 #endif 647 648 /* 649 * MRU string constants shared by send_mru_entry() and read_mru_list(). 650 */ 651 static const char addr_fmt[] = "addr.%d"; 652 static const char last_fmt[] = "last.%d"; 653 654 /* 655 * System and processor definitions. 656 */ 657 #ifndef HAVE_UNAME 658 # ifndef STR_SYSTEM 659 # define STR_SYSTEM "UNIX" 660 # endif 661 # ifndef STR_PROCESSOR 662 # define STR_PROCESSOR "unknown" 663 # endif 664 665 static const char str_system[] = STR_SYSTEM; 666 static const char str_processor[] = STR_PROCESSOR; 667 #else 668 # include <sys/utsname.h> 669 static struct utsname utsnamebuf; 670 #endif /* HAVE_UNAME */ 671 672 /* 673 * Trap structures. We only allow a few of these, and send a copy of 674 * each async message to each live one. Traps time out after an hour, it 675 * is up to the trap receipient to keep resetting it to avoid being 676 * timed out. 677 */ 678 /* ntp_request.c */ 679 struct ctl_trap ctl_traps[CTL_MAXTRAPS]; 680 int num_ctl_traps; 681 682 /* 683 * Type bits, for ctlsettrap() call. 684 */ 685 #define TRAP_TYPE_CONFIG 0 /* used by configuration code */ 686 #define TRAP_TYPE_PRIO 1 /* priority trap */ 687 #define TRAP_TYPE_NONPRIO 2 /* nonpriority trap */ 688 689 690 /* 691 * List relating reference clock types to control message time sources. 692 * Index by the reference clock type. This list will only be used iff 693 * the reference clock driver doesn't set peer->sstclktype to something 694 * different than CTL_SST_TS_UNSPEC. 695 */ 696 #ifdef REFCLOCK 697 static const u_char clocktypes[] = { 698 CTL_SST_TS_NTP, /* REFCLK_NONE (0) */ 699 CTL_SST_TS_LOCAL, /* REFCLK_LOCALCLOCK (1) */ 700 CTL_SST_TS_UHF, /* deprecated REFCLK_GPS_TRAK (2) */ 701 CTL_SST_TS_HF, /* REFCLK_WWV_PST (3) */ 702 CTL_SST_TS_LF, /* REFCLK_WWVB_SPECTRACOM (4) */ 703 CTL_SST_TS_UHF, /* REFCLK_TRUETIME (5) */ 704 CTL_SST_TS_UHF, /* REFCLK_IRIG_AUDIO (6) */ 705 CTL_SST_TS_HF, /* REFCLK_CHU (7) */ 706 CTL_SST_TS_LF, /* REFCLOCK_PARSE (default) (8) */ 707 CTL_SST_TS_LF, /* REFCLK_GPS_MX4200 (9) */ 708 CTL_SST_TS_UHF, /* REFCLK_GPS_AS2201 (10) */ 709 CTL_SST_TS_UHF, /* REFCLK_GPS_ARBITER (11) */ 710 CTL_SST_TS_UHF, /* REFCLK_IRIG_TPRO (12) */ 711 CTL_SST_TS_ATOM, /* REFCLK_ATOM_LEITCH (13) */ 712 CTL_SST_TS_LF, /* deprecated REFCLK_MSF_EES (14) */ 713 CTL_SST_TS_NTP, /* not used (15) */ 714 CTL_SST_TS_UHF, /* REFCLK_IRIG_BANCOMM (16) */ 715 CTL_SST_TS_UHF, /* REFCLK_GPS_DATU (17) */ 716 CTL_SST_TS_TELEPHONE, /* REFCLK_NIST_ACTS (18) */ 717 CTL_SST_TS_HF, /* REFCLK_WWV_HEATH (19) */ 718 CTL_SST_TS_UHF, /* REFCLK_GPS_NMEA (20) */ 719 CTL_SST_TS_UHF, /* REFCLK_GPS_VME (21) */ 720 CTL_SST_TS_ATOM, /* REFCLK_ATOM_PPS (22) */ 721 CTL_SST_TS_NTP, /* not used (23) */ 722 CTL_SST_TS_NTP, /* not used (24) */ 723 CTL_SST_TS_NTP, /* not used (25) */ 724 CTL_SST_TS_UHF, /* REFCLK_GPS_HP (26) */ 725 CTL_SST_TS_LF, /* REFCLK_ARCRON_MSF (27) */ 726 CTL_SST_TS_UHF, /* REFCLK_SHM (28) */ 727 CTL_SST_TS_UHF, /* REFCLK_PALISADE (29) */ 728 CTL_SST_TS_UHF, /* REFCLK_ONCORE (30) */ 729 CTL_SST_TS_UHF, /* REFCLK_JUPITER (31) */ 730 CTL_SST_TS_LF, /* REFCLK_CHRONOLOG (32) */ 731 CTL_SST_TS_LF, /* REFCLK_DUMBCLOCK (33) */ 732 CTL_SST_TS_LF, /* REFCLK_ULINK (34) */ 733 CTL_SST_TS_LF, /* REFCLK_PCF (35) */ 734 CTL_SST_TS_HF, /* REFCLK_WWV (36) */ 735 CTL_SST_TS_LF, /* REFCLK_FG (37) */ 736 CTL_SST_TS_UHF, /* REFCLK_HOPF_SERIAL (38) */ 737 CTL_SST_TS_UHF, /* REFCLK_HOPF_PCI (39) */ 738 CTL_SST_TS_LF, /* REFCLK_JJY (40) */ 739 CTL_SST_TS_UHF, /* REFCLK_TT560 (41) */ 740 CTL_SST_TS_UHF, /* REFCLK_ZYFER (42) */ 741 CTL_SST_TS_UHF, /* REFCLK_RIPENCC (43) */ 742 CTL_SST_TS_UHF, /* REFCLK_NEOCLOCK4X (44) */ 743 CTL_SST_TS_UHF, /* REFCLK_TSYNCPCI (45) */ 744 CTL_SST_TS_UHF /* REFCLK_GPSDJSON (46) */ 745 }; 746 #endif /* REFCLOCK */ 747 748 749 /* 750 * Keyid used for authenticating write requests. 751 */ 752 keyid_t ctl_auth_keyid; 753 754 /* 755 * We keep track of the last error reported by the system internally 756 */ 757 static u_char ctl_sys_last_event; 758 static u_char ctl_sys_num_events; 759 760 761 /* 762 * Statistic counters to keep track of requests and responses. 763 */ 764 u_long ctltimereset; /* time stats reset */ 765 u_long numctlreq; /* number of requests we've received */ 766 u_long numctlbadpkts; /* number of bad control packets */ 767 u_long numctlresponses; /* number of resp packets sent with data */ 768 u_long numctlfrags; /* number of fragments sent */ 769 u_long numctlerrors; /* number of error responses sent */ 770 u_long numctltooshort; /* number of too short input packets */ 771 u_long numctlinputresp; /* number of responses on input */ 772 u_long numctlinputfrag; /* number of fragments on input */ 773 u_long numctlinputerr; /* number of input pkts with err bit set */ 774 u_long numctlbadoffset; /* number of input pkts with nonzero offset */ 775 u_long numctlbadversion; /* number of input pkts with unknown version */ 776 u_long numctldatatooshort; /* data too short for count */ 777 u_long numctlbadop; /* bad op code found in packet */ 778 u_long numasyncmsgs; /* number of async messages we've sent */ 779 780 /* 781 * Response packet used by these routines. Also some state information 782 * so that we can handle packet formatting within a common set of 783 * subroutines. Note we try to enter data in place whenever possible, 784 * but the need to set the more bit correctly means we occasionally 785 * use the extra buffer and copy. 786 */ 787 static struct ntp_control rpkt; 788 static u_char res_version; 789 static u_char res_opcode; 790 static associd_t res_associd; 791 static u_short res_frags; /* datagrams in this response */ 792 static int res_offset; /* offset of payload in response */ 793 static u_char * datapt; 794 static u_char * dataend; 795 static int datalinelen; 796 static int datasent; /* flag to avoid initial ", " */ 797 static int datanotbinflag; 798 static sockaddr_u *rmt_addr; 799 static struct interface *lcl_inter; 800 801 static u_char res_authenticate; 802 static u_char res_authokay; 803 static keyid_t res_keyid; 804 805 #define MAXDATALINELEN (72) 806 807 static u_char res_async; /* sending async trap response? */ 808 809 /* 810 * Pointers for saving state when decoding request packets 811 */ 812 static char *reqpt; 813 static char *reqend; 814 815 #ifndef MIN 816 #define MIN(a, b) (((a) <= (b)) ? (a) : (b)) 817 #endif 818 819 /* 820 * init_control - initialize request data 821 */ 822 void 823 init_control(void) 824 { 825 size_t i; 826 827 #ifdef HAVE_UNAME 828 uname(&utsnamebuf); 829 #endif /* HAVE_UNAME */ 830 831 ctl_clr_stats(); 832 833 ctl_auth_keyid = 0; 834 ctl_sys_last_event = EVNT_UNSPEC; 835 ctl_sys_num_events = 0; 836 837 num_ctl_traps = 0; 838 for (i = 0; i < COUNTOF(ctl_traps); i++) 839 ctl_traps[i].tr_flags = 0; 840 } 841 842 843 /* 844 * ctl_error - send an error response for the current request 845 */ 846 static void 847 ctl_error( 848 u_char errcode 849 ) 850 { 851 int maclen; 852 853 numctlerrors++; 854 DPRINTF(3, ("sending control error %u\n", errcode)); 855 856 /* 857 * Fill in the fields. We assume rpkt.sequence and rpkt.associd 858 * have already been filled in. 859 */ 860 rpkt.r_m_e_op = (u_char)CTL_RESPONSE | CTL_ERROR | 861 (res_opcode & CTL_OP_MASK); 862 rpkt.status = htons((u_short)(errcode << 8) & 0xff00); 863 rpkt.count = 0; 864 865 /* 866 * send packet and bump counters 867 */ 868 if (res_authenticate && sys_authenticate) { 869 maclen = authencrypt(res_keyid, (u_int32 *)&rpkt, 870 CTL_HEADER_LEN); 871 sendpkt(rmt_addr, lcl_inter, -2, (void *)&rpkt, 872 CTL_HEADER_LEN + maclen); 873 } else 874 sendpkt(rmt_addr, lcl_inter, -3, (void *)&rpkt, 875 CTL_HEADER_LEN); 876 } 877 878 /* 879 * save_config - Implements ntpq -c "saveconfig <filename>" 880 * Writes current configuration including any runtime 881 * changes by ntpq's :config or config-from-file 882 */ 883 void 884 save_config( 885 struct recvbuf *rbufp, 886 int restrict_mask 887 ) 888 { 889 /* block directory traversal by searching for characters that 890 * indicate directory components in a file path. 891 * 892 * Conceptually we should be searching for DIRSEP in filename, 893 * however Windows actually recognizes both forward and 894 * backslashes as equivalent directory separators at the API 895 * level. On POSIX systems we could allow '\\' but such 896 * filenames are tricky to manipulate from a shell, so just 897 * reject both types of slashes on all platforms. 898 */ 899 /* TALOS-CAN-0062: block directory traversal for VMS, too */ 900 static const char * illegal_in_filename = 901 #if defined(VMS) 902 ":[]" /* do not allow drive and path components here */ 903 #elif defined(SYS_WINNT) 904 ":\\/" /* path and drive separators */ 905 #else 906 "\\/" /* separator and critical char for POSIX */ 907 #endif 908 ; 909 910 911 char reply[128]; 912 #ifdef SAVECONFIG 913 char filespec[128]; 914 char filename[128]; 915 char fullpath[512]; 916 const char savedconfig_eq[] = "savedconfig="; 917 char savedconfig[sizeof(savedconfig_eq) + sizeof(filename)]; 918 time_t now; 919 int fd; 920 FILE *fptr; 921 #endif 922 923 if (RES_NOMODIFY & restrict_mask) { 924 snprintf(reply, sizeof(reply), 925 "saveconfig prohibited by restrict ... nomodify"); 926 ctl_putdata(reply, strlen(reply), 0); 927 ctl_flushpkt(0); 928 NLOG(NLOG_SYSINFO) 929 msyslog(LOG_NOTICE, 930 "saveconfig from %s rejected due to nomodify restriction", 931 stoa(&rbufp->recv_srcadr)); 932 sys_restricted++; 933 return; 934 } 935 936 #ifdef SAVECONFIG 937 if (NULL == saveconfigdir) { 938 snprintf(reply, sizeof(reply), 939 "saveconfig prohibited, no saveconfigdir configured"); 940 ctl_putdata(reply, strlen(reply), 0); 941 ctl_flushpkt(0); 942 NLOG(NLOG_SYSINFO) 943 msyslog(LOG_NOTICE, 944 "saveconfig from %s rejected, no saveconfigdir", 945 stoa(&rbufp->recv_srcadr)); 946 return; 947 } 948 949 if (0 == reqend - reqpt) 950 return; 951 952 strlcpy(filespec, reqpt, sizeof(filespec)); 953 time(&now); 954 955 /* 956 * allow timestamping of the saved config filename with 957 * strftime() format such as: 958 * ntpq -c "saveconfig ntp-%Y%m%d-%H%M%S.conf" 959 * XXX: Nice feature, but not too safe. 960 */ 961 if (0 == strftime(filename, sizeof(filename), filespec, 962 localtime(&now))) 963 strlcpy(filename, filespec, sizeof(filename)); 964 965 /* block directory/drive traversal */ 966 /* TALOS-CAN-0062: block directory traversal for VMS, too */ 967 if (NULL != strpbrk(filename, illegal_in_filename)) { 968 snprintf(reply, sizeof(reply), 969 "saveconfig does not allow directory in filename"); 970 ctl_putdata(reply, strlen(reply), 0); 971 ctl_flushpkt(0); 972 msyslog(LOG_NOTICE, 973 "saveconfig with path from %s rejected", 974 stoa(&rbufp->recv_srcadr)); 975 return; 976 } 977 978 snprintf(fullpath, sizeof(fullpath), "%s%s", 979 saveconfigdir, filename); 980 981 fd = open(fullpath, O_CREAT | O_TRUNC | O_WRONLY, 982 S_IRUSR | S_IWUSR); 983 if (-1 == fd) 984 fptr = NULL; 985 else 986 fptr = fdopen(fd, "w"); 987 988 if (NULL == fptr || -1 == dump_all_config_trees(fptr, 1)) { 989 snprintf(reply, sizeof(reply), 990 "Unable to save configuration to file %s", 991 filename); 992 msyslog(LOG_ERR, 993 "saveconfig %s from %s failed", filename, 994 stoa(&rbufp->recv_srcadr)); 995 } else { 996 snprintf(reply, sizeof(reply), 997 "Configuration saved to %s", filename); 998 msyslog(LOG_NOTICE, 999 "Configuration saved to %s (requested by %s)", 1000 fullpath, stoa(&rbufp->recv_srcadr)); 1001 /* 1002 * save the output filename in system variable 1003 * savedconfig, retrieved with: 1004 * ntpq -c "rv 0 savedconfig" 1005 */ 1006 snprintf(savedconfig, sizeof(savedconfig), "%s%s", 1007 savedconfig_eq, filename); 1008 set_sys_var(savedconfig, strlen(savedconfig) + 1, RO); 1009 } 1010 1011 if (NULL != fptr) 1012 fclose(fptr); 1013 #else /* !SAVECONFIG follows */ 1014 snprintf(reply, sizeof(reply), 1015 "saveconfig unavailable, configured with --disable-saveconfig"); 1016 #endif 1017 1018 ctl_putdata(reply, strlen(reply), 0); 1019 ctl_flushpkt(0); 1020 } 1021 1022 1023 /* 1024 * process_control - process an incoming control message 1025 */ 1026 void 1027 process_control( 1028 struct recvbuf *rbufp, 1029 int restrict_mask 1030 ) 1031 { 1032 struct ntp_control *pkt; 1033 int req_count; 1034 int req_data; 1035 const struct ctl_proc *cc; 1036 keyid_t *pkid; 1037 int properlen; 1038 size_t maclen; 1039 1040 DPRINTF(3, ("in process_control()\n")); 1041 1042 /* 1043 * Save the addresses for error responses 1044 */ 1045 numctlreq++; 1046 rmt_addr = &rbufp->recv_srcadr; 1047 lcl_inter = rbufp->dstadr; 1048 pkt = (struct ntp_control *)&rbufp->recv_pkt; 1049 1050 /* 1051 * If the length is less than required for the header, or 1052 * it is a response or a fragment, ignore this. 1053 */ 1054 if (rbufp->recv_length < (int)CTL_HEADER_LEN 1055 || (CTL_RESPONSE | CTL_MORE | CTL_ERROR) & pkt->r_m_e_op 1056 || pkt->offset != 0) { 1057 DPRINTF(1, ("invalid format in control packet\n")); 1058 if (rbufp->recv_length < (int)CTL_HEADER_LEN) 1059 numctltooshort++; 1060 if (CTL_RESPONSE & pkt->r_m_e_op) 1061 numctlinputresp++; 1062 if (CTL_MORE & pkt->r_m_e_op) 1063 numctlinputfrag++; 1064 if (CTL_ERROR & pkt->r_m_e_op) 1065 numctlinputerr++; 1066 if (pkt->offset != 0) 1067 numctlbadoffset++; 1068 return; 1069 } 1070 res_version = PKT_VERSION(pkt->li_vn_mode); 1071 if (res_version > NTP_VERSION || res_version < NTP_OLDVERSION) { 1072 DPRINTF(1, ("unknown version %d in control packet\n", 1073 res_version)); 1074 numctlbadversion++; 1075 return; 1076 } 1077 1078 /* 1079 * Pull enough data from the packet to make intelligent 1080 * responses 1081 */ 1082 rpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap, res_version, 1083 MODE_CONTROL); 1084 res_opcode = pkt->r_m_e_op; 1085 rpkt.sequence = pkt->sequence; 1086 rpkt.associd = pkt->associd; 1087 rpkt.status = 0; 1088 res_frags = 1; 1089 res_offset = 0; 1090 res_associd = htons(pkt->associd); 1091 res_async = FALSE; 1092 res_authenticate = FALSE; 1093 res_keyid = 0; 1094 res_authokay = FALSE; 1095 req_count = (int)ntohs(pkt->count); 1096 datanotbinflag = FALSE; 1097 datalinelen = 0; 1098 datasent = 0; 1099 datapt = rpkt.u.data; 1100 dataend = &rpkt.u.data[CTL_MAX_DATA_LEN]; 1101 1102 if ((rbufp->recv_length & 0x3) != 0) 1103 DPRINTF(3, ("Control packet length %d unrounded\n", 1104 rbufp->recv_length)); 1105 1106 /* 1107 * We're set up now. Make sure we've got at least enough 1108 * incoming data space to match the count. 1109 */ 1110 req_data = rbufp->recv_length - CTL_HEADER_LEN; 1111 if (req_data < req_count || rbufp->recv_length & 0x3) { 1112 ctl_error(CERR_BADFMT); 1113 numctldatatooshort++; 1114 return; 1115 } 1116 1117 properlen = req_count + CTL_HEADER_LEN; 1118 /* round up proper len to a 8 octet boundary */ 1119 1120 properlen = (properlen + 7) & ~7; 1121 maclen = rbufp->recv_length - properlen; 1122 if ((rbufp->recv_length & 3) == 0 && 1123 maclen >= MIN_MAC_LEN && maclen <= MAX_MAC_LEN && 1124 sys_authenticate) { 1125 res_authenticate = TRUE; 1126 pkid = (void *)((char *)pkt + properlen); 1127 res_keyid = ntohl(*pkid); 1128 DPRINTF(3, ("recv_len %d, properlen %d, wants auth with keyid %08x, MAC length=%zu\n", 1129 rbufp->recv_length, properlen, res_keyid, 1130 maclen)); 1131 1132 if (!authistrusted(res_keyid)) 1133 DPRINTF(3, ("invalid keyid %08x\n", res_keyid)); 1134 else if (authdecrypt(res_keyid, (u_int32 *)pkt, 1135 rbufp->recv_length - maclen, 1136 maclen)) { 1137 res_authokay = TRUE; 1138 DPRINTF(3, ("authenticated okay\n")); 1139 } else { 1140 res_keyid = 0; 1141 DPRINTF(3, ("authentication failed\n")); 1142 } 1143 } 1144 1145 /* 1146 * Set up translate pointers 1147 */ 1148 reqpt = (char *)pkt->u.data; 1149 reqend = reqpt + req_count; 1150 1151 /* 1152 * Look for the opcode processor 1153 */ 1154 for (cc = control_codes; cc->control_code != NO_REQUEST; cc++) { 1155 if (cc->control_code == res_opcode) { 1156 DPRINTF(3, ("opcode %d, found command handler\n", 1157 res_opcode)); 1158 if (cc->flags == AUTH 1159 && (!res_authokay 1160 || res_keyid != ctl_auth_keyid)) { 1161 ctl_error(CERR_PERMISSION); 1162 return; 1163 } 1164 (cc->handler)(rbufp, restrict_mask); 1165 return; 1166 } 1167 } 1168 1169 /* 1170 * Can't find this one, return an error. 1171 */ 1172 numctlbadop++; 1173 ctl_error(CERR_BADOP); 1174 return; 1175 } 1176 1177 1178 /* 1179 * ctlpeerstatus - return a status word for this peer 1180 */ 1181 u_short 1182 ctlpeerstatus( 1183 register struct peer *p 1184 ) 1185 { 1186 u_short status; 1187 1188 status = p->status; 1189 if (FLAG_CONFIG & p->flags) 1190 status |= CTL_PST_CONFIG; 1191 if (p->keyid) 1192 status |= CTL_PST_AUTHENABLE; 1193 if (FLAG_AUTHENTIC & p->flags) 1194 status |= CTL_PST_AUTHENTIC; 1195 if (p->reach) 1196 status |= CTL_PST_REACH; 1197 if (MDF_TXONLY_MASK & p->cast_flags) 1198 status |= CTL_PST_BCAST; 1199 1200 return CTL_PEER_STATUS(status, p->num_events, p->last_event); 1201 } 1202 1203 1204 /* 1205 * ctlclkstatus - return a status word for this clock 1206 */ 1207 #ifdef REFCLOCK 1208 static u_short 1209 ctlclkstatus( 1210 struct refclockstat *pcs 1211 ) 1212 { 1213 return CTL_PEER_STATUS(0, pcs->lastevent, pcs->currentstatus); 1214 } 1215 #endif 1216 1217 1218 /* 1219 * ctlsysstatus - return the system status word 1220 */ 1221 u_short 1222 ctlsysstatus(void) 1223 { 1224 register u_char this_clock; 1225 1226 this_clock = CTL_SST_TS_UNSPEC; 1227 #ifdef REFCLOCK 1228 if (sys_peer != NULL) { 1229 if (CTL_SST_TS_UNSPEC != sys_peer->sstclktype) 1230 this_clock = sys_peer->sstclktype; 1231 else if (sys_peer->refclktype < COUNTOF(clocktypes)) 1232 this_clock = clocktypes[sys_peer->refclktype]; 1233 } 1234 #else /* REFCLOCK */ 1235 if (sys_peer != 0) 1236 this_clock = CTL_SST_TS_NTP; 1237 #endif /* REFCLOCK */ 1238 return CTL_SYS_STATUS(sys_leap, this_clock, ctl_sys_num_events, 1239 ctl_sys_last_event); 1240 } 1241 1242 1243 /* 1244 * ctl_flushpkt - write out the current packet and prepare 1245 * another if necessary. 1246 */ 1247 static void 1248 ctl_flushpkt( 1249 u_char more 1250 ) 1251 { 1252 size_t i; 1253 int dlen; 1254 int sendlen; 1255 int maclen; 1256 int totlen; 1257 keyid_t keyid; 1258 1259 dlen = datapt - rpkt.u.data; 1260 if (!more && datanotbinflag && dlen + 2 < CTL_MAX_DATA_LEN) { 1261 /* 1262 * Big hack, output a trailing \r\n 1263 */ 1264 *datapt++ = '\r'; 1265 *datapt++ = '\n'; 1266 dlen += 2; 1267 } 1268 sendlen = dlen + CTL_HEADER_LEN; 1269 1270 /* 1271 * Pad to a multiple of 32 bits 1272 */ 1273 while (sendlen & 0x3) { 1274 *datapt++ = '\0'; 1275 sendlen++; 1276 } 1277 1278 /* 1279 * Fill in the packet with the current info 1280 */ 1281 rpkt.r_m_e_op = CTL_RESPONSE | more | 1282 (res_opcode & CTL_OP_MASK); 1283 rpkt.count = htons((u_short)dlen); 1284 rpkt.offset = htons((u_short)res_offset); 1285 if (res_async) { 1286 for (i = 0; i < COUNTOF(ctl_traps); i++) { 1287 if (TRAP_INUSE & ctl_traps[i].tr_flags) { 1288 rpkt.li_vn_mode = 1289 PKT_LI_VN_MODE( 1290 sys_leap, 1291 ctl_traps[i].tr_version, 1292 MODE_CONTROL); 1293 rpkt.sequence = 1294 htons(ctl_traps[i].tr_sequence); 1295 sendpkt(&ctl_traps[i].tr_addr, 1296 ctl_traps[i].tr_localaddr, -4, 1297 (struct pkt *)&rpkt, sendlen); 1298 if (!more) 1299 ctl_traps[i].tr_sequence++; 1300 numasyncmsgs++; 1301 } 1302 } 1303 } else { 1304 if (res_authenticate && sys_authenticate) { 1305 totlen = sendlen; 1306 /* 1307 * If we are going to authenticate, then there 1308 * is an additional requirement that the MAC 1309 * begin on a 64 bit boundary. 1310 */ 1311 while (totlen & 7) { 1312 *datapt++ = '\0'; 1313 totlen++; 1314 } 1315 keyid = htonl(res_keyid); 1316 memcpy(datapt, &keyid, sizeof(keyid)); 1317 maclen = authencrypt(res_keyid, 1318 (u_int32 *)&rpkt, totlen); 1319 sendpkt(rmt_addr, lcl_inter, -5, 1320 (struct pkt *)&rpkt, totlen + maclen); 1321 } else { 1322 sendpkt(rmt_addr, lcl_inter, -6, 1323 (struct pkt *)&rpkt, sendlen); 1324 } 1325 if (more) 1326 numctlfrags++; 1327 else 1328 numctlresponses++; 1329 } 1330 1331 /* 1332 * Set us up for another go around. 1333 */ 1334 res_frags++; 1335 res_offset += dlen; 1336 datapt = rpkt.u.data; 1337 } 1338 1339 1340 /* 1341 * ctl_putdata - write data into the packet, fragmenting and starting 1342 * another if this one is full. 1343 */ 1344 static void 1345 ctl_putdata( 1346 const char *dp, 1347 unsigned int dlen, 1348 int bin /* set to 1 when data is binary */ 1349 ) 1350 { 1351 int overhead; 1352 unsigned int currentlen; 1353 1354 overhead = 0; 1355 if (!bin) { 1356 datanotbinflag = TRUE; 1357 overhead = 3; 1358 if (datasent) { 1359 *datapt++ = ','; 1360 datalinelen++; 1361 if ((dlen + datalinelen + 1) >= MAXDATALINELEN) { 1362 *datapt++ = '\r'; 1363 *datapt++ = '\n'; 1364 datalinelen = 0; 1365 } else { 1366 *datapt++ = ' '; 1367 datalinelen++; 1368 } 1369 } 1370 } 1371 1372 /* 1373 * Save room for trailing junk 1374 */ 1375 while (dlen + overhead + datapt > dataend) { 1376 /* 1377 * Not enough room in this one, flush it out. 1378 */ 1379 currentlen = MIN(dlen, (unsigned int)(dataend - datapt)); 1380 1381 memcpy(datapt, dp, currentlen); 1382 1383 datapt += currentlen; 1384 dp += currentlen; 1385 dlen -= currentlen; 1386 datalinelen += currentlen; 1387 1388 ctl_flushpkt(CTL_MORE); 1389 } 1390 1391 memcpy(datapt, dp, dlen); 1392 datapt += dlen; 1393 datalinelen += dlen; 1394 datasent = TRUE; 1395 } 1396 1397 1398 /* 1399 * ctl_putstr - write a tagged string into the response packet 1400 * in the form: 1401 * 1402 * tag="data" 1403 * 1404 * len is the data length excluding the NUL terminator, 1405 * as in ctl_putstr("var", "value", strlen("value")); 1406 */ 1407 static void 1408 ctl_putstr( 1409 const char * tag, 1410 const char * data, 1411 size_t len 1412 ) 1413 { 1414 char buffer[512]; 1415 char *cp; 1416 size_t tl; 1417 1418 tl = strlen(tag); 1419 memcpy(buffer, tag, tl); 1420 cp = buffer + tl; 1421 if (len > 0) { 1422 INSIST(tl + 3 + len <= sizeof(buffer)); 1423 *cp++ = '='; 1424 *cp++ = '"'; 1425 memcpy(cp, data, len); 1426 cp += len; 1427 *cp++ = '"'; 1428 } 1429 ctl_putdata(buffer, (u_int)(cp - buffer), 0); 1430 } 1431 1432 1433 /* 1434 * ctl_putunqstr - write a tagged string into the response packet 1435 * in the form: 1436 * 1437 * tag=data 1438 * 1439 * len is the data length excluding the NUL terminator. 1440 * data must not contain a comma or whitespace. 1441 */ 1442 static void 1443 ctl_putunqstr( 1444 const char * tag, 1445 const char * data, 1446 size_t len 1447 ) 1448 { 1449 char buffer[512]; 1450 char *cp; 1451 size_t tl; 1452 1453 tl = strlen(tag); 1454 memcpy(buffer, tag, tl); 1455 cp = buffer + tl; 1456 if (len > 0) { 1457 INSIST(tl + 1 + len <= sizeof(buffer)); 1458 *cp++ = '='; 1459 memcpy(cp, data, len); 1460 cp += len; 1461 } 1462 ctl_putdata(buffer, (u_int)(cp - buffer), 0); 1463 } 1464 1465 1466 /* 1467 * ctl_putdblf - write a tagged, signed double into the response packet 1468 */ 1469 static void 1470 ctl_putdblf( 1471 const char * tag, 1472 int use_f, 1473 int precision, 1474 double d 1475 ) 1476 { 1477 char *cp; 1478 const char *cq; 1479 char buffer[200]; 1480 1481 cp = buffer; 1482 cq = tag; 1483 while (*cq != '\0') 1484 *cp++ = *cq++; 1485 *cp++ = '='; 1486 INSIST((size_t)(cp - buffer) < sizeof(buffer)); 1487 snprintf(cp, sizeof(buffer) - (cp - buffer), use_f ? "%.*f" : "%.*g", 1488 precision, d); 1489 cp += strlen(cp); 1490 ctl_putdata(buffer, (unsigned)(cp - buffer), 0); 1491 } 1492 1493 /* 1494 * ctl_putuint - write a tagged unsigned integer into the response 1495 */ 1496 static void 1497 ctl_putuint( 1498 const char *tag, 1499 u_long uval 1500 ) 1501 { 1502 register char *cp; 1503 register const char *cq; 1504 char buffer[200]; 1505 1506 cp = buffer; 1507 cq = tag; 1508 while (*cq != '\0') 1509 *cp++ = *cq++; 1510 1511 *cp++ = '='; 1512 INSIST((cp - buffer) < (int)sizeof(buffer)); 1513 snprintf(cp, sizeof(buffer) - (cp - buffer), "%lu", uval); 1514 cp += strlen(cp); 1515 ctl_putdata(buffer, (unsigned)( cp - buffer ), 0); 1516 } 1517 1518 /* 1519 * ctl_putcal - write a decoded calendar data into the response 1520 */ 1521 static void 1522 ctl_putcal( 1523 const char *tag, 1524 const struct calendar *pcal 1525 ) 1526 { 1527 char buffer[100]; 1528 unsigned numch; 1529 1530 numch = snprintf(buffer, sizeof(buffer), 1531 "%s=%04d%02d%02d%02d%02d", 1532 tag, 1533 pcal->year, 1534 pcal->month, 1535 pcal->monthday, 1536 pcal->hour, 1537 pcal->minute 1538 ); 1539 INSIST(numch < sizeof(buffer)); 1540 ctl_putdata(buffer, numch, 0); 1541 1542 return; 1543 } 1544 1545 /* 1546 * ctl_putfs - write a decoded filestamp into the response 1547 */ 1548 static void 1549 ctl_putfs( 1550 const char *tag, 1551 tstamp_t uval 1552 ) 1553 { 1554 register char *cp; 1555 register const char *cq; 1556 char buffer[200]; 1557 struct tm *tm = NULL; 1558 time_t fstamp; 1559 1560 cp = buffer; 1561 cq = tag; 1562 while (*cq != '\0') 1563 *cp++ = *cq++; 1564 1565 *cp++ = '='; 1566 fstamp = uval - JAN_1970; 1567 tm = gmtime(&fstamp); 1568 if (NULL == tm) 1569 return; 1570 INSIST((cp - buffer) < (int)sizeof(buffer)); 1571 snprintf(cp, sizeof(buffer) - (cp - buffer), 1572 "%04d%02d%02d%02d%02d", tm->tm_year + 1900, 1573 tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min); 1574 cp += strlen(cp); 1575 ctl_putdata(buffer, (unsigned)( cp - buffer ), 0); 1576 } 1577 1578 1579 /* 1580 * ctl_puthex - write a tagged unsigned integer, in hex, into the 1581 * response 1582 */ 1583 static void 1584 ctl_puthex( 1585 const char *tag, 1586 u_long uval 1587 ) 1588 { 1589 register char *cp; 1590 register const char *cq; 1591 char buffer[200]; 1592 1593 cp = buffer; 1594 cq = tag; 1595 while (*cq != '\0') 1596 *cp++ = *cq++; 1597 1598 *cp++ = '='; 1599 INSIST((cp - buffer) < (int)sizeof(buffer)); 1600 snprintf(cp, sizeof(buffer) - (cp - buffer), "0x%lx", uval); 1601 cp += strlen(cp); 1602 ctl_putdata(buffer,(unsigned)( cp - buffer ), 0); 1603 } 1604 1605 1606 /* 1607 * ctl_putint - write a tagged signed integer into the response 1608 */ 1609 static void 1610 ctl_putint( 1611 const char *tag, 1612 long ival 1613 ) 1614 { 1615 register char *cp; 1616 register const char *cq; 1617 char buffer[200]; 1618 1619 cp = buffer; 1620 cq = tag; 1621 while (*cq != '\0') 1622 *cp++ = *cq++; 1623 1624 *cp++ = '='; 1625 INSIST((cp - buffer) < (int)sizeof(buffer)); 1626 snprintf(cp, sizeof(buffer) - (cp - buffer), "%ld", ival); 1627 cp += strlen(cp); 1628 ctl_putdata(buffer, (unsigned)( cp - buffer ), 0); 1629 } 1630 1631 1632 /* 1633 * ctl_putts - write a tagged timestamp, in hex, into the response 1634 */ 1635 static void 1636 ctl_putts( 1637 const char *tag, 1638 l_fp *ts 1639 ) 1640 { 1641 register char *cp; 1642 register const char *cq; 1643 char buffer[200]; 1644 1645 cp = buffer; 1646 cq = tag; 1647 while (*cq != '\0') 1648 *cp++ = *cq++; 1649 1650 *cp++ = '='; 1651 INSIST((size_t)(cp - buffer) < sizeof(buffer)); 1652 snprintf(cp, sizeof(buffer) - (cp - buffer), "0x%08x.%08x", 1653 (u_int)ts->l_ui, (u_int)ts->l_uf); 1654 cp += strlen(cp); 1655 ctl_putdata(buffer, (unsigned)( cp - buffer ), 0); 1656 } 1657 1658 1659 /* 1660 * ctl_putadr - write an IP address into the response 1661 */ 1662 static void 1663 ctl_putadr( 1664 const char *tag, 1665 u_int32 addr32, 1666 sockaddr_u *addr 1667 ) 1668 { 1669 register char *cp; 1670 register const char *cq; 1671 char buffer[200]; 1672 1673 cp = buffer; 1674 cq = tag; 1675 while (*cq != '\0') 1676 *cp++ = *cq++; 1677 1678 *cp++ = '='; 1679 if (NULL == addr) 1680 cq = numtoa(addr32); 1681 else 1682 cq = stoa(addr); 1683 INSIST((cp - buffer) < (int)sizeof(buffer)); 1684 snprintf(cp, sizeof(buffer) - (cp - buffer), "%s", cq); 1685 cp += strlen(cp); 1686 ctl_putdata(buffer, (unsigned)(cp - buffer), 0); 1687 } 1688 1689 1690 /* 1691 * ctl_putrefid - send a u_int32 refid as printable text 1692 */ 1693 static void 1694 ctl_putrefid( 1695 const char * tag, 1696 u_int32 refid 1697 ) 1698 { 1699 char output[16]; 1700 char * optr; 1701 char * oplim; 1702 char * iptr; 1703 char * iplim; 1704 char * past_eq; 1705 1706 optr = output; 1707 oplim = output + sizeof(output); 1708 while (optr < oplim && '\0' != *tag) 1709 *optr++ = *tag++; 1710 if (optr < oplim) { 1711 *optr++ = '='; 1712 past_eq = optr; 1713 } 1714 if (!(optr < oplim)) 1715 return; 1716 iptr = (char *)&refid; 1717 iplim = iptr + sizeof(refid); 1718 for ( ; optr < oplim && iptr < iplim && '\0' != *iptr; 1719 iptr++, optr++) 1720 if (isprint((int)*iptr)) 1721 *optr = *iptr; 1722 else 1723 *optr = '.'; 1724 if (!(optr <= oplim)) 1725 optr = past_eq; 1726 ctl_putdata(output, (u_int)(optr - output), FALSE); 1727 } 1728 1729 1730 /* 1731 * ctl_putarray - write a tagged eight element double array into the response 1732 */ 1733 static void 1734 ctl_putarray( 1735 const char *tag, 1736 double *arr, 1737 int start 1738 ) 1739 { 1740 register char *cp; 1741 register const char *cq; 1742 char buffer[200]; 1743 int i; 1744 cp = buffer; 1745 cq = tag; 1746 while (*cq != '\0') 1747 *cp++ = *cq++; 1748 *cp++ = '='; 1749 i = start; 1750 do { 1751 if (i == 0) 1752 i = NTP_SHIFT; 1753 i--; 1754 INSIST((cp - buffer) < (int)sizeof(buffer)); 1755 snprintf(cp, sizeof(buffer) - (cp - buffer), 1756 " %.2f", arr[i] * 1e3); 1757 cp += strlen(cp); 1758 } while (i != start); 1759 ctl_putdata(buffer, (unsigned)(cp - buffer), 0); 1760 } 1761 1762 1763 /* 1764 * ctl_putsys - output a system variable 1765 */ 1766 static void 1767 ctl_putsys( 1768 int varid 1769 ) 1770 { 1771 l_fp tmp; 1772 char str[256]; 1773 u_int u; 1774 double kb; 1775 double dtemp; 1776 const char *ss; 1777 #ifdef AUTOKEY 1778 struct cert_info *cp; 1779 #endif /* AUTOKEY */ 1780 #ifdef KERNEL_PLL 1781 static struct timex ntx; 1782 static u_long ntp_adjtime_time; 1783 1784 static const double to_ms = 1785 # ifdef STA_NANO 1786 1.0e-6; /* nsec to msec */ 1787 # else 1788 1.0e-3; /* usec to msec */ 1789 # endif 1790 1791 /* 1792 * CS_K_* variables depend on up-to-date output of ntp_adjtime() 1793 */ 1794 if (CS_KERN_FIRST <= varid && varid <= CS_KERN_LAST && 1795 current_time != ntp_adjtime_time) { 1796 ZERO(ntx); 1797 if (ntp_adjtime(&ntx) < 0) 1798 msyslog(LOG_ERR, "ntp_adjtime() for mode 6 query failed: %m"); 1799 else 1800 ntp_adjtime_time = current_time; 1801 } 1802 #endif /* KERNEL_PLL */ 1803 1804 switch (varid) { 1805 1806 case CS_LEAP: 1807 ctl_putuint(sys_var[CS_LEAP].text, sys_leap); 1808 break; 1809 1810 case CS_STRATUM: 1811 ctl_putuint(sys_var[CS_STRATUM].text, sys_stratum); 1812 break; 1813 1814 case CS_PRECISION: 1815 ctl_putint(sys_var[CS_PRECISION].text, sys_precision); 1816 break; 1817 1818 case CS_ROOTDELAY: 1819 ctl_putdbl(sys_var[CS_ROOTDELAY].text, sys_rootdelay * 1820 1e3); 1821 break; 1822 1823 case CS_ROOTDISPERSION: 1824 ctl_putdbl(sys_var[CS_ROOTDISPERSION].text, 1825 sys_rootdisp * 1e3); 1826 break; 1827 1828 case CS_REFID: 1829 if (sys_stratum > 1 && sys_stratum < STRATUM_UNSPEC) 1830 ctl_putadr(sys_var[varid].text, sys_refid, NULL); 1831 else 1832 ctl_putrefid(sys_var[varid].text, sys_refid); 1833 break; 1834 1835 case CS_REFTIME: 1836 ctl_putts(sys_var[CS_REFTIME].text, &sys_reftime); 1837 break; 1838 1839 case CS_POLL: 1840 ctl_putuint(sys_var[CS_POLL].text, sys_poll); 1841 break; 1842 1843 case CS_PEERID: 1844 if (sys_peer == NULL) 1845 ctl_putuint(sys_var[CS_PEERID].text, 0); 1846 else 1847 ctl_putuint(sys_var[CS_PEERID].text, 1848 sys_peer->associd); 1849 break; 1850 1851 case CS_PEERADR: 1852 if (sys_peer != NULL && sys_peer->dstadr != NULL) 1853 ss = sptoa(&sys_peer->srcadr); 1854 else 1855 ss = "0.0.0.0:0"; 1856 ctl_putunqstr(sys_var[CS_PEERADR].text, ss, strlen(ss)); 1857 break; 1858 1859 case CS_PEERMODE: 1860 u = (sys_peer != NULL) 1861 ? sys_peer->hmode 1862 : MODE_UNSPEC; 1863 ctl_putuint(sys_var[CS_PEERMODE].text, u); 1864 break; 1865 1866 case CS_OFFSET: 1867 ctl_putdbl6(sys_var[CS_OFFSET].text, last_offset * 1e3); 1868 break; 1869 1870 case CS_DRIFT: 1871 ctl_putdbl(sys_var[CS_DRIFT].text, drift_comp * 1e6); 1872 break; 1873 1874 case CS_JITTER: 1875 ctl_putdbl6(sys_var[CS_JITTER].text, sys_jitter * 1e3); 1876 break; 1877 1878 case CS_ERROR: 1879 ctl_putdbl(sys_var[CS_ERROR].text, clock_jitter * 1e3); 1880 break; 1881 1882 case CS_CLOCK: 1883 get_systime(&tmp); 1884 ctl_putts(sys_var[CS_CLOCK].text, &tmp); 1885 break; 1886 1887 case CS_PROCESSOR: 1888 #ifndef HAVE_UNAME 1889 ctl_putstr(sys_var[CS_PROCESSOR].text, str_processor, 1890 sizeof(str_processor) - 1); 1891 #else 1892 ctl_putstr(sys_var[CS_PROCESSOR].text, 1893 utsnamebuf.machine, strlen(utsnamebuf.machine)); 1894 #endif /* HAVE_UNAME */ 1895 break; 1896 1897 case CS_SYSTEM: 1898 #ifndef HAVE_UNAME 1899 ctl_putstr(sys_var[CS_SYSTEM].text, str_system, 1900 sizeof(str_system) - 1); 1901 #else 1902 snprintf(str, sizeof(str), "%s/%s", utsnamebuf.sysname, 1903 utsnamebuf.release); 1904 ctl_putstr(sys_var[CS_SYSTEM].text, str, strlen(str)); 1905 #endif /* HAVE_UNAME */ 1906 break; 1907 1908 case CS_VERSION: 1909 ctl_putstr(sys_var[CS_VERSION].text, Version, 1910 strlen(Version)); 1911 break; 1912 1913 case CS_STABIL: 1914 ctl_putdbl(sys_var[CS_STABIL].text, clock_stability * 1915 1e6); 1916 break; 1917 1918 case CS_VARLIST: 1919 { 1920 char buf[CTL_MAX_DATA_LEN]; 1921 //buffPointer, firstElementPointer, buffEndPointer 1922 char *buffp, *buffend; 1923 int firstVarName; 1924 const char *ss1; 1925 int len; 1926 const struct ctl_var *k; 1927 1928 buffp = buf; 1929 buffend = buf + sizeof(buf); 1930 if (buffp + strlen(sys_var[CS_VARLIST].text) + 4 > buffend) 1931 break; /* really long var name */ 1932 1933 snprintf(buffp, sizeof(buf), "%s=\"",sys_var[CS_VARLIST].text); 1934 buffp += strlen(buffp); 1935 firstVarName = TRUE; 1936 for (k = sys_var; !(k->flags & EOV); k++) { 1937 if (k->flags & PADDING) 1938 continue; 1939 len = strlen(k->text); 1940 if (buffp + len + 1 >= buffend) 1941 break; 1942 if (!firstVarName) 1943 *buffp++ = ','; 1944 else 1945 firstVarName = FALSE; 1946 memcpy(buffp, k->text, len); 1947 buffp += len; 1948 } 1949 1950 for (k = ext_sys_var; k && !(k->flags & EOV); k++) { 1951 if (k->flags & PADDING) 1952 continue; 1953 if (NULL == k->text) 1954 continue; 1955 ss1 = strchr(k->text, '='); 1956 if (NULL == ss1) 1957 len = strlen(k->text); 1958 else 1959 len = ss1 - k->text; 1960 if (buffp + len + 1 >= buffend) 1961 break; 1962 if (firstVarName) { 1963 *buffp++ = ','; 1964 firstVarName = FALSE; 1965 } 1966 memcpy(buffp, k->text,(unsigned)len); 1967 buffp += len; 1968 } 1969 if (buffp + 2 >= buffend) 1970 break; 1971 1972 *buffp++ = '"'; 1973 *buffp = '\0'; 1974 1975 ctl_putdata(buf, (unsigned)( buffp - buf ), 0); 1976 break; 1977 } 1978 1979 case CS_TAI: 1980 if (sys_tai > 0) 1981 ctl_putuint(sys_var[CS_TAI].text, sys_tai); 1982 break; 1983 1984 case CS_LEAPTAB: 1985 { 1986 leap_signature_t lsig; 1987 leapsec_getsig(&lsig); 1988 if (lsig.ttime > 0) 1989 ctl_putfs(sys_var[CS_LEAPTAB].text, lsig.ttime); 1990 break; 1991 } 1992 1993 case CS_LEAPEND: 1994 { 1995 leap_signature_t lsig; 1996 leapsec_getsig(&lsig); 1997 if (lsig.etime > 0) 1998 ctl_putfs(sys_var[CS_LEAPEND].text, lsig.etime); 1999 break; 2000 } 2001 2002 #ifdef LEAP_SMEAR 2003 case CS_LEAPSMEARINTV: 2004 if (leap_smear_intv > 0) 2005 ctl_putuint(sys_var[CS_LEAPSMEARINTV].text, leap_smear_intv); 2006 break; 2007 2008 case CS_LEAPSMEAROFFS: 2009 if (leap_smear_intv > 0) 2010 ctl_putdbl(sys_var[CS_LEAPSMEAROFFS].text, 2011 leap_smear.doffset * 1e3); 2012 break; 2013 #endif /* LEAP_SMEAR */ 2014 2015 case CS_RATE: 2016 ctl_putuint(sys_var[CS_RATE].text, ntp_minpoll); 2017 break; 2018 2019 case CS_MRU_ENABLED: 2020 ctl_puthex(sys_var[varid].text, mon_enabled); 2021 break; 2022 2023 case CS_MRU_DEPTH: 2024 ctl_putuint(sys_var[varid].text, mru_entries); 2025 break; 2026 2027 case CS_MRU_MEM: 2028 kb = mru_entries * (sizeof(mon_entry) / 1024.); 2029 u = (u_int)kb; 2030 if (kb - u >= 0.5) 2031 u++; 2032 ctl_putuint(sys_var[varid].text, u); 2033 break; 2034 2035 case CS_MRU_DEEPEST: 2036 ctl_putuint(sys_var[varid].text, mru_peakentries); 2037 break; 2038 2039 case CS_MRU_MINDEPTH: 2040 ctl_putuint(sys_var[varid].text, mru_mindepth); 2041 break; 2042 2043 case CS_MRU_MAXAGE: 2044 ctl_putint(sys_var[varid].text, mru_maxage); 2045 break; 2046 2047 case CS_MRU_MAXDEPTH: 2048 ctl_putuint(sys_var[varid].text, mru_maxdepth); 2049 break; 2050 2051 case CS_MRU_MAXMEM: 2052 kb = mru_maxdepth * (sizeof(mon_entry) / 1024.); 2053 u = (u_int)kb; 2054 if (kb - u >= 0.5) 2055 u++; 2056 ctl_putuint(sys_var[varid].text, u); 2057 break; 2058 2059 case CS_SS_UPTIME: 2060 ctl_putuint(sys_var[varid].text, current_time); 2061 break; 2062 2063 case CS_SS_RESET: 2064 ctl_putuint(sys_var[varid].text, 2065 current_time - sys_stattime); 2066 break; 2067 2068 case CS_SS_RECEIVED: 2069 ctl_putuint(sys_var[varid].text, sys_received); 2070 break; 2071 2072 case CS_SS_THISVER: 2073 ctl_putuint(sys_var[varid].text, sys_newversion); 2074 break; 2075 2076 case CS_SS_OLDVER: 2077 ctl_putuint(sys_var[varid].text, sys_oldversion); 2078 break; 2079 2080 case CS_SS_BADFORMAT: 2081 ctl_putuint(sys_var[varid].text, sys_badlength); 2082 break; 2083 2084 case CS_SS_BADAUTH: 2085 ctl_putuint(sys_var[varid].text, sys_badauth); 2086 break; 2087 2088 case CS_SS_DECLINED: 2089 ctl_putuint(sys_var[varid].text, sys_declined); 2090 break; 2091 2092 case CS_SS_RESTRICTED: 2093 ctl_putuint(sys_var[varid].text, sys_restricted); 2094 break; 2095 2096 case CS_SS_LIMITED: 2097 ctl_putuint(sys_var[varid].text, sys_limitrejected); 2098 break; 2099 2100 case CS_SS_KODSENT: 2101 ctl_putuint(sys_var[varid].text, sys_kodsent); 2102 break; 2103 2104 case CS_SS_PROCESSED: 2105 ctl_putuint(sys_var[varid].text, sys_processed); 2106 break; 2107 2108 case CS_BCASTDELAY: 2109 ctl_putdbl(sys_var[varid].text, sys_bdelay * 1e3); 2110 break; 2111 2112 case CS_AUTHDELAY: 2113 LFPTOD(&sys_authdelay, dtemp); 2114 ctl_putdbl(sys_var[varid].text, dtemp * 1e3); 2115 break; 2116 2117 case CS_AUTHKEYS: 2118 ctl_putuint(sys_var[varid].text, authnumkeys); 2119 break; 2120 2121 case CS_AUTHFREEK: 2122 ctl_putuint(sys_var[varid].text, authnumfreekeys); 2123 break; 2124 2125 case CS_AUTHKLOOKUPS: 2126 ctl_putuint(sys_var[varid].text, authkeylookups); 2127 break; 2128 2129 case CS_AUTHKNOTFOUND: 2130 ctl_putuint(sys_var[varid].text, authkeynotfound); 2131 break; 2132 2133 case CS_AUTHKUNCACHED: 2134 ctl_putuint(sys_var[varid].text, authkeyuncached); 2135 break; 2136 2137 case CS_AUTHKEXPIRED: 2138 ctl_putuint(sys_var[varid].text, authkeyexpired); 2139 break; 2140 2141 case CS_AUTHENCRYPTS: 2142 ctl_putuint(sys_var[varid].text, authencryptions); 2143 break; 2144 2145 case CS_AUTHDECRYPTS: 2146 ctl_putuint(sys_var[varid].text, authdecryptions); 2147 break; 2148 2149 case CS_AUTHRESET: 2150 ctl_putuint(sys_var[varid].text, 2151 current_time - auth_timereset); 2152 break; 2153 2154 /* 2155 * CTL_IF_KERNLOOP() puts a zero if the kernel loop is 2156 * unavailable, otherwise calls putfunc with args. 2157 */ 2158 #ifndef KERNEL_PLL 2159 # define CTL_IF_KERNLOOP(putfunc, args) \ 2160 ctl_putint(sys_var[varid].text, 0) 2161 #else 2162 # define CTL_IF_KERNLOOP(putfunc, args) \ 2163 putfunc args 2164 #endif 2165 2166 /* 2167 * CTL_IF_KERNPPS() puts a zero if either the kernel 2168 * loop is unavailable, or kernel hard PPS is not 2169 * active, otherwise calls putfunc with args. 2170 */ 2171 #ifndef KERNEL_PLL 2172 # define CTL_IF_KERNPPS(putfunc, args) \ 2173 ctl_putint(sys_var[varid].text, 0) 2174 #else 2175 # define CTL_IF_KERNPPS(putfunc, args) \ 2176 if (0 == ntx.shift) \ 2177 ctl_putint(sys_var[varid].text, 0); \ 2178 else \ 2179 putfunc args /* no trailing ; */ 2180 #endif 2181 2182 case CS_K_OFFSET: 2183 CTL_IF_KERNLOOP( 2184 ctl_putdblf, 2185 (sys_var[varid].text, 0, -1, to_ms * ntx.offset) 2186 ); 2187 break; 2188 2189 case CS_K_FREQ: 2190 CTL_IF_KERNLOOP( 2191 ctl_putsfp, 2192 (sys_var[varid].text, ntx.freq) 2193 ); 2194 break; 2195 2196 case CS_K_MAXERR: 2197 CTL_IF_KERNLOOP( 2198 ctl_putdblf, 2199 (sys_var[varid].text, 0, 6, 2200 to_ms * ntx.maxerror) 2201 ); 2202 break; 2203 2204 case CS_K_ESTERR: 2205 CTL_IF_KERNLOOP( 2206 ctl_putdblf, 2207 (sys_var[varid].text, 0, 6, 2208 to_ms * ntx.esterror) 2209 ); 2210 break; 2211 2212 case CS_K_STFLAGS: 2213 #ifndef KERNEL_PLL 2214 ss = ""; 2215 #else 2216 ss = k_st_flags(ntx.status); 2217 #endif 2218 ctl_putstr(sys_var[varid].text, ss, strlen(ss)); 2219 break; 2220 2221 case CS_K_TIMECONST: 2222 CTL_IF_KERNLOOP( 2223 ctl_putint, 2224 (sys_var[varid].text, ntx.constant) 2225 ); 2226 break; 2227 2228 case CS_K_PRECISION: 2229 CTL_IF_KERNLOOP( 2230 ctl_putdblf, 2231 (sys_var[varid].text, 0, 6, 2232 to_ms * ntx.precision) 2233 ); 2234 break; 2235 2236 case CS_K_FREQTOL: 2237 CTL_IF_KERNLOOP( 2238 ctl_putsfp, 2239 (sys_var[varid].text, ntx.tolerance) 2240 ); 2241 break; 2242 2243 case CS_K_PPS_FREQ: 2244 CTL_IF_KERNPPS( 2245 ctl_putsfp, 2246 (sys_var[varid].text, ntx.ppsfreq) 2247 ); 2248 break; 2249 2250 case CS_K_PPS_STABIL: 2251 CTL_IF_KERNPPS( 2252 ctl_putsfp, 2253 (sys_var[varid].text, ntx.stabil) 2254 ); 2255 break; 2256 2257 case CS_K_PPS_JITTER: 2258 CTL_IF_KERNPPS( 2259 ctl_putdbl, 2260 (sys_var[varid].text, to_ms * ntx.jitter) 2261 ); 2262 break; 2263 2264 case CS_K_PPS_CALIBDUR: 2265 CTL_IF_KERNPPS( 2266 ctl_putint, 2267 (sys_var[varid].text, 1 << ntx.shift) 2268 ); 2269 break; 2270 2271 case CS_K_PPS_CALIBS: 2272 CTL_IF_KERNPPS( 2273 ctl_putint, 2274 (sys_var[varid].text, ntx.calcnt) 2275 ); 2276 break; 2277 2278 case CS_K_PPS_CALIBERRS: 2279 CTL_IF_KERNPPS( 2280 ctl_putint, 2281 (sys_var[varid].text, ntx.errcnt) 2282 ); 2283 break; 2284 2285 case CS_K_PPS_JITEXC: 2286 CTL_IF_KERNPPS( 2287 ctl_putint, 2288 (sys_var[varid].text, ntx.jitcnt) 2289 ); 2290 break; 2291 2292 case CS_K_PPS_STBEXC: 2293 CTL_IF_KERNPPS( 2294 ctl_putint, 2295 (sys_var[varid].text, ntx.stbcnt) 2296 ); 2297 break; 2298 2299 case CS_IOSTATS_RESET: 2300 ctl_putuint(sys_var[varid].text, 2301 current_time - io_timereset); 2302 break; 2303 2304 case CS_TOTAL_RBUF: 2305 ctl_putuint(sys_var[varid].text, total_recvbuffs()); 2306 break; 2307 2308 case CS_FREE_RBUF: 2309 ctl_putuint(sys_var[varid].text, free_recvbuffs()); 2310 break; 2311 2312 case CS_USED_RBUF: 2313 ctl_putuint(sys_var[varid].text, full_recvbuffs()); 2314 break; 2315 2316 case CS_RBUF_LOWATER: 2317 ctl_putuint(sys_var[varid].text, lowater_additions()); 2318 break; 2319 2320 case CS_IO_DROPPED: 2321 ctl_putuint(sys_var[varid].text, packets_dropped); 2322 break; 2323 2324 case CS_IO_IGNORED: 2325 ctl_putuint(sys_var[varid].text, packets_ignored); 2326 break; 2327 2328 case CS_IO_RECEIVED: 2329 ctl_putuint(sys_var[varid].text, packets_received); 2330 break; 2331 2332 case CS_IO_SENT: 2333 ctl_putuint(sys_var[varid].text, packets_sent); 2334 break; 2335 2336 case CS_IO_SENDFAILED: 2337 ctl_putuint(sys_var[varid].text, packets_notsent); 2338 break; 2339 2340 case CS_IO_WAKEUPS: 2341 ctl_putuint(sys_var[varid].text, handler_calls); 2342 break; 2343 2344 case CS_IO_GOODWAKEUPS: 2345 ctl_putuint(sys_var[varid].text, handler_pkts); 2346 break; 2347 2348 case CS_TIMERSTATS_RESET: 2349 ctl_putuint(sys_var[varid].text, 2350 current_time - timer_timereset); 2351 break; 2352 2353 case CS_TIMER_OVERRUNS: 2354 ctl_putuint(sys_var[varid].text, alarm_overflow); 2355 break; 2356 2357 case CS_TIMER_XMTS: 2358 ctl_putuint(sys_var[varid].text, timer_xmtcalls); 2359 break; 2360 2361 case CS_FUZZ: 2362 ctl_putdbl(sys_var[varid].text, sys_fuzz * 1e3); 2363 break; 2364 case CS_WANDER_THRESH: 2365 ctl_putdbl(sys_var[varid].text, wander_threshold * 1e6); 2366 break; 2367 #ifdef AUTOKEY 2368 case CS_FLAGS: 2369 if (crypto_flags) 2370 ctl_puthex(sys_var[CS_FLAGS].text, 2371 crypto_flags); 2372 break; 2373 2374 case CS_DIGEST: 2375 if (crypto_flags) { 2376 strlcpy(str, OBJ_nid2ln(crypto_nid), 2377 COUNTOF(str)); 2378 ctl_putstr(sys_var[CS_DIGEST].text, str, 2379 strlen(str)); 2380 } 2381 break; 2382 2383 case CS_SIGNATURE: 2384 if (crypto_flags) { 2385 const EVP_MD *dp; 2386 2387 dp = EVP_get_digestbynid(crypto_flags >> 16); 2388 strlcpy(str, OBJ_nid2ln(EVP_MD_pkey_type(dp)), 2389 COUNTOF(str)); 2390 ctl_putstr(sys_var[CS_SIGNATURE].text, str, 2391 strlen(str)); 2392 } 2393 break; 2394 2395 case CS_HOST: 2396 if (hostval.ptr != NULL) 2397 ctl_putstr(sys_var[CS_HOST].text, hostval.ptr, 2398 strlen(hostval.ptr)); 2399 break; 2400 2401 case CS_IDENT: 2402 if (sys_ident != NULL) 2403 ctl_putstr(sys_var[CS_IDENT].text, sys_ident, 2404 strlen(sys_ident)); 2405 break; 2406 2407 case CS_CERTIF: 2408 for (cp = cinfo; cp != NULL; cp = cp->link) { 2409 snprintf(str, sizeof(str), "%s %s 0x%x", 2410 cp->subject, cp->issuer, cp->flags); 2411 ctl_putstr(sys_var[CS_CERTIF].text, str, 2412 strlen(str)); 2413 ctl_putcal(sys_var[CS_REVTIME].text, &(cp->last)); 2414 } 2415 break; 2416 2417 case CS_PUBLIC: 2418 if (hostval.tstamp != 0) 2419 ctl_putfs(sys_var[CS_PUBLIC].text, 2420 ntohl(hostval.tstamp)); 2421 break; 2422 #endif /* AUTOKEY */ 2423 2424 default: 2425 break; 2426 } 2427 } 2428 2429 2430 /* 2431 * ctl_putpeer - output a peer variable 2432 */ 2433 static void 2434 ctl_putpeer( 2435 int id, 2436 struct peer *p 2437 ) 2438 { 2439 char buf[CTL_MAX_DATA_LEN]; 2440 char *s; 2441 char *t; 2442 char *be; 2443 int i; 2444 const struct ctl_var *k; 2445 #ifdef AUTOKEY 2446 struct autokey *ap; 2447 const EVP_MD *dp; 2448 const char *str; 2449 #endif /* AUTOKEY */ 2450 2451 switch (id) { 2452 2453 case CP_CONFIG: 2454 ctl_putuint(peer_var[id].text, 2455 !(FLAG_PREEMPT & p->flags)); 2456 break; 2457 2458 case CP_AUTHENABLE: 2459 ctl_putuint(peer_var[id].text, !(p->keyid)); 2460 break; 2461 2462 case CP_AUTHENTIC: 2463 ctl_putuint(peer_var[id].text, 2464 !!(FLAG_AUTHENTIC & p->flags)); 2465 break; 2466 2467 case CP_SRCADR: 2468 ctl_putadr(peer_var[id].text, 0, &p->srcadr); 2469 break; 2470 2471 case CP_SRCPORT: 2472 ctl_putuint(peer_var[id].text, SRCPORT(&p->srcadr)); 2473 break; 2474 2475 case CP_SRCHOST: 2476 if (p->hostname != NULL) 2477 ctl_putstr(peer_var[id].text, p->hostname, 2478 strlen(p->hostname)); 2479 break; 2480 2481 case CP_DSTADR: 2482 ctl_putadr(peer_var[id].text, 0, 2483 (p->dstadr != NULL) 2484 ? &p->dstadr->sin 2485 : NULL); 2486 break; 2487 2488 case CP_DSTPORT: 2489 ctl_putuint(peer_var[id].text, 2490 (p->dstadr != NULL) 2491 ? SRCPORT(&p->dstadr->sin) 2492 : 0); 2493 break; 2494 2495 case CP_IN: 2496 if (p->r21 > 0.) 2497 ctl_putdbl(peer_var[id].text, p->r21 / 1e3); 2498 break; 2499 2500 case CP_OUT: 2501 if (p->r34 > 0.) 2502 ctl_putdbl(peer_var[id].text, p->r34 / 1e3); 2503 break; 2504 2505 case CP_RATE: 2506 ctl_putuint(peer_var[id].text, p->throttle); 2507 break; 2508 2509 case CP_LEAP: 2510 ctl_putuint(peer_var[id].text, p->leap); 2511 break; 2512 2513 case CP_HMODE: 2514 ctl_putuint(peer_var[id].text, p->hmode); 2515 break; 2516 2517 case CP_STRATUM: 2518 ctl_putuint(peer_var[id].text, p->stratum); 2519 break; 2520 2521 case CP_PPOLL: 2522 ctl_putuint(peer_var[id].text, p->ppoll); 2523 break; 2524 2525 case CP_HPOLL: 2526 ctl_putuint(peer_var[id].text, p->hpoll); 2527 break; 2528 2529 case CP_PRECISION: 2530 ctl_putint(peer_var[id].text, p->precision); 2531 break; 2532 2533 case CP_ROOTDELAY: 2534 ctl_putdbl(peer_var[id].text, p->rootdelay * 1e3); 2535 break; 2536 2537 case CP_ROOTDISPERSION: 2538 ctl_putdbl(peer_var[id].text, p->rootdisp * 1e3); 2539 break; 2540 2541 case CP_REFID: 2542 #ifdef REFCLOCK 2543 if (p->flags & FLAG_REFCLOCK) { 2544 ctl_putrefid(peer_var[id].text, p->refid); 2545 break; 2546 } 2547 #endif 2548 if (p->stratum > 1 && p->stratum < STRATUM_UNSPEC) 2549 ctl_putadr(peer_var[id].text, p->refid, 2550 NULL); 2551 else 2552 ctl_putrefid(peer_var[id].text, p->refid); 2553 break; 2554 2555 case CP_REFTIME: 2556 ctl_putts(peer_var[id].text, &p->reftime); 2557 break; 2558 2559 case CP_ORG: 2560 ctl_putts(peer_var[id].text, &p->aorg); 2561 break; 2562 2563 case CP_REC: 2564 ctl_putts(peer_var[id].text, &p->dst); 2565 break; 2566 2567 case CP_XMT: 2568 if (p->xleave) 2569 ctl_putdbl(peer_var[id].text, p->xleave * 1e3); 2570 break; 2571 2572 case CP_BIAS: 2573 if (p->bias != 0.) 2574 ctl_putdbl(peer_var[id].text, p->bias * 1e3); 2575 break; 2576 2577 case CP_REACH: 2578 ctl_puthex(peer_var[id].text, p->reach); 2579 break; 2580 2581 case CP_FLASH: 2582 ctl_puthex(peer_var[id].text, p->flash); 2583 break; 2584 2585 case CP_TTL: 2586 #ifdef REFCLOCK 2587 if (p->flags & FLAG_REFCLOCK) { 2588 ctl_putuint(peer_var[id].text, p->ttl); 2589 break; 2590 } 2591 #endif 2592 if (p->ttl > 0 && p->ttl < COUNTOF(sys_ttl)) 2593 ctl_putint(peer_var[id].text, 2594 sys_ttl[p->ttl]); 2595 break; 2596 2597 case CP_UNREACH: 2598 ctl_putuint(peer_var[id].text, p->unreach); 2599 break; 2600 2601 case CP_TIMER: 2602 ctl_putuint(peer_var[id].text, 2603 p->nextdate - current_time); 2604 break; 2605 2606 case CP_DELAY: 2607 ctl_putdbl(peer_var[id].text, p->delay * 1e3); 2608 break; 2609 2610 case CP_OFFSET: 2611 ctl_putdbl(peer_var[id].text, p->offset * 1e3); 2612 break; 2613 2614 case CP_JITTER: 2615 ctl_putdbl(peer_var[id].text, p->jitter * 1e3); 2616 break; 2617 2618 case CP_DISPERSION: 2619 ctl_putdbl(peer_var[id].text, p->disp * 1e3); 2620 break; 2621 2622 case CP_KEYID: 2623 if (p->keyid > NTP_MAXKEY) 2624 ctl_puthex(peer_var[id].text, p->keyid); 2625 else 2626 ctl_putuint(peer_var[id].text, p->keyid); 2627 break; 2628 2629 case CP_FILTDELAY: 2630 ctl_putarray(peer_var[id].text, p->filter_delay, 2631 p->filter_nextpt); 2632 break; 2633 2634 case CP_FILTOFFSET: 2635 ctl_putarray(peer_var[id].text, p->filter_offset, 2636 p->filter_nextpt); 2637 break; 2638 2639 case CP_FILTERROR: 2640 ctl_putarray(peer_var[id].text, p->filter_disp, 2641 p->filter_nextpt); 2642 break; 2643 2644 case CP_PMODE: 2645 ctl_putuint(peer_var[id].text, p->pmode); 2646 break; 2647 2648 case CP_RECEIVED: 2649 ctl_putuint(peer_var[id].text, p->received); 2650 break; 2651 2652 case CP_SENT: 2653 ctl_putuint(peer_var[id].text, p->sent); 2654 break; 2655 2656 case CP_VARLIST: 2657 s = buf; 2658 be = buf + sizeof(buf); 2659 if (strlen(peer_var[id].text) + 4 > sizeof(buf)) 2660 break; /* really long var name */ 2661 2662 snprintf(s, sizeof(buf), "%s=\"", peer_var[id].text); 2663 s += strlen(s); 2664 t = s; 2665 for (k = peer_var; !(EOV & k->flags); k++) { 2666 if (PADDING & k->flags) 2667 continue; 2668 i = strlen(k->text); 2669 if (s + i + 1 >= be) 2670 break; 2671 if (s != t) 2672 *s++ = ','; 2673 memcpy(s, k->text, i); 2674 s += i; 2675 } 2676 if (s + 2 < be) { 2677 *s++ = '"'; 2678 *s = '\0'; 2679 ctl_putdata(buf, (u_int)(s - buf), 0); 2680 } 2681 break; 2682 2683 case CP_TIMEREC: 2684 ctl_putuint(peer_var[id].text, 2685 current_time - p->timereceived); 2686 break; 2687 2688 case CP_TIMEREACH: 2689 ctl_putuint(peer_var[id].text, 2690 current_time - p->timereachable); 2691 break; 2692 2693 case CP_BADAUTH: 2694 ctl_putuint(peer_var[id].text, p->badauth); 2695 break; 2696 2697 case CP_BOGUSORG: 2698 ctl_putuint(peer_var[id].text, p->bogusorg); 2699 break; 2700 2701 case CP_OLDPKT: 2702 ctl_putuint(peer_var[id].text, p->oldpkt); 2703 break; 2704 2705 case CP_SELDISP: 2706 ctl_putuint(peer_var[id].text, p->seldisptoolarge); 2707 break; 2708 2709 case CP_SELBROKEN: 2710 ctl_putuint(peer_var[id].text, p->selbroken); 2711 break; 2712 2713 case CP_CANDIDATE: 2714 ctl_putuint(peer_var[id].text, p->status); 2715 break; 2716 #ifdef AUTOKEY 2717 case CP_FLAGS: 2718 if (p->crypto) 2719 ctl_puthex(peer_var[id].text, p->crypto); 2720 break; 2721 2722 case CP_SIGNATURE: 2723 if (p->crypto) { 2724 dp = EVP_get_digestbynid(p->crypto >> 16); 2725 str = OBJ_nid2ln(EVP_MD_pkey_type(dp)); 2726 ctl_putstr(peer_var[id].text, str, strlen(str)); 2727 } 2728 break; 2729 2730 case CP_HOST: 2731 if (p->subject != NULL) 2732 ctl_putstr(peer_var[id].text, p->subject, 2733 strlen(p->subject)); 2734 break; 2735 2736 case CP_VALID: /* not used */ 2737 break; 2738 2739 case CP_INITSEQ: 2740 if (NULL == (ap = p->recval.ptr)) 2741 break; 2742 2743 ctl_putint(peer_var[CP_INITSEQ].text, ap->seq); 2744 ctl_puthex(peer_var[CP_INITKEY].text, ap->key); 2745 ctl_putfs(peer_var[CP_INITTSP].text, 2746 ntohl(p->recval.tstamp)); 2747 break; 2748 2749 case CP_IDENT: 2750 if (p->ident != NULL) 2751 ctl_putstr(peer_var[id].text, p->ident, 2752 strlen(p->ident)); 2753 break; 2754 2755 2756 #endif /* AUTOKEY */ 2757 } 2758 } 2759 2760 2761 #ifdef REFCLOCK 2762 /* 2763 * ctl_putclock - output clock variables 2764 */ 2765 static void 2766 ctl_putclock( 2767 int id, 2768 struct refclockstat *pcs, 2769 int mustput 2770 ) 2771 { 2772 char buf[CTL_MAX_DATA_LEN]; 2773 char *s, *t, *be; 2774 const char *ss; 2775 int i; 2776 const struct ctl_var *k; 2777 2778 switch (id) { 2779 2780 case CC_TYPE: 2781 if (mustput || pcs->clockdesc == NULL 2782 || *(pcs->clockdesc) == '\0') { 2783 ctl_putuint(clock_var[id].text, pcs->type); 2784 } 2785 break; 2786 case CC_TIMECODE: 2787 ctl_putstr(clock_var[id].text, 2788 pcs->p_lastcode, 2789 (unsigned)pcs->lencode); 2790 break; 2791 2792 case CC_POLL: 2793 ctl_putuint(clock_var[id].text, pcs->polls); 2794 break; 2795 2796 case CC_NOREPLY: 2797 ctl_putuint(clock_var[id].text, 2798 pcs->noresponse); 2799 break; 2800 2801 case CC_BADFORMAT: 2802 ctl_putuint(clock_var[id].text, 2803 pcs->badformat); 2804 break; 2805 2806 case CC_BADDATA: 2807 ctl_putuint(clock_var[id].text, 2808 pcs->baddata); 2809 break; 2810 2811 case CC_FUDGETIME1: 2812 if (mustput || (pcs->haveflags & CLK_HAVETIME1)) 2813 ctl_putdbl(clock_var[id].text, 2814 pcs->fudgetime1 * 1e3); 2815 break; 2816 2817 case CC_FUDGETIME2: 2818 if (mustput || (pcs->haveflags & CLK_HAVETIME2)) 2819 ctl_putdbl(clock_var[id].text, 2820 pcs->fudgetime2 * 1e3); 2821 break; 2822 2823 case CC_FUDGEVAL1: 2824 if (mustput || (pcs->haveflags & CLK_HAVEVAL1)) 2825 ctl_putint(clock_var[id].text, 2826 pcs->fudgeval1); 2827 break; 2828 2829 case CC_FUDGEVAL2: 2830 if (mustput || (pcs->haveflags & CLK_HAVEVAL2)) { 2831 if (pcs->fudgeval1 > 1) 2832 ctl_putadr(clock_var[id].text, 2833 pcs->fudgeval2, NULL); 2834 else 2835 ctl_putrefid(clock_var[id].text, 2836 pcs->fudgeval2); 2837 } 2838 break; 2839 2840 case CC_FLAGS: 2841 ctl_putuint(clock_var[id].text, pcs->flags); 2842 break; 2843 2844 case CC_DEVICE: 2845 if (pcs->clockdesc == NULL || 2846 *(pcs->clockdesc) == '\0') { 2847 if (mustput) 2848 ctl_putstr(clock_var[id].text, 2849 "", 0); 2850 } else { 2851 ctl_putstr(clock_var[id].text, 2852 pcs->clockdesc, 2853 strlen(pcs->clockdesc)); 2854 } 2855 break; 2856 2857 case CC_VARLIST: 2858 s = buf; 2859 be = buf + sizeof(buf); 2860 if (strlen(clock_var[CC_VARLIST].text) + 4 > 2861 sizeof(buf)) 2862 break; /* really long var name */ 2863 2864 snprintf(s, sizeof(buf), "%s=\"", 2865 clock_var[CC_VARLIST].text); 2866 s += strlen(s); 2867 t = s; 2868 2869 for (k = clock_var; !(EOV & k->flags); k++) { 2870 if (PADDING & k->flags) 2871 continue; 2872 2873 i = strlen(k->text); 2874 if (s + i + 1 >= be) 2875 break; 2876 2877 if (s != t) 2878 *s++ = ','; 2879 memcpy(s, k->text, i); 2880 s += i; 2881 } 2882 2883 for (k = pcs->kv_list; k && !(EOV & k->flags); k++) { 2884 if (PADDING & k->flags) 2885 continue; 2886 2887 ss = k->text; 2888 if (NULL == ss) 2889 continue; 2890 2891 while (*ss && *ss != '=') 2892 ss++; 2893 i = ss - k->text; 2894 if (s + i + 1 >= be) 2895 break; 2896 2897 if (s != t) 2898 *s++ = ','; 2899 memcpy(s, k->text, (unsigned)i); 2900 s += i; 2901 *s = '\0'; 2902 } 2903 if (s + 2 >= be) 2904 break; 2905 2906 *s++ = '"'; 2907 *s = '\0'; 2908 ctl_putdata(buf, (unsigned)(s - buf), 0); 2909 break; 2910 } 2911 } 2912 #endif 2913 2914 2915 2916 /* 2917 * ctl_getitem - get the next data item from the incoming packet 2918 */ 2919 static const struct ctl_var * 2920 ctl_getitem( 2921 const struct ctl_var *var_list, 2922 char **data 2923 ) 2924 { 2925 static const struct ctl_var eol = { 0, EOV, NULL }; 2926 static char buf[128]; 2927 static u_long quiet_until; 2928 const struct ctl_var *v; 2929 const char *pch; 2930 char *cp; 2931 char *tp; 2932 2933 /* 2934 * Delete leading commas and white space 2935 */ 2936 while (reqpt < reqend && (*reqpt == ',' || 2937 isspace((unsigned char)*reqpt))) 2938 reqpt++; 2939 if (reqpt >= reqend) 2940 return NULL; 2941 2942 if (NULL == var_list) 2943 return &eol; 2944 2945 /* 2946 * Look for a first character match on the tag. If we find 2947 * one, see if it is a full match. 2948 */ 2949 cp = reqpt; 2950 for (v = var_list; !(EOV & v->flags); v++) { 2951 if (!(PADDING & v->flags) && *cp == *(v->text)) { 2952 pch = v->text; 2953 while ('\0' != *pch && '=' != *pch && cp < reqend 2954 && *cp == *pch) { 2955 cp++; 2956 pch++; 2957 } 2958 if ('\0' == *pch || '=' == *pch) { 2959 while (cp < reqend && isspace((u_char)*cp)) 2960 cp++; 2961 if (cp == reqend || ',' == *cp) { 2962 buf[0] = '\0'; 2963 *data = buf; 2964 if (cp < reqend) 2965 cp++; 2966 reqpt = cp; 2967 return v; 2968 } 2969 if ('=' == *cp) { 2970 cp++; 2971 tp = buf; 2972 while (cp < reqend && isspace((u_char)*cp)) 2973 cp++; 2974 while (cp < reqend && *cp != ',') { 2975 *tp++ = *cp++; 2976 if ((size_t)(tp - buf) >= sizeof(buf)) { 2977 ctl_error(CERR_BADFMT); 2978 numctlbadpkts++; 2979 NLOG(NLOG_SYSEVENT) 2980 if (quiet_until <= current_time) { 2981 quiet_until = current_time + 300; 2982 msyslog(LOG_WARNING, 2983 "Possible 'ntpdx' exploit from %s#%u (possibly spoofed)", stoa(rmt_addr), SRCPORT(rmt_addr)); 2984 } 2985 return NULL; 2986 } 2987 } 2988 if (cp < reqend) 2989 cp++; 2990 *tp-- = '\0'; 2991 while (tp >= buf && isspace((u_char)*tp)) 2992 *tp-- = '\0'; 2993 reqpt = cp; 2994 *data = buf; 2995 return v; 2996 } 2997 } 2998 cp = reqpt; 2999 } 3000 } 3001 return v; 3002 } 3003 3004 3005 /* 3006 * control_unspec - response to an unspecified op-code 3007 */ 3008 /*ARGSUSED*/ 3009 static void 3010 control_unspec( 3011 struct recvbuf *rbufp, 3012 int restrict_mask 3013 ) 3014 { 3015 struct peer *peer; 3016 3017 /* 3018 * What is an appropriate response to an unspecified op-code? 3019 * I return no errors and no data, unless a specified assocation 3020 * doesn't exist. 3021 */ 3022 if (res_associd) { 3023 peer = findpeerbyassoc(res_associd); 3024 if (NULL == peer) { 3025 ctl_error(CERR_BADASSOC); 3026 return; 3027 } 3028 rpkt.status = htons(ctlpeerstatus(peer)); 3029 } else 3030 rpkt.status = htons(ctlsysstatus()); 3031 ctl_flushpkt(0); 3032 } 3033 3034 3035 /* 3036 * read_status - return either a list of associd's, or a particular 3037 * peer's status. 3038 */ 3039 /*ARGSUSED*/ 3040 static void 3041 read_status( 3042 struct recvbuf *rbufp, 3043 int restrict_mask 3044 ) 3045 { 3046 struct peer *peer; 3047 const u_char *cp; 3048 size_t n; 3049 /* a_st holds association ID, status pairs alternating */ 3050 u_short a_st[CTL_MAX_DATA_LEN / sizeof(u_short)]; 3051 3052 #ifdef DEBUG 3053 if (debug > 2) 3054 printf("read_status: ID %d\n", res_associd); 3055 #endif 3056 /* 3057 * Two choices here. If the specified association ID is 3058 * zero we return all known assocation ID's. Otherwise 3059 * we return a bunch of stuff about the particular peer. 3060 */ 3061 if (res_associd) { 3062 peer = findpeerbyassoc(res_associd); 3063 if (NULL == peer) { 3064 ctl_error(CERR_BADASSOC); 3065 return; 3066 } 3067 rpkt.status = htons(ctlpeerstatus(peer)); 3068 if (res_authokay) 3069 peer->num_events = 0; 3070 /* 3071 * For now, output everything we know about the 3072 * peer. May be more selective later. 3073 */ 3074 for (cp = def_peer_var; *cp != 0; cp++) 3075 ctl_putpeer((int)*cp, peer); 3076 ctl_flushpkt(0); 3077 return; 3078 } 3079 n = 0; 3080 rpkt.status = htons(ctlsysstatus()); 3081 for (peer = peer_list; peer != NULL; peer = peer->p_link) { 3082 a_st[n++] = htons(peer->associd); 3083 a_st[n++] = htons(ctlpeerstatus(peer)); 3084 /* two entries each loop iteration, so n + 1 */ 3085 if (n + 1 >= COUNTOF(a_st)) { 3086 ctl_putdata((void *)a_st, n * sizeof(a_st[0]), 3087 1); 3088 n = 0; 3089 } 3090 } 3091 if (n) 3092 ctl_putdata((void *)a_st, n * sizeof(a_st[0]), 1); 3093 ctl_flushpkt(0); 3094 } 3095 3096 3097 /* 3098 * read_peervars - half of read_variables() implementation 3099 */ 3100 static void 3101 read_peervars(void) 3102 { 3103 const struct ctl_var *v; 3104 struct peer *peer; 3105 const u_char *cp; 3106 size_t i; 3107 char * valuep; 3108 u_char wants[CP_MAXCODE + 1]; 3109 u_int gotvar; 3110 3111 /* 3112 * Wants info for a particular peer. See if we know 3113 * the guy. 3114 */ 3115 peer = findpeerbyassoc(res_associd); 3116 if (NULL == peer) { 3117 ctl_error(CERR_BADASSOC); 3118 return; 3119 } 3120 rpkt.status = htons(ctlpeerstatus(peer)); 3121 if (res_authokay) 3122 peer->num_events = 0; 3123 ZERO(wants); 3124 gotvar = 0; 3125 while (NULL != (v = ctl_getitem(peer_var, &valuep))) { 3126 if (v->flags & EOV) { 3127 ctl_error(CERR_UNKNOWNVAR); 3128 return; 3129 } 3130 INSIST(v->code < COUNTOF(wants)); 3131 wants[v->code] = 1; 3132 gotvar = 1; 3133 } 3134 if (gotvar) { 3135 for (i = 1; i < COUNTOF(wants); i++) 3136 if (wants[i]) 3137 ctl_putpeer(i, peer); 3138 } else 3139 for (cp = def_peer_var; *cp != 0; cp++) 3140 ctl_putpeer((int)*cp, peer); 3141 ctl_flushpkt(0); 3142 } 3143 3144 3145 /* 3146 * read_sysvars - half of read_variables() implementation 3147 */ 3148 static void 3149 read_sysvars(void) 3150 { 3151 const struct ctl_var *v; 3152 struct ctl_var *kv; 3153 u_int n; 3154 u_int gotvar; 3155 const u_char *cs; 3156 char * valuep; 3157 const char * pch; 3158 u_char *wants; 3159 size_t wants_count; 3160 3161 /* 3162 * Wants system variables. Figure out which he wants 3163 * and give them to him. 3164 */ 3165 rpkt.status = htons(ctlsysstatus()); 3166 if (res_authokay) 3167 ctl_sys_num_events = 0; 3168 wants_count = CS_MAXCODE + 1 + count_var(ext_sys_var); 3169 wants = emalloc_zero(wants_count); 3170 gotvar = 0; 3171 while (NULL != (v = ctl_getitem(sys_var, &valuep))) { 3172 if (!(EOV & v->flags)) { 3173 INSIST(v->code < wants_count); 3174 wants[v->code] = 1; 3175 gotvar = 1; 3176 } else { 3177 v = ctl_getitem(ext_sys_var, &valuep); 3178 INSIST(v != NULL); 3179 if (EOV & v->flags) { 3180 ctl_error(CERR_UNKNOWNVAR); 3181 free(wants); 3182 return; 3183 } 3184 n = v->code + CS_MAXCODE + 1; 3185 INSIST(n < wants_count); 3186 wants[n] = 1; 3187 gotvar = 1; 3188 } 3189 } 3190 if (gotvar) { 3191 for (n = 1; n <= CS_MAXCODE; n++) 3192 if (wants[n]) 3193 ctl_putsys(n); 3194 for (n = 0; n + CS_MAXCODE + 1 < wants_count; n++) 3195 if (wants[n + CS_MAXCODE + 1]) { 3196 pch = ext_sys_var[n].text; 3197 ctl_putdata(pch, strlen(pch), 0); 3198 } 3199 } else { 3200 for (cs = def_sys_var; *cs != 0; cs++) 3201 ctl_putsys((int)*cs); 3202 for (kv = ext_sys_var; kv && !(EOV & kv->flags); kv++) 3203 if (DEF & kv->flags) 3204 ctl_putdata(kv->text, strlen(kv->text), 3205 0); 3206 } 3207 free(wants); 3208 ctl_flushpkt(0); 3209 } 3210 3211 3212 /* 3213 * read_variables - return the variables the caller asks for 3214 */ 3215 /*ARGSUSED*/ 3216 static void 3217 read_variables( 3218 struct recvbuf *rbufp, 3219 int restrict_mask 3220 ) 3221 { 3222 if (res_associd) 3223 read_peervars(); 3224 else 3225 read_sysvars(); 3226 } 3227 3228 3229 /* 3230 * write_variables - write into variables. We only allow leap bit 3231 * writing this way. 3232 */ 3233 /*ARGSUSED*/ 3234 static void 3235 write_variables( 3236 struct recvbuf *rbufp, 3237 int restrict_mask 3238 ) 3239 { 3240 const struct ctl_var *v; 3241 int ext_var; 3242 char *valuep; 3243 long val; 3244 size_t octets; 3245 char *vareqv; 3246 const char *t; 3247 char *tt; 3248 3249 val = 0; 3250 /* 3251 * If he's trying to write into a peer tell him no way 3252 */ 3253 if (res_associd != 0) { 3254 ctl_error(CERR_PERMISSION); 3255 return; 3256 } 3257 3258 /* 3259 * Set status 3260 */ 3261 rpkt.status = htons(ctlsysstatus()); 3262 3263 /* 3264 * Look through the variables. Dump out at the first sign of 3265 * trouble. 3266 */ 3267 while ((v = ctl_getitem(sys_var, &valuep)) != 0) { 3268 ext_var = 0; 3269 if (v->flags & EOV) { 3270 if ((v = ctl_getitem(ext_sys_var, &valuep)) != 3271 0) { 3272 if (v->flags & EOV) { 3273 ctl_error(CERR_UNKNOWNVAR); 3274 return; 3275 } 3276 ext_var = 1; 3277 } else { 3278 break; 3279 } 3280 } 3281 if (!(v->flags & CAN_WRITE)) { 3282 ctl_error(CERR_PERMISSION); 3283 return; 3284 } 3285 if (!ext_var && (*valuep == '\0' || !atoint(valuep, 3286 &val))) { 3287 ctl_error(CERR_BADFMT); 3288 return; 3289 } 3290 if (!ext_var && (val & ~LEAP_NOTINSYNC) != 0) { 3291 ctl_error(CERR_BADVALUE); 3292 return; 3293 } 3294 3295 if (ext_var) { 3296 octets = strlen(v->text) + strlen(valuep) + 2; 3297 vareqv = emalloc(octets); 3298 tt = vareqv; 3299 t = v->text; 3300 while (*t && *t != '=') 3301 *tt++ = *t++; 3302 *tt++ = '='; 3303 memcpy(tt, valuep, 1 + strlen(valuep)); 3304 set_sys_var(vareqv, 1 + strlen(vareqv), v->flags); 3305 free(vareqv); 3306 } else { 3307 ctl_error(CERR_UNSPEC); /* really */ 3308 return; 3309 } 3310 } 3311 3312 /* 3313 * If we got anything, do it. xxx nothing to do *** 3314 */ 3315 /* 3316 if (leapind != ~0 || leapwarn != ~0) { 3317 if (!leap_setleap((int)leapind, (int)leapwarn)) { 3318 ctl_error(CERR_PERMISSION); 3319 return; 3320 } 3321 } 3322 */ 3323 ctl_flushpkt(0); 3324 } 3325 3326 3327 /* 3328 * configure() processes ntpq :config/config-from-file, allowing 3329 * generic runtime reconfiguration. 3330 */ 3331 static void configure( 3332 struct recvbuf *rbufp, 3333 int restrict_mask 3334 ) 3335 { 3336 size_t data_count; 3337 int retval; 3338 3339 /* I haven't yet implemented changes to an existing association. 3340 * Hence check if the association id is 0 3341 */ 3342 if (res_associd != 0) { 3343 ctl_error(CERR_BADVALUE); 3344 return; 3345 } 3346 3347 if (RES_NOMODIFY & restrict_mask) { 3348 snprintf(remote_config.err_msg, 3349 sizeof(remote_config.err_msg), 3350 "runtime configuration prohibited by restrict ... nomodify"); 3351 ctl_putdata(remote_config.err_msg, 3352 strlen(remote_config.err_msg), 0); 3353 ctl_flushpkt(0); 3354 NLOG(NLOG_SYSINFO) 3355 msyslog(LOG_NOTICE, 3356 "runtime config from %s rejected due to nomodify restriction", 3357 stoa(&rbufp->recv_srcadr)); 3358 sys_restricted++; 3359 return; 3360 } 3361 3362 /* Initialize the remote config buffer */ 3363 data_count = remoteconfig_cmdlength(reqpt, reqend); 3364 3365 if (data_count > sizeof(remote_config.buffer) - 2) { 3366 snprintf(remote_config.err_msg, 3367 sizeof(remote_config.err_msg), 3368 "runtime configuration failed: request too long"); 3369 ctl_putdata(remote_config.err_msg, 3370 strlen(remote_config.err_msg), 0); 3371 ctl_flushpkt(0); 3372 msyslog(LOG_NOTICE, 3373 "runtime config from %s rejected: request too long", 3374 stoa(&rbufp->recv_srcadr)); 3375 return; 3376 } 3377 /* Bug 2853 -- check if all characters were acceptable */ 3378 if (data_count != (size_t)(reqend - reqpt)) { 3379 snprintf(remote_config.err_msg, 3380 sizeof(remote_config.err_msg), 3381 "runtime configuration failed: request contains an unprintable character"); 3382 ctl_putdata(remote_config.err_msg, 3383 strlen(remote_config.err_msg), 0); 3384 ctl_flushpkt(0); 3385 msyslog(LOG_NOTICE, 3386 "runtime config from %s rejected: request contains an unprintable character: %0x", 3387 stoa(&rbufp->recv_srcadr), 3388 reqpt[data_count]); 3389 return; 3390 } 3391 3392 memcpy(remote_config.buffer, reqpt, data_count); 3393 /* The buffer has no trailing linefeed or NUL right now. For 3394 * logging, we do not want a newline, so we do that first after 3395 * adding the necessary NUL byte. 3396 */ 3397 remote_config.buffer[data_count] = '\0'; 3398 DPRINTF(1, ("Got Remote Configuration Command: %s\n", 3399 remote_config.buffer)); 3400 msyslog(LOG_NOTICE, "%s config: %s", 3401 stoa(&rbufp->recv_srcadr), 3402 remote_config.buffer); 3403 3404 /* Now we have to make sure there is a NL/NUL sequence at the 3405 * end of the buffer before we parse it. 3406 */ 3407 remote_config.buffer[data_count++] = '\n'; 3408 remote_config.buffer[data_count] = '\0'; 3409 remote_config.pos = 0; 3410 remote_config.err_pos = 0; 3411 remote_config.no_errors = 0; 3412 config_remotely(&rbufp->recv_srcadr); 3413 3414 /* 3415 * Check if errors were reported. If not, output 'Config 3416 * Succeeded'. Else output the error count. It would be nice 3417 * to output any parser error messages. 3418 */ 3419 if (0 == remote_config.no_errors) { 3420 retval = snprintf(remote_config.err_msg, 3421 sizeof(remote_config.err_msg), 3422 "Config Succeeded"); 3423 if (retval > 0) 3424 remote_config.err_pos += retval; 3425 } 3426 3427 ctl_putdata(remote_config.err_msg, remote_config.err_pos, 0); 3428 ctl_flushpkt(0); 3429 3430 DPRINTF(1, ("Reply: %s\n", remote_config.err_msg)); 3431 3432 if (remote_config.no_errors > 0) 3433 msyslog(LOG_NOTICE, "%d error in %s config", 3434 remote_config.no_errors, 3435 stoa(&rbufp->recv_srcadr)); 3436 } 3437 3438 3439 /* 3440 * derive_nonce - generate client-address-specific nonce value 3441 * associated with a given timestamp. 3442 */ 3443 static u_int32 derive_nonce( 3444 sockaddr_u * addr, 3445 u_int32 ts_i, 3446 u_int32 ts_f 3447 ) 3448 { 3449 static u_int32 salt[4]; 3450 static u_long last_salt_update; 3451 union d_tag { 3452 u_char digest[EVP_MAX_MD_SIZE]; 3453 u_int32 extract; 3454 } d; 3455 EVP_MD_CTX ctx; 3456 u_int len; 3457 3458 while (!salt[0] || current_time - last_salt_update >= 3600) { 3459 salt[0] = ntp_random(); 3460 salt[1] = ntp_random(); 3461 salt[2] = ntp_random(); 3462 salt[3] = ntp_random(); 3463 last_salt_update = current_time; 3464 } 3465 3466 EVP_DigestInit(&ctx, EVP_get_digestbynid(NID_md5)); 3467 EVP_DigestUpdate(&ctx, salt, sizeof(salt)); 3468 EVP_DigestUpdate(&ctx, &ts_i, sizeof(ts_i)); 3469 EVP_DigestUpdate(&ctx, &ts_f, sizeof(ts_f)); 3470 if (IS_IPV4(addr)) 3471 EVP_DigestUpdate(&ctx, &SOCK_ADDR4(addr), 3472 sizeof(SOCK_ADDR4(addr))); 3473 else 3474 EVP_DigestUpdate(&ctx, &SOCK_ADDR6(addr), 3475 sizeof(SOCK_ADDR6(addr))); 3476 EVP_DigestUpdate(&ctx, &NSRCPORT(addr), sizeof(NSRCPORT(addr))); 3477 EVP_DigestUpdate(&ctx, salt, sizeof(salt)); 3478 EVP_DigestFinal(&ctx, d.digest, &len); 3479 3480 return d.extract; 3481 } 3482 3483 3484 /* 3485 * generate_nonce - generate client-address-specific nonce string. 3486 */ 3487 static void generate_nonce( 3488 struct recvbuf * rbufp, 3489 char * nonce, 3490 size_t nonce_octets 3491 ) 3492 { 3493 u_int32 derived; 3494 3495 derived = derive_nonce(&rbufp->recv_srcadr, 3496 rbufp->recv_time.l_ui, 3497 rbufp->recv_time.l_uf); 3498 snprintf(nonce, nonce_octets, "%08x%08x%08x", 3499 rbufp->recv_time.l_ui, rbufp->recv_time.l_uf, derived); 3500 } 3501 3502 3503 /* 3504 * validate_nonce - validate client-address-specific nonce string. 3505 * 3506 * Returns TRUE if the local calculation of the nonce matches the 3507 * client-provided value and the timestamp is recent enough. 3508 */ 3509 static int validate_nonce( 3510 const char * pnonce, 3511 struct recvbuf * rbufp 3512 ) 3513 { 3514 u_int ts_i; 3515 u_int ts_f; 3516 l_fp ts; 3517 l_fp now_delta; 3518 u_int supposed; 3519 u_int derived; 3520 3521 if (3 != sscanf(pnonce, "%08x%08x%08x", &ts_i, &ts_f, &supposed)) 3522 return FALSE; 3523 3524 ts.l_ui = (u_int32)ts_i; 3525 ts.l_uf = (u_int32)ts_f; 3526 derived = derive_nonce(&rbufp->recv_srcadr, ts.l_ui, ts.l_uf); 3527 get_systime(&now_delta); 3528 L_SUB(&now_delta, &ts); 3529 3530 return (supposed == derived && now_delta.l_ui < 16); 3531 } 3532 3533 3534 /* 3535 * send_random_tag_value - send a randomly-generated three character 3536 * tag prefix, a '.', an index, a '=' and a 3537 * random integer value. 3538 * 3539 * To try to force clients to ignore unrecognized tags in mrulist, 3540 * reslist, and ifstats responses, the first and last rows are spiced 3541 * with randomly-generated tag names with correct .# index. Make it 3542 * three characters knowing that none of the currently-used subscripted 3543 * tags have that length, avoiding the need to test for 3544 * tag collision. 3545 */ 3546 static void 3547 send_random_tag_value( 3548 int indx 3549 ) 3550 { 3551 int noise; 3552 char buf[32]; 3553 3554 noise = rand() ^ (rand() << 16); 3555 buf[0] = 'a' + noise % 26; 3556 noise >>= 5; 3557 buf[1] = 'a' + noise % 26; 3558 noise >>= 5; 3559 buf[2] = 'a' + noise % 26; 3560 noise >>= 5; 3561 buf[3] = '.'; 3562 snprintf(&buf[4], sizeof(buf) - 4, "%d", indx); 3563 ctl_putuint(buf, noise); 3564 } 3565 3566 3567 /* 3568 * Send a MRU list entry in response to a "ntpq -c mrulist" operation. 3569 * 3570 * To keep clients honest about not depending on the order of values, 3571 * and thereby avoid being locked into ugly workarounds to maintain 3572 * backward compatibility later as new fields are added to the response, 3573 * the order is random. 3574 */ 3575 static void 3576 send_mru_entry( 3577 mon_entry * mon, 3578 int count 3579 ) 3580 { 3581 const char first_fmt[] = "first.%d"; 3582 const char ct_fmt[] = "ct.%d"; 3583 const char mv_fmt[] = "mv.%d"; 3584 const char rs_fmt[] = "rs.%d"; 3585 char tag[32]; 3586 u_char sent[6]; /* 6 tag=value pairs */ 3587 u_int32 noise; 3588 u_int which; 3589 u_int remaining; 3590 const char * pch; 3591 3592 remaining = COUNTOF(sent); 3593 ZERO(sent); 3594 noise = (u_int32)(rand() ^ (rand() << 16)); 3595 while (remaining > 0) { 3596 which = (noise & 7) % COUNTOF(sent); 3597 noise >>= 3; 3598 while (sent[which]) 3599 which = (which + 1) % COUNTOF(sent); 3600 3601 switch (which) { 3602 3603 case 0: 3604 snprintf(tag, sizeof(tag), addr_fmt, count); 3605 pch = sptoa(&mon->rmtadr); 3606 ctl_putunqstr(tag, pch, strlen(pch)); 3607 break; 3608 3609 case 1: 3610 snprintf(tag, sizeof(tag), last_fmt, count); 3611 ctl_putts(tag, &mon->last); 3612 break; 3613 3614 case 2: 3615 snprintf(tag, sizeof(tag), first_fmt, count); 3616 ctl_putts(tag, &mon->first); 3617 break; 3618 3619 case 3: 3620 snprintf(tag, sizeof(tag), ct_fmt, count); 3621 ctl_putint(tag, mon->count); 3622 break; 3623 3624 case 4: 3625 snprintf(tag, sizeof(tag), mv_fmt, count); 3626 ctl_putuint(tag, mon->vn_mode); 3627 break; 3628 3629 case 5: 3630 snprintf(tag, sizeof(tag), rs_fmt, count); 3631 ctl_puthex(tag, mon->flags); 3632 break; 3633 } 3634 sent[which] = TRUE; 3635 remaining--; 3636 } 3637 } 3638 3639 3640 /* 3641 * read_mru_list - supports ntpq's mrulist command. 3642 * 3643 * The challenge here is to match ntpdc's monlist functionality without 3644 * being limited to hundreds of entries returned total, and without 3645 * requiring state on the server. If state were required, ntpq's 3646 * mrulist command would require authentication. 3647 * 3648 * The approach was suggested by Ry Jones. A finite and variable number 3649 * of entries are retrieved per request, to avoid having responses with 3650 * such large numbers of packets that socket buffers are overflowed and 3651 * packets lost. The entries are retrieved oldest-first, taking into 3652 * account that the MRU list will be changing between each request. We 3653 * can expect to see duplicate entries for addresses updated in the MRU 3654 * list during the fetch operation. In the end, the client can assemble 3655 * a close approximation of the MRU list at the point in time the last 3656 * response was sent by ntpd. The only difference is it may be longer, 3657 * containing some number of oldest entries which have since been 3658 * reclaimed. If necessary, the protocol could be extended to zap those 3659 * from the client snapshot at the end, but so far that doesn't seem 3660 * useful. 3661 * 3662 * To accomodate the changing MRU list, the starting point for requests 3663 * after the first request is supplied as a series of last seen 3664 * timestamps and associated addresses, the newest ones the client has 3665 * received. As long as at least one of those entries hasn't been 3666 * bumped to the head of the MRU list, ntpd can pick up at that point. 3667 * Otherwise, the request is failed and it is up to ntpq to back up and 3668 * provide the next newest entry's timestamps and addresses, conceivably 3669 * backing up all the way to the starting point. 3670 * 3671 * input parameters: 3672 * nonce= Regurgitated nonce retrieved by the client 3673 * previously using CTL_OP_REQ_NONCE, demonstrating 3674 * ability to receive traffic sent to its address. 3675 * frags= Limit on datagrams (fragments) in response. Used 3676 * by newer ntpq versions instead of limit= when 3677 * retrieving multiple entries. 3678 * limit= Limit on MRU entries returned. One of frags= or 3679 * limit= must be provided. 3680 * limit=1 is a special case: Instead of fetching 3681 * beginning with the supplied starting point's 3682 * newer neighbor, fetch the supplied entry, and 3683 * in that case the #.last timestamp can be zero. 3684 * This enables fetching a single entry by IP 3685 * address. When limit is not one and frags= is 3686 * provided, the fragment limit controls. 3687 * mincount= (decimal) Return entries with count >= mincount. 3688 * laddr= Return entries associated with the server's IP 3689 * address given. No port specification is needed, 3690 * and any supplied is ignored. 3691 * resall= 0x-prefixed hex restrict bits which must all be 3692 * lit for an MRU entry to be included. 3693 * Has precedence over any resany=. 3694 * resany= 0x-prefixed hex restrict bits, at least one of 3695 * which must be list for an MRU entry to be 3696 * included. 3697 * last.0= 0x-prefixed hex l_fp timestamp of newest entry 3698 * which client previously received. 3699 * addr.0= text of newest entry's IP address and port, 3700 * IPv6 addresses in bracketed form: [::]:123 3701 * last.1= timestamp of 2nd newest entry client has. 3702 * addr.1= address of 2nd newest entry. 3703 * [...] 3704 * 3705 * ntpq provides as many last/addr pairs as will fit in a single request 3706 * packet, except for the first request in a MRU fetch operation. 3707 * 3708 * The response begins with a new nonce value to be used for any 3709 * followup request. Following the nonce is the next newer entry than 3710 * referred to by last.0 and addr.0, if the "0" entry has not been 3711 * bumped to the front. If it has, the first entry returned will be the 3712 * next entry newer than referred to by last.1 and addr.1, and so on. 3713 * If none of the referenced entries remain unchanged, the request fails 3714 * and ntpq backs up to the next earlier set of entries to resync. 3715 * 3716 * Except for the first response, the response begins with confirmation 3717 * of the entry that precedes the first additional entry provided: 3718 * 3719 * last.older= hex l_fp timestamp matching one of the input 3720 * .last timestamps, which entry now precedes the 3721 * response 0. entry in the MRU list. 3722 * addr.older= text of address corresponding to older.last. 3723 * 3724 * And in any case, a successful response contains sets of values 3725 * comprising entries, with the oldest numbered 0 and incrementing from 3726 * there: 3727 * 3728 * addr.# text of IPv4 or IPv6 address and port 3729 * last.# hex l_fp timestamp of last receipt 3730 * first.# hex l_fp timestamp of first receipt 3731 * ct.# count of packets received 3732 * mv.# mode and version 3733 * rs.# restriction mask (RES_* bits) 3734 * 3735 * Note the code currently assumes there are no valid three letter 3736 * tags sent with each row, and needs to be adjusted if that changes. 3737 * 3738 * The client should accept the values in any order, and ignore .# 3739 * values which it does not understand, to allow a smooth path to 3740 * future changes without requiring a new opcode. Clients can rely 3741 * on all *.0 values preceding any *.1 values, that is all values for 3742 * a given index number are together in the response. 3743 * 3744 * The end of the response list is noted with one or two tag=value 3745 * pairs. Unconditionally: 3746 * 3747 * now= 0x-prefixed l_fp timestamp at the server marking 3748 * the end of the operation. 3749 * 3750 * If any entries were returned, now= is followed by: 3751 * 3752 * last.newest= hex l_fp identical to last.# of the prior 3753 * entry. 3754 */ 3755 static void read_mru_list( 3756 struct recvbuf *rbufp, 3757 int restrict_mask 3758 ) 3759 { 3760 const char nonce_text[] = "nonce"; 3761 const char frags_text[] = "frags"; 3762 const char limit_text[] = "limit"; 3763 const char mincount_text[] = "mincount"; 3764 const char resall_text[] = "resall"; 3765 const char resany_text[] = "resany"; 3766 const char maxlstint_text[] = "maxlstint"; 3767 const char laddr_text[] = "laddr"; 3768 const char resaxx_fmt[] = "0x%hx"; 3769 u_int limit; 3770 u_short frags; 3771 u_short resall; 3772 u_short resany; 3773 int mincount; 3774 u_int maxlstint; 3775 sockaddr_u laddr; 3776 struct interface * lcladr; 3777 u_int count; 3778 u_int ui; 3779 u_int uf; 3780 l_fp last[16]; 3781 sockaddr_u addr[COUNTOF(last)]; 3782 char buf[128]; 3783 struct ctl_var * in_parms; 3784 const struct ctl_var * v; 3785 char * val; 3786 const char * pch; 3787 char * pnonce; 3788 int nonce_valid; 3789 size_t i; 3790 int priors; 3791 u_short hash; 3792 mon_entry * mon; 3793 mon_entry * prior_mon; 3794 l_fp now; 3795 3796 if (RES_NOMRULIST & restrict_mask) { 3797 ctl_error(CERR_PERMISSION); 3798 NLOG(NLOG_SYSINFO) 3799 msyslog(LOG_NOTICE, 3800 "mrulist from %s rejected due to nomrulist restriction", 3801 stoa(&rbufp->recv_srcadr)); 3802 sys_restricted++; 3803 return; 3804 } 3805 /* 3806 * fill in_parms var list with all possible input parameters. 3807 */ 3808 in_parms = NULL; 3809 set_var(&in_parms, nonce_text, sizeof(nonce_text), 0); 3810 set_var(&in_parms, frags_text, sizeof(frags_text), 0); 3811 set_var(&in_parms, limit_text, sizeof(limit_text), 0); 3812 set_var(&in_parms, mincount_text, sizeof(mincount_text), 0); 3813 set_var(&in_parms, resall_text, sizeof(resall_text), 0); 3814 set_var(&in_parms, resany_text, sizeof(resany_text), 0); 3815 set_var(&in_parms, maxlstint_text, sizeof(maxlstint_text), 0); 3816 set_var(&in_parms, laddr_text, sizeof(laddr_text), 0); 3817 for (i = 0; i < COUNTOF(last); i++) { 3818 snprintf(buf, sizeof(buf), last_fmt, (int)i); 3819 set_var(&in_parms, buf, strlen(buf) + 1, 0); 3820 snprintf(buf, sizeof(buf), addr_fmt, (int)i); 3821 set_var(&in_parms, buf, strlen(buf) + 1, 0); 3822 } 3823 3824 /* decode input parms */ 3825 pnonce = NULL; 3826 frags = 0; 3827 limit = 0; 3828 mincount = 0; 3829 resall = 0; 3830 resany = 0; 3831 maxlstint = 0; 3832 lcladr = NULL; 3833 priors = 0; 3834 ZERO(last); 3835 ZERO(addr); 3836 3837 while (NULL != (v = ctl_getitem(in_parms, &val)) && 3838 !(EOV & v->flags)) { 3839 int si; 3840 3841 if (!strcmp(nonce_text, v->text)) { 3842 if (NULL != pnonce) 3843 free(pnonce); 3844 pnonce = estrdup(val); 3845 } else if (!strcmp(frags_text, v->text)) { 3846 sscanf(val, "%hu", &frags); 3847 } else if (!strcmp(limit_text, v->text)) { 3848 sscanf(val, "%u", &limit); 3849 } else if (!strcmp(mincount_text, v->text)) { 3850 if (1 != sscanf(val, "%d", &mincount) || 3851 mincount < 0) 3852 mincount = 0; 3853 } else if (!strcmp(resall_text, v->text)) { 3854 sscanf(val, resaxx_fmt, &resall); 3855 } else if (!strcmp(resany_text, v->text)) { 3856 sscanf(val, resaxx_fmt, &resany); 3857 } else if (!strcmp(maxlstint_text, v->text)) { 3858 sscanf(val, "%u", &maxlstint); 3859 } else if (!strcmp(laddr_text, v->text)) { 3860 if (decodenetnum(val, &laddr)) 3861 lcladr = getinterface(&laddr, 0); 3862 } else if (1 == sscanf(v->text, last_fmt, &si) && 3863 (size_t)si < COUNTOF(last)) { 3864 if (2 == sscanf(val, "0x%08x.%08x", &ui, &uf)) { 3865 last[si].l_ui = ui; 3866 last[si].l_uf = uf; 3867 if (!SOCK_UNSPEC(&addr[si]) && 3868 si == priors) 3869 priors++; 3870 } 3871 } else if (1 == sscanf(v->text, addr_fmt, &si) && 3872 (size_t)si < COUNTOF(addr)) { 3873 if (decodenetnum(val, &addr[si]) 3874 && last[si].l_ui && last[si].l_uf && 3875 si == priors) 3876 priors++; 3877 } 3878 } 3879 free_varlist(in_parms); 3880 in_parms = NULL; 3881 3882 /* return no responses until the nonce is validated */ 3883 if (NULL == pnonce) 3884 return; 3885 3886 nonce_valid = validate_nonce(pnonce, rbufp); 3887 free(pnonce); 3888 if (!nonce_valid) 3889 return; 3890 3891 if ((0 == frags && !(0 < limit && limit <= MRU_ROW_LIMIT)) || 3892 frags > MRU_FRAGS_LIMIT) { 3893 ctl_error(CERR_BADVALUE); 3894 return; 3895 } 3896 3897 /* 3898 * If either frags or limit is not given, use the max. 3899 */ 3900 if (0 != frags && 0 == limit) 3901 limit = UINT_MAX; 3902 else if (0 != limit && 0 == frags) 3903 frags = MRU_FRAGS_LIMIT; 3904 3905 /* 3906 * Find the starting point if one was provided. 3907 */ 3908 mon = NULL; 3909 for (i = 0; i < (size_t)priors; i++) { 3910 hash = MON_HASH(&addr[i]); 3911 for (mon = mon_hash[hash]; 3912 mon != NULL; 3913 mon = mon->hash_next) 3914 if (ADDR_PORT_EQ(&mon->rmtadr, &addr[i])) 3915 break; 3916 if (mon != NULL) { 3917 if (L_ISEQU(&mon->last, &last[i])) 3918 break; 3919 mon = NULL; 3920 } 3921 } 3922 3923 /* If a starting point was provided... */ 3924 if (priors) { 3925 /* and none could be found unmodified... */ 3926 if (NULL == mon) { 3927 /* tell ntpq to try again with older entries */ 3928 ctl_error(CERR_UNKNOWNVAR); 3929 return; 3930 } 3931 /* confirm the prior entry used as starting point */ 3932 ctl_putts("last.older", &mon->last); 3933 pch = sptoa(&mon->rmtadr); 3934 ctl_putunqstr("addr.older", pch, strlen(pch)); 3935 3936 /* 3937 * Move on to the first entry the client doesn't have, 3938 * except in the special case of a limit of one. In 3939 * that case return the starting point entry. 3940 */ 3941 if (limit > 1) 3942 mon = PREV_DLIST(mon_mru_list, mon, mru); 3943 } else { /* start with the oldest */ 3944 mon = TAIL_DLIST(mon_mru_list, mru); 3945 } 3946 3947 /* 3948 * send up to limit= entries in up to frags= datagrams 3949 */ 3950 get_systime(&now); 3951 generate_nonce(rbufp, buf, sizeof(buf)); 3952 ctl_putunqstr("nonce", buf, strlen(buf)); 3953 prior_mon = NULL; 3954 for (count = 0; 3955 mon != NULL && res_frags < frags && count < limit; 3956 mon = PREV_DLIST(mon_mru_list, mon, mru)) { 3957 3958 if (mon->count < mincount) 3959 continue; 3960 if (resall && resall != (resall & mon->flags)) 3961 continue; 3962 if (resany && !(resany & mon->flags)) 3963 continue; 3964 if (maxlstint > 0 && now.l_ui - mon->last.l_ui > 3965 maxlstint) 3966 continue; 3967 if (lcladr != NULL && mon->lcladr != lcladr) 3968 continue; 3969 3970 send_mru_entry(mon, count); 3971 if (!count) 3972 send_random_tag_value(0); 3973 count++; 3974 prior_mon = mon; 3975 } 3976 3977 /* 3978 * If this batch completes the MRU list, say so explicitly with 3979 * a now= l_fp timestamp. 3980 */ 3981 if (NULL == mon) { 3982 if (count > 1) 3983 send_random_tag_value(count - 1); 3984 ctl_putts("now", &now); 3985 /* if any entries were returned confirm the last */ 3986 if (prior_mon != NULL) 3987 ctl_putts("last.newest", &prior_mon->last); 3988 } 3989 ctl_flushpkt(0); 3990 } 3991 3992 3993 /* 3994 * Send a ifstats entry in response to a "ntpq -c ifstats" request. 3995 * 3996 * To keep clients honest about not depending on the order of values, 3997 * and thereby avoid being locked into ugly workarounds to maintain 3998 * backward compatibility later as new fields are added to the response, 3999 * the order is random. 4000 */ 4001 static void 4002 send_ifstats_entry( 4003 endpt * la, 4004 u_int ifnum 4005 ) 4006 { 4007 const char addr_fmtu[] = "addr.%u"; 4008 const char bcast_fmt[] = "bcast.%u"; 4009 const char en_fmt[] = "en.%u"; /* enabled */ 4010 const char name_fmt[] = "name.%u"; 4011 const char flags_fmt[] = "flags.%u"; 4012 const char tl_fmt[] = "tl.%u"; /* ttl */ 4013 const char mc_fmt[] = "mc.%u"; /* mcast count */ 4014 const char rx_fmt[] = "rx.%u"; 4015 const char tx_fmt[] = "tx.%u"; 4016 const char txerr_fmt[] = "txerr.%u"; 4017 const char pc_fmt[] = "pc.%u"; /* peer count */ 4018 const char up_fmt[] = "up.%u"; /* uptime */ 4019 char tag[32]; 4020 u_char sent[IFSTATS_FIELDS]; /* 12 tag=value pairs */ 4021 int noisebits; 4022 u_int32 noise; 4023 u_int which; 4024 u_int remaining; 4025 const char *pch; 4026 4027 remaining = COUNTOF(sent); 4028 ZERO(sent); 4029 noise = 0; 4030 noisebits = 0; 4031 while (remaining > 0) { 4032 if (noisebits < 4) { 4033 noise = rand() ^ (rand() << 16); 4034 noisebits = 31; 4035 } 4036 which = (noise & 0xf) % COUNTOF(sent); 4037 noise >>= 4; 4038 noisebits -= 4; 4039 4040 while (sent[which]) 4041 which = (which + 1) % COUNTOF(sent); 4042 4043 switch (which) { 4044 4045 case 0: 4046 snprintf(tag, sizeof(tag), addr_fmtu, ifnum); 4047 pch = sptoa(&la->sin); 4048 ctl_putunqstr(tag, pch, strlen(pch)); 4049 break; 4050 4051 case 1: 4052 snprintf(tag, sizeof(tag), bcast_fmt, ifnum); 4053 if (INT_BCASTOPEN & la->flags) 4054 pch = sptoa(&la->bcast); 4055 else 4056 pch = ""; 4057 ctl_putunqstr(tag, pch, strlen(pch)); 4058 break; 4059 4060 case 2: 4061 snprintf(tag, sizeof(tag), en_fmt, ifnum); 4062 ctl_putint(tag, !la->ignore_packets); 4063 break; 4064 4065 case 3: 4066 snprintf(tag, sizeof(tag), name_fmt, ifnum); 4067 ctl_putstr(tag, la->name, strlen(la->name)); 4068 break; 4069 4070 case 4: 4071 snprintf(tag, sizeof(tag), flags_fmt, ifnum); 4072 ctl_puthex(tag, (u_int)la->flags); 4073 break; 4074 4075 case 5: 4076 snprintf(tag, sizeof(tag), tl_fmt, ifnum); 4077 ctl_putint(tag, la->last_ttl); 4078 break; 4079 4080 case 6: 4081 snprintf(tag, sizeof(tag), mc_fmt, ifnum); 4082 ctl_putint(tag, la->num_mcast); 4083 break; 4084 4085 case 7: 4086 snprintf(tag, sizeof(tag), rx_fmt, ifnum); 4087 ctl_putint(tag, la->received); 4088 break; 4089 4090 case 8: 4091 snprintf(tag, sizeof(tag), tx_fmt, ifnum); 4092 ctl_putint(tag, la->sent); 4093 break; 4094 4095 case 9: 4096 snprintf(tag, sizeof(tag), txerr_fmt, ifnum); 4097 ctl_putint(tag, la->notsent); 4098 break; 4099 4100 case 10: 4101 snprintf(tag, sizeof(tag), pc_fmt, ifnum); 4102 ctl_putuint(tag, la->peercnt); 4103 break; 4104 4105 case 11: 4106 snprintf(tag, sizeof(tag), up_fmt, ifnum); 4107 ctl_putuint(tag, current_time - la->starttime); 4108 break; 4109 } 4110 sent[which] = TRUE; 4111 remaining--; 4112 } 4113 send_random_tag_value((int)ifnum); 4114 } 4115 4116 4117 /* 4118 * read_ifstats - send statistics for each local address, exposed by 4119 * ntpq -c ifstats 4120 */ 4121 static void 4122 read_ifstats( 4123 struct recvbuf * rbufp 4124 ) 4125 { 4126 u_int ifidx; 4127 endpt * la; 4128 4129 /* 4130 * loop over [0..sys_ifnum] searching ep_list for each 4131 * ifnum in turn. 4132 */ 4133 for (ifidx = 0; ifidx < sys_ifnum; ifidx++) { 4134 for (la = ep_list; la != NULL; la = la->elink) 4135 if (ifidx == la->ifnum) 4136 break; 4137 if (NULL == la) 4138 continue; 4139 /* return stats for one local address */ 4140 send_ifstats_entry(la, ifidx); 4141 } 4142 ctl_flushpkt(0); 4143 } 4144 4145 static void 4146 sockaddrs_from_restrict_u( 4147 sockaddr_u * psaA, 4148 sockaddr_u * psaM, 4149 restrict_u * pres, 4150 int ipv6 4151 ) 4152 { 4153 ZERO(*psaA); 4154 ZERO(*psaM); 4155 if (!ipv6) { 4156 psaA->sa.sa_family = AF_INET; 4157 psaA->sa4.sin_addr.s_addr = htonl(pres->u.v4.addr); 4158 psaM->sa.sa_family = AF_INET; 4159 psaM->sa4.sin_addr.s_addr = htonl(pres->u.v4.mask); 4160 } else { 4161 psaA->sa.sa_family = AF_INET6; 4162 memcpy(&psaA->sa6.sin6_addr, &pres->u.v6.addr, 4163 sizeof(psaA->sa6.sin6_addr)); 4164 psaM->sa.sa_family = AF_INET6; 4165 memcpy(&psaM->sa6.sin6_addr, &pres->u.v6.mask, 4166 sizeof(psaA->sa6.sin6_addr)); 4167 } 4168 } 4169 4170 4171 /* 4172 * Send a restrict entry in response to a "ntpq -c reslist" request. 4173 * 4174 * To keep clients honest about not depending on the order of values, 4175 * and thereby avoid being locked into ugly workarounds to maintain 4176 * backward compatibility later as new fields are added to the response, 4177 * the order is random. 4178 */ 4179 static void 4180 send_restrict_entry( 4181 restrict_u * pres, 4182 int ipv6, 4183 u_int idx 4184 ) 4185 { 4186 const char addr_fmtu[] = "addr.%u"; 4187 const char mask_fmtu[] = "mask.%u"; 4188 const char hits_fmt[] = "hits.%u"; 4189 const char flags_fmt[] = "flags.%u"; 4190 char tag[32]; 4191 u_char sent[RESLIST_FIELDS]; /* 4 tag=value pairs */ 4192 int noisebits; 4193 u_int32 noise; 4194 u_int which; 4195 u_int remaining; 4196 sockaddr_u addr; 4197 sockaddr_u mask; 4198 const char * pch; 4199 char * buf; 4200 const char * match_str; 4201 const char * access_str; 4202 4203 sockaddrs_from_restrict_u(&addr, &mask, pres, ipv6); 4204 remaining = COUNTOF(sent); 4205 ZERO(sent); 4206 noise = 0; 4207 noisebits = 0; 4208 while (remaining > 0) { 4209 if (noisebits < 2) { 4210 noise = rand() ^ (rand() << 16); 4211 noisebits = 31; 4212 } 4213 which = (noise & 0x3) % COUNTOF(sent); 4214 noise >>= 2; 4215 noisebits -= 2; 4216 4217 while (sent[which]) 4218 which = (which + 1) % COUNTOF(sent); 4219 4220 switch (which) { 4221 4222 case 0: 4223 snprintf(tag, sizeof(tag), addr_fmtu, idx); 4224 pch = stoa(&addr); 4225 ctl_putunqstr(tag, pch, strlen(pch)); 4226 break; 4227 4228 case 1: 4229 snprintf(tag, sizeof(tag), mask_fmtu, idx); 4230 pch = stoa(&mask); 4231 ctl_putunqstr(tag, pch, strlen(pch)); 4232 break; 4233 4234 case 2: 4235 snprintf(tag, sizeof(tag), hits_fmt, idx); 4236 ctl_putuint(tag, pres->count); 4237 break; 4238 4239 case 3: 4240 snprintf(tag, sizeof(tag), flags_fmt, idx); 4241 match_str = res_match_flags(pres->mflags); 4242 access_str = res_access_flags(pres->flags); 4243 if ('\0' == match_str[0]) { 4244 pch = access_str; 4245 } else { 4246 LIB_GETBUF(buf); 4247 snprintf(buf, LIB_BUFLENGTH, "%s %s", 4248 match_str, access_str); 4249 pch = buf; 4250 } 4251 ctl_putunqstr(tag, pch, strlen(pch)); 4252 break; 4253 } 4254 sent[which] = TRUE; 4255 remaining--; 4256 } 4257 send_random_tag_value((int)idx); 4258 } 4259 4260 4261 static void 4262 send_restrict_list( 4263 restrict_u * pres, 4264 int ipv6, 4265 u_int * pidx 4266 ) 4267 { 4268 for ( ; pres != NULL; pres = pres->link) { 4269 send_restrict_entry(pres, ipv6, *pidx); 4270 (*pidx)++; 4271 } 4272 } 4273 4274 4275 /* 4276 * read_addr_restrictions - returns IPv4 and IPv6 access control lists 4277 */ 4278 static void 4279 read_addr_restrictions( 4280 struct recvbuf * rbufp 4281 ) 4282 { 4283 u_int idx; 4284 4285 idx = 0; 4286 send_restrict_list(restrictlist4, FALSE, &idx); 4287 send_restrict_list(restrictlist6, TRUE, &idx); 4288 ctl_flushpkt(0); 4289 } 4290 4291 4292 /* 4293 * read_ordlist - CTL_OP_READ_ORDLIST_A for ntpq -c ifstats & reslist 4294 */ 4295 static void 4296 read_ordlist( 4297 struct recvbuf * rbufp, 4298 int restrict_mask 4299 ) 4300 { 4301 const char ifstats_s[] = "ifstats"; 4302 const size_t ifstats_chars = COUNTOF(ifstats_s) - 1; 4303 const char addr_rst_s[] = "addr_restrictions"; 4304 const size_t a_r_chars = COUNTOF(addr_rst_s) - 1; 4305 struct ntp_control * cpkt; 4306 u_short qdata_octets; 4307 4308 /* 4309 * CTL_OP_READ_ORDLIST_A was first named CTL_OP_READ_IFSTATS and 4310 * used only for ntpq -c ifstats. With the addition of reslist 4311 * the same opcode was generalized to retrieve ordered lists 4312 * which require authentication. The request data is empty or 4313 * contains "ifstats" (not null terminated) to retrieve local 4314 * addresses and associated stats. It is "addr_restrictions" 4315 * to retrieve the IPv4 then IPv6 remote address restrictions, 4316 * which are access control lists. Other request data return 4317 * CERR_UNKNOWNVAR. 4318 */ 4319 cpkt = (struct ntp_control *)&rbufp->recv_pkt; 4320 qdata_octets = ntohs(cpkt->count); 4321 if (0 == qdata_octets || (ifstats_chars == qdata_octets && 4322 !memcmp(ifstats_s, cpkt->u.data, ifstats_chars))) { 4323 read_ifstats(rbufp); 4324 return; 4325 } 4326 if (a_r_chars == qdata_octets && 4327 !memcmp(addr_rst_s, cpkt->u.data, a_r_chars)) { 4328 read_addr_restrictions(rbufp); 4329 return; 4330 } 4331 ctl_error(CERR_UNKNOWNVAR); 4332 } 4333 4334 4335 /* 4336 * req_nonce - CTL_OP_REQ_NONCE for ntpq -c mrulist prerequisite. 4337 */ 4338 static void req_nonce( 4339 struct recvbuf * rbufp, 4340 int restrict_mask 4341 ) 4342 { 4343 char buf[64]; 4344 4345 generate_nonce(rbufp, buf, sizeof(buf)); 4346 ctl_putunqstr("nonce", buf, strlen(buf)); 4347 ctl_flushpkt(0); 4348 } 4349 4350 4351 /* 4352 * read_clockstatus - return clock radio status 4353 */ 4354 /*ARGSUSED*/ 4355 static void 4356 read_clockstatus( 4357 struct recvbuf *rbufp, 4358 int restrict_mask 4359 ) 4360 { 4361 #ifndef REFCLOCK 4362 /* 4363 * If no refclock support, no data to return 4364 */ 4365 ctl_error(CERR_BADASSOC); 4366 #else 4367 const struct ctl_var * v; 4368 int i; 4369 struct peer * peer; 4370 char * valuep; 4371 u_char * wants; 4372 size_t wants_alloc; 4373 int gotvar; 4374 const u_char * cc; 4375 struct ctl_var * kv; 4376 struct refclockstat cs; 4377 4378 if (res_associd != 0) { 4379 peer = findpeerbyassoc(res_associd); 4380 } else { 4381 /* 4382 * Find a clock for this jerk. If the system peer 4383 * is a clock use it, else search peer_list for one. 4384 */ 4385 if (sys_peer != NULL && (FLAG_REFCLOCK & 4386 sys_peer->flags)) 4387 peer = sys_peer; 4388 else 4389 for (peer = peer_list; 4390 peer != NULL; 4391 peer = peer->p_link) 4392 if (FLAG_REFCLOCK & peer->flags) 4393 break; 4394 } 4395 if (NULL == peer || !(FLAG_REFCLOCK & peer->flags)) { 4396 ctl_error(CERR_BADASSOC); 4397 return; 4398 } 4399 /* 4400 * If we got here we have a peer which is a clock. Get his 4401 * status. 4402 */ 4403 cs.kv_list = NULL; 4404 refclock_control(&peer->srcadr, NULL, &cs); 4405 kv = cs.kv_list; 4406 /* 4407 * Look for variables in the packet. 4408 */ 4409 rpkt.status = htons(ctlclkstatus(&cs)); 4410 wants_alloc = CC_MAXCODE + 1 + count_var(kv); 4411 wants = emalloc_zero(wants_alloc); 4412 gotvar = FALSE; 4413 while (NULL != (v = ctl_getitem(clock_var, &valuep))) { 4414 if (!(EOV & v->flags)) { 4415 wants[v->code] = TRUE; 4416 gotvar = TRUE; 4417 } else { 4418 v = ctl_getitem(kv, &valuep); 4419 INSIST(NULL != v); 4420 if (EOV & v->flags) { 4421 ctl_error(CERR_UNKNOWNVAR); 4422 free(wants); 4423 free_varlist(cs.kv_list); 4424 return; 4425 } 4426 wants[CC_MAXCODE + 1 + v->code] = TRUE; 4427 gotvar = TRUE; 4428 } 4429 } 4430 4431 if (gotvar) { 4432 for (i = 1; i <= CC_MAXCODE; i++) 4433 if (wants[i]) 4434 ctl_putclock(i, &cs, TRUE); 4435 if (kv != NULL) 4436 for (i = 0; !(EOV & kv[i].flags); i++) 4437 if (wants[i + CC_MAXCODE + 1]) 4438 ctl_putdata(kv[i].text, 4439 strlen(kv[i].text), 4440 FALSE); 4441 } else { 4442 for (cc = def_clock_var; *cc != 0; cc++) 4443 ctl_putclock((int)*cc, &cs, FALSE); 4444 for ( ; kv != NULL && !(EOV & kv->flags); kv++) 4445 if (DEF & kv->flags) 4446 ctl_putdata(kv->text, strlen(kv->text), 4447 FALSE); 4448 } 4449 4450 free(wants); 4451 free_varlist(cs.kv_list); 4452 4453 ctl_flushpkt(0); 4454 #endif 4455 } 4456 4457 4458 /* 4459 * write_clockstatus - we don't do this 4460 */ 4461 /*ARGSUSED*/ 4462 static void 4463 write_clockstatus( 4464 struct recvbuf *rbufp, 4465 int restrict_mask 4466 ) 4467 { 4468 ctl_error(CERR_PERMISSION); 4469 } 4470 4471 /* 4472 * Trap support from here on down. We send async trap messages when the 4473 * upper levels report trouble. Traps can by set either by control 4474 * messages or by configuration. 4475 */ 4476 /* 4477 * set_trap - set a trap in response to a control message 4478 */ 4479 static void 4480 set_trap( 4481 struct recvbuf *rbufp, 4482 int restrict_mask 4483 ) 4484 { 4485 int traptype; 4486 4487 /* 4488 * See if this guy is allowed 4489 */ 4490 if (restrict_mask & RES_NOTRAP) { 4491 ctl_error(CERR_PERMISSION); 4492 return; 4493 } 4494 4495 /* 4496 * Determine his allowed trap type. 4497 */ 4498 traptype = TRAP_TYPE_PRIO; 4499 if (restrict_mask & RES_LPTRAP) 4500 traptype = TRAP_TYPE_NONPRIO; 4501 4502 /* 4503 * Call ctlsettrap() to do the work. Return 4504 * an error if it can't assign the trap. 4505 */ 4506 if (!ctlsettrap(&rbufp->recv_srcadr, rbufp->dstadr, traptype, 4507 (int)res_version)) 4508 ctl_error(CERR_NORESOURCE); 4509 ctl_flushpkt(0); 4510 } 4511 4512 4513 /* 4514 * unset_trap - unset a trap in response to a control message 4515 */ 4516 static void 4517 unset_trap( 4518 struct recvbuf *rbufp, 4519 int restrict_mask 4520 ) 4521 { 4522 int traptype; 4523 4524 /* 4525 * We don't prevent anyone from removing his own trap unless the 4526 * trap is configured. Note we also must be aware of the 4527 * possibility that restriction flags were changed since this 4528 * guy last set his trap. Set the trap type based on this. 4529 */ 4530 traptype = TRAP_TYPE_PRIO; 4531 if (restrict_mask & RES_LPTRAP) 4532 traptype = TRAP_TYPE_NONPRIO; 4533 4534 /* 4535 * Call ctlclrtrap() to clear this out. 4536 */ 4537 if (!ctlclrtrap(&rbufp->recv_srcadr, rbufp->dstadr, traptype)) 4538 ctl_error(CERR_BADASSOC); 4539 ctl_flushpkt(0); 4540 } 4541 4542 4543 /* 4544 * ctlsettrap - called to set a trap 4545 */ 4546 int 4547 ctlsettrap( 4548 sockaddr_u *raddr, 4549 struct interface *linter, 4550 int traptype, 4551 int version 4552 ) 4553 { 4554 size_t n; 4555 struct ctl_trap *tp; 4556 struct ctl_trap *tptouse; 4557 4558 /* 4559 * See if we can find this trap. If so, we only need update 4560 * the flags and the time. 4561 */ 4562 if ((tp = ctlfindtrap(raddr, linter)) != NULL) { 4563 switch (traptype) { 4564 4565 case TRAP_TYPE_CONFIG: 4566 tp->tr_flags = TRAP_INUSE|TRAP_CONFIGURED; 4567 break; 4568 4569 case TRAP_TYPE_PRIO: 4570 if (tp->tr_flags & TRAP_CONFIGURED) 4571 return (1); /* don't change anything */ 4572 tp->tr_flags = TRAP_INUSE; 4573 break; 4574 4575 case TRAP_TYPE_NONPRIO: 4576 if (tp->tr_flags & TRAP_CONFIGURED) 4577 return (1); /* don't change anything */ 4578 tp->tr_flags = TRAP_INUSE|TRAP_NONPRIO; 4579 break; 4580 } 4581 tp->tr_settime = current_time; 4582 tp->tr_resets++; 4583 return (1); 4584 } 4585 4586 /* 4587 * First we heard of this guy. Try to find a trap structure 4588 * for him to use, clearing out lesser priority guys if we 4589 * have to. Clear out anyone who's expired while we're at it. 4590 */ 4591 tptouse = NULL; 4592 for (n = 0; n < COUNTOF(ctl_traps); n++) { 4593 tp = &ctl_traps[n]; 4594 if ((TRAP_INUSE & tp->tr_flags) && 4595 !(TRAP_CONFIGURED & tp->tr_flags) && 4596 ((tp->tr_settime + CTL_TRAPTIME) > current_time)) { 4597 tp->tr_flags = 0; 4598 num_ctl_traps--; 4599 } 4600 if (!(TRAP_INUSE & tp->tr_flags)) { 4601 tptouse = tp; 4602 } else if (!(TRAP_CONFIGURED & tp->tr_flags)) { 4603 switch (traptype) { 4604 4605 case TRAP_TYPE_CONFIG: 4606 if (tptouse == NULL) { 4607 tptouse = tp; 4608 break; 4609 } 4610 if ((TRAP_NONPRIO & tptouse->tr_flags) && 4611 !(TRAP_NONPRIO & tp->tr_flags)) 4612 break; 4613 4614 if (!(TRAP_NONPRIO & tptouse->tr_flags) 4615 && (TRAP_NONPRIO & tp->tr_flags)) { 4616 tptouse = tp; 4617 break; 4618 } 4619 if (tptouse->tr_origtime < 4620 tp->tr_origtime) 4621 tptouse = tp; 4622 break; 4623 4624 case TRAP_TYPE_PRIO: 4625 if ( TRAP_NONPRIO & tp->tr_flags) { 4626 if (tptouse == NULL || 4627 ((TRAP_INUSE & 4628 tptouse->tr_flags) && 4629 tptouse->tr_origtime < 4630 tp->tr_origtime)) 4631 tptouse = tp; 4632 } 4633 break; 4634 4635 case TRAP_TYPE_NONPRIO: 4636 break; 4637 } 4638 } 4639 } 4640 4641 /* 4642 * If we don't have room for him return an error. 4643 */ 4644 if (tptouse == NULL) 4645 return (0); 4646 4647 /* 4648 * Set up this structure for him. 4649 */ 4650 tptouse->tr_settime = tptouse->tr_origtime = current_time; 4651 tptouse->tr_count = tptouse->tr_resets = 0; 4652 tptouse->tr_sequence = 1; 4653 tptouse->tr_addr = *raddr; 4654 tptouse->tr_localaddr = linter; 4655 tptouse->tr_version = (u_char) version; 4656 tptouse->tr_flags = TRAP_INUSE; 4657 if (traptype == TRAP_TYPE_CONFIG) 4658 tptouse->tr_flags |= TRAP_CONFIGURED; 4659 else if (traptype == TRAP_TYPE_NONPRIO) 4660 tptouse->tr_flags |= TRAP_NONPRIO; 4661 num_ctl_traps++; 4662 return (1); 4663 } 4664 4665 4666 /* 4667 * ctlclrtrap - called to clear a trap 4668 */ 4669 int 4670 ctlclrtrap( 4671 sockaddr_u *raddr, 4672 struct interface *linter, 4673 int traptype 4674 ) 4675 { 4676 register struct ctl_trap *tp; 4677 4678 if ((tp = ctlfindtrap(raddr, linter)) == NULL) 4679 return (0); 4680 4681 if (tp->tr_flags & TRAP_CONFIGURED 4682 && traptype != TRAP_TYPE_CONFIG) 4683 return (0); 4684 4685 tp->tr_flags = 0; 4686 num_ctl_traps--; 4687 return (1); 4688 } 4689 4690 4691 /* 4692 * ctlfindtrap - find a trap given the remote and local addresses 4693 */ 4694 static struct ctl_trap * 4695 ctlfindtrap( 4696 sockaddr_u *raddr, 4697 struct interface *linter 4698 ) 4699 { 4700 size_t n; 4701 4702 for (n = 0; n < COUNTOF(ctl_traps); n++) 4703 if ((ctl_traps[n].tr_flags & TRAP_INUSE) 4704 && ADDR_PORT_EQ(raddr, &ctl_traps[n].tr_addr) 4705 && (linter == ctl_traps[n].tr_localaddr)) 4706 return &ctl_traps[n]; 4707 4708 return NULL; 4709 } 4710 4711 4712 /* 4713 * report_event - report an event to the trappers 4714 */ 4715 void 4716 report_event( 4717 int err, /* error code */ 4718 struct peer *peer, /* peer structure pointer */ 4719 const char *str /* protostats string */ 4720 ) 4721 { 4722 char statstr[NTP_MAXSTRLEN]; 4723 int i; 4724 size_t len; 4725 4726 /* 4727 * Report the error to the protostats file, system log and 4728 * trappers. 4729 */ 4730 if (peer == NULL) { 4731 4732 /* 4733 * Discard a system report if the number of reports of 4734 * the same type exceeds the maximum. 4735 */ 4736 if (ctl_sys_last_event != (u_char)err) 4737 ctl_sys_num_events= 0; 4738 if (ctl_sys_num_events >= CTL_SYS_MAXEVENTS) 4739 return; 4740 4741 ctl_sys_last_event = (u_char)err; 4742 ctl_sys_num_events++; 4743 snprintf(statstr, sizeof(statstr), 4744 "0.0.0.0 %04x %02x %s", 4745 ctlsysstatus(), err, eventstr(err)); 4746 if (str != NULL) { 4747 len = strlen(statstr); 4748 snprintf(statstr + len, sizeof(statstr) - len, 4749 " %s", str); 4750 } 4751 NLOG(NLOG_SYSEVENT) 4752 msyslog(LOG_INFO, "%s", statstr); 4753 } else { 4754 4755 /* 4756 * Discard a peer report if the number of reports of 4757 * the same type exceeds the maximum for that peer. 4758 */ 4759 const char * src; 4760 u_char errlast; 4761 4762 errlast = (u_char)err & ~PEER_EVENT; 4763 if (peer->last_event == errlast) 4764 peer->num_events = 0; 4765 if (peer->num_events >= CTL_PEER_MAXEVENTS) 4766 return; 4767 4768 peer->last_event = errlast; 4769 peer->num_events++; 4770 if (ISREFCLOCKADR(&peer->srcadr)) 4771 src = refnumtoa(&peer->srcadr); 4772 else 4773 src = stoa(&peer->srcadr); 4774 4775 snprintf(statstr, sizeof(statstr), 4776 "%s %04x %02x %s", src, 4777 ctlpeerstatus(peer), err, eventstr(err)); 4778 if (str != NULL) { 4779 len = strlen(statstr); 4780 snprintf(statstr + len, sizeof(statstr) - len, 4781 " %s", str); 4782 } 4783 NLOG(NLOG_PEEREVENT) 4784 msyslog(LOG_INFO, "%s", statstr); 4785 } 4786 record_proto_stats(statstr); 4787 #if DEBUG 4788 if (debug) 4789 printf("event at %lu %s\n", current_time, statstr); 4790 #endif 4791 4792 /* 4793 * If no trappers, return. 4794 */ 4795 if (num_ctl_traps <= 0) 4796 return; 4797 4798 /* 4799 * Set up the outgoing packet variables 4800 */ 4801 res_opcode = CTL_OP_ASYNCMSG; 4802 res_offset = 0; 4803 res_async = TRUE; 4804 res_authenticate = FALSE; 4805 datapt = rpkt.u.data; 4806 dataend = &rpkt.u.data[CTL_MAX_DATA_LEN]; 4807 if (!(err & PEER_EVENT)) { 4808 rpkt.associd = 0; 4809 rpkt.status = htons(ctlsysstatus()); 4810 4811 /* Include the core system variables and the list. */ 4812 for (i = 1; i <= CS_VARLIST; i++) 4813 ctl_putsys(i); 4814 } else { 4815 INSIST(peer != NULL); 4816 rpkt.associd = htons(peer->associd); 4817 rpkt.status = htons(ctlpeerstatus(peer)); 4818 4819 /* Dump it all. Later, maybe less. */ 4820 for (i = 1; i <= CP_MAX_NOAUTOKEY; i++) 4821 ctl_putpeer(i, peer); 4822 #ifdef REFCLOCK 4823 /* 4824 * for clock exception events: add clock variables to 4825 * reflect info on exception 4826 */ 4827 if (err == PEVNT_CLOCK) { 4828 struct refclockstat cs; 4829 struct ctl_var *kv; 4830 4831 cs.kv_list = NULL; 4832 refclock_control(&peer->srcadr, NULL, &cs); 4833 4834 ctl_puthex("refclockstatus", 4835 ctlclkstatus(&cs)); 4836 4837 for (i = 1; i <= CC_MAXCODE; i++) 4838 ctl_putclock(i, &cs, FALSE); 4839 for (kv = cs.kv_list; 4840 kv != NULL && !(EOV & kv->flags); 4841 kv++) 4842 if (DEF & kv->flags) 4843 ctl_putdata(kv->text, 4844 strlen(kv->text), 4845 FALSE); 4846 free_varlist(cs.kv_list); 4847 } 4848 #endif /* REFCLOCK */ 4849 } 4850 4851 /* 4852 * We're done, return. 4853 */ 4854 ctl_flushpkt(0); 4855 } 4856 4857 4858 /* 4859 * mprintf_event - printf-style varargs variant of report_event() 4860 */ 4861 int 4862 mprintf_event( 4863 int evcode, /* event code */ 4864 struct peer * p, /* may be NULL */ 4865 const char * fmt, /* msnprintf format */ 4866 ... 4867 ) 4868 { 4869 va_list ap; 4870 int rc; 4871 char msg[512]; 4872 4873 va_start(ap, fmt); 4874 rc = mvsnprintf(msg, sizeof(msg), fmt, ap); 4875 va_end(ap); 4876 report_event(evcode, p, msg); 4877 4878 return rc; 4879 } 4880 4881 4882 /* 4883 * ctl_clr_stats - clear stat counters 4884 */ 4885 void 4886 ctl_clr_stats(void) 4887 { 4888 ctltimereset = current_time; 4889 numctlreq = 0; 4890 numctlbadpkts = 0; 4891 numctlresponses = 0; 4892 numctlfrags = 0; 4893 numctlerrors = 0; 4894 numctlfrags = 0; 4895 numctltooshort = 0; 4896 numctlinputresp = 0; 4897 numctlinputfrag = 0; 4898 numctlinputerr = 0; 4899 numctlbadoffset = 0; 4900 numctlbadversion = 0; 4901 numctldatatooshort = 0; 4902 numctlbadop = 0; 4903 numasyncmsgs = 0; 4904 } 4905 4906 static u_short 4907 count_var( 4908 const struct ctl_var *k 4909 ) 4910 { 4911 u_int c; 4912 4913 if (NULL == k) 4914 return 0; 4915 4916 c = 0; 4917 while (!(EOV & (k++)->flags)) 4918 c++; 4919 4920 ENSURE(c <= USHRT_MAX); 4921 return (u_short)c; 4922 } 4923 4924 4925 char * 4926 add_var( 4927 struct ctl_var **kv, 4928 u_long size, 4929 u_short def 4930 ) 4931 { 4932 u_short c; 4933 struct ctl_var *k; 4934 char * buf; 4935 4936 c = count_var(*kv); 4937 *kv = erealloc(*kv, (c + 2) * sizeof(**kv)); 4938 k = *kv; 4939 buf = emalloc(size); 4940 k[c].code = c; 4941 k[c].text = buf; 4942 k[c].flags = def; 4943 k[c + 1].code = 0; 4944 k[c + 1].text = NULL; 4945 k[c + 1].flags = EOV; 4946 4947 return buf; 4948 } 4949 4950 4951 void 4952 set_var( 4953 struct ctl_var **kv, 4954 const char *data, 4955 u_long size, 4956 u_short def 4957 ) 4958 { 4959 struct ctl_var *k; 4960 const char *s; 4961 const char *t; 4962 char *td; 4963 4964 if (NULL == data || !size) 4965 return; 4966 4967 k = *kv; 4968 if (k != NULL) { 4969 while (!(EOV & k->flags)) { 4970 if (NULL == k->text) { 4971 td = emalloc(size); 4972 memcpy(td, data, size); 4973 k->text = td; 4974 k->flags = def; 4975 return; 4976 } else { 4977 s = data; 4978 t = k->text; 4979 while (*t != '=' && *s == *t) { 4980 s++; 4981 t++; 4982 } 4983 if (*s == *t && ((*t == '=') || !*t)) { 4984 td = erealloc((void *)(intptr_t)k->text, size); 4985 memcpy(td, data, size); 4986 k->text = td; 4987 k->flags = def; 4988 return; 4989 } 4990 } 4991 k++; 4992 } 4993 } 4994 td = add_var(kv, size, def); 4995 memcpy(td, data, size); 4996 } 4997 4998 4999 void 5000 set_sys_var( 5001 const char *data, 5002 u_long size, 5003 u_short def 5004 ) 5005 { 5006 set_var(&ext_sys_var, data, size, def); 5007 } 5008 5009 5010 /* 5011 * get_ext_sys_var() retrieves the value of a user-defined variable or 5012 * NULL if the variable has not been setvar'd. 5013 */ 5014 const char * 5015 get_ext_sys_var(const char *tag) 5016 { 5017 struct ctl_var * v; 5018 size_t c; 5019 const char * val; 5020 5021 val = NULL; 5022 c = strlen(tag); 5023 for (v = ext_sys_var; !(EOV & v->flags); v++) { 5024 if (NULL != v->text && !memcmp(tag, v->text, c)) { 5025 if ('=' == v->text[c]) { 5026 val = v->text + c + 1; 5027 break; 5028 } else if ('\0' == v->text[c]) { 5029 val = ""; 5030 break; 5031 } 5032 } 5033 } 5034 5035 return val; 5036 } 5037 5038 5039 void 5040 free_varlist( 5041 struct ctl_var *kv 5042 ) 5043 { 5044 struct ctl_var *k; 5045 if (kv) { 5046 for (k = kv; !(k->flags & EOV); k++) 5047 free((void *)(intptr_t)k->text); 5048 free((void *)kv); 5049 } 5050 } 5051