ntpq-subs.c revision 1.1.1.14
1 /* 2 * ntpq-subs.c - subroutines which are called to perform ntpq commands. 3 */ 4 #include <config.h> 5 #include <stdio.h> 6 #include <ctype.h> 7 #include <sys/types.h> 8 #include <sys/time.h> 9 10 #include "ntpq.h" 11 #include "ntpq-opts.h" 12 13 extern char currenthost[]; 14 extern int currenthostisnum; 15 size_t maxhostlen; 16 17 /* 18 * Declarations for command handlers in here 19 */ 20 static associd_t checkassocid (u_int32); 21 static struct varlist *findlistvar (struct varlist *, char *); 22 static void doaddvlist (struct varlist *, const char *); 23 static void dormvlist (struct varlist *, const char *); 24 static void doclearvlist (struct varlist *); 25 static void makequerydata (struct varlist *, size_t *, char *); 26 static int doquerylist (struct varlist *, int, associd_t, int, 27 u_short *, size_t *, const char **); 28 static void doprintvlist (struct varlist *, FILE *); 29 static void addvars (struct parse *, FILE *); 30 static void rmvars (struct parse *, FILE *); 31 static void clearvars (struct parse *, FILE *); 32 static void showvars (struct parse *, FILE *); 33 static int dolist (struct varlist *, associd_t, int, int, 34 FILE *); 35 static void readlist (struct parse *, FILE *); 36 static void writelist (struct parse *, FILE *); 37 static void readvar (struct parse *, FILE *); 38 static void writevar (struct parse *, FILE *); 39 static void clocklist (struct parse *, FILE *); 40 static void clockvar (struct parse *, FILE *); 41 static int findassidrange (u_int32, u_int32, int *, int *, 42 FILE *); 43 static void mreadlist (struct parse *, FILE *); 44 static void mreadvar (struct parse *, FILE *); 45 static void printassoc (int, FILE *); 46 static void associations (struct parse *, FILE *); 47 static void lassociations (struct parse *, FILE *); 48 static void passociations (struct parse *, FILE *); 49 static void lpassociations (struct parse *, FILE *); 50 51 #ifdef UNUSED 52 static void radiostatus (struct parse *, FILE *); 53 #endif /* UNUSED */ 54 55 static void authinfo (struct parse *, FILE *); 56 static void pstats (struct parse *, FILE *); 57 static long when (l_fp *, l_fp *, l_fp *); 58 static char * prettyinterval (char *, size_t, long); 59 static int doprintpeers (struct varlist *, int, int, size_t, const char *, FILE *, int); 60 static int dogetpeers (struct varlist *, associd_t, FILE *, int); 61 static void dopeers (int, FILE *, int); 62 static void peers (struct parse *, FILE *); 63 static void doapeers (int, FILE *, int); 64 static void apeers (struct parse *, FILE *); 65 static void lpeers (struct parse *, FILE *); 66 static void doopeers (int, FILE *, int); 67 static void opeers (struct parse *, FILE *); 68 static void lopeers (struct parse *, FILE *); 69 static void config (struct parse *, FILE *); 70 static void saveconfig (struct parse *, FILE *); 71 static void config_from_file(struct parse *, FILE *); 72 static void mrulist (struct parse *, FILE *); 73 static void ifstats (struct parse *, FILE *); 74 static void reslist (struct parse *, FILE *); 75 static void sysstats (struct parse *, FILE *); 76 static void sysinfo (struct parse *, FILE *); 77 static void kerninfo (struct parse *, FILE *); 78 static void monstats (struct parse *, FILE *); 79 static void iostats (struct parse *, FILE *); 80 static void timerstats (struct parse *, FILE *); 81 82 /* 83 * Commands we understand. Ntpdc imports this. 84 */ 85 struct xcmd opcmds[] = { 86 { "saveconfig", saveconfig, { NTP_STR, NO, NO, NO }, 87 { "filename", "", "", ""}, 88 "save ntpd configuration to file, . for current config file"}, 89 { "associations", associations, { NO, NO, NO, NO }, 90 { "", "", "", "" }, 91 "print list of association ID's and statuses for the server's peers" }, 92 { "passociations", passociations, { NO, NO, NO, NO }, 93 { "", "", "", "" }, 94 "print list of associations returned by last associations command" }, 95 { "lassociations", lassociations, { NO, NO, NO, NO }, 96 { "", "", "", "" }, 97 "print list of associations including all client information" }, 98 { "lpassociations", lpassociations, { NO, NO, NO, NO }, 99 { "", "", "", "" }, 100 "print last obtained list of associations, including client information" }, 101 { "addvars", addvars, { NTP_STR, NO, NO, NO }, 102 { "name[=value][,...]", "", "", "" }, 103 "add variables to the variable list or change their values" }, 104 { "rmvars", rmvars, { NTP_STR, NO, NO, NO }, 105 { "name[,...]", "", "", "" }, 106 "remove variables from the variable list" }, 107 { "clearvars", clearvars, { NO, NO, NO, NO }, 108 { "", "", "", "" }, 109 "remove all variables from the variable list" }, 110 { "showvars", showvars, { NO, NO, NO, NO }, 111 { "", "", "", "" }, 112 "print variables on the variable list" }, 113 { "readlist", readlist, { OPT|NTP_UINT, NO, NO, NO }, 114 { "assocID", "", "", "" }, 115 "read the system or peer variables included in the variable list" }, 116 { "rl", readlist, { OPT|NTP_UINT, NO, NO, NO }, 117 { "assocID", "", "", "" }, 118 "read the system or peer variables included in the variable list" }, 119 { "writelist", writelist, { OPT|NTP_UINT, NO, NO, NO }, 120 { "assocID", "", "", "" }, 121 "write the system or peer variables included in the variable list" }, 122 { "readvar", readvar, { OPT|NTP_UINT, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR, }, 123 { "assocID", "varname1", "varname2", "varname3" }, 124 "read system or peer variables" }, 125 { "rv", readvar, { OPT|NTP_UINT, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR, }, 126 { "assocID", "varname1", "varname2", "varname3" }, 127 "read system or peer variables" }, 128 { "writevar", writevar, { NTP_UINT, NTP_STR, NO, NO }, 129 { "assocID", "name=value,[...]", "", "" }, 130 "write system or peer variables" }, 131 { "mreadlist", mreadlist, { NTP_UINT, NTP_UINT, NO, NO }, 132 { "assocIDlow", "assocIDhigh", "", "" }, 133 "read the peer variables in the variable list for multiple peers" }, 134 { "mrl", mreadlist, { NTP_UINT, NTP_UINT, NO, NO }, 135 { "assocIDlow", "assocIDhigh", "", "" }, 136 "read the peer variables in the variable list for multiple peers" }, 137 { "mreadvar", mreadvar, { NTP_UINT, NTP_UINT, OPT|NTP_STR, NO }, 138 { "assocIDlow", "assocIDhigh", "name=value[,...]", "" }, 139 "read peer variables from multiple peers" }, 140 { "mrv", mreadvar, { NTP_UINT, NTP_UINT, OPT|NTP_STR, NO }, 141 { "assocIDlow", "assocIDhigh", "name=value[,...]", "" }, 142 "read peer variables from multiple peers" }, 143 { "clocklist", clocklist, { OPT|NTP_UINT, NO, NO, NO }, 144 { "assocID", "", "", "" }, 145 "read the clock variables included in the variable list" }, 146 { "cl", clocklist, { OPT|NTP_UINT, NO, NO, NO }, 147 { "assocID", "", "", "" }, 148 "read the clock variables included in the variable list" }, 149 { "clockvar", clockvar, { OPT|NTP_UINT, OPT|NTP_STR, NO, NO }, 150 { "assocID", "name=value[,...]", "", "" }, 151 "read clock variables" }, 152 { "cv", clockvar, { OPT|NTP_UINT, OPT|NTP_STR, NO, NO }, 153 { "assocID", "name=value[,...]", "", "" }, 154 "read clock variables" }, 155 { "pstats", pstats, { NTP_UINT, NO, NO, NO }, 156 { "assocID", "", "", "" }, 157 "show statistics for a peer" }, 158 { "peers", peers, { OPT|IP_VERSION, NO, NO, NO }, 159 { "-4|-6", "", "", "" }, 160 "obtain and print a list of the server's peers [IP version]" }, 161 { "apeers", apeers, { OPT|IP_VERSION, NO, NO, NO }, 162 { "-4|-6", "", "", "" }, 163 "obtain and print a list of the server's peers and their assocIDs [IP version]" }, 164 { "lpeers", lpeers, { OPT|IP_VERSION, NO, NO, NO }, 165 { "-4|-6", "", "", "" }, 166 "obtain and print a list of all peers and clients [IP version]" }, 167 { "opeers", opeers, { OPT|IP_VERSION, NO, NO, NO }, 168 { "-4|-6", "", "", "" }, 169 "print peer list the old way, with dstadr shown rather than refid [IP version]" }, 170 { "lopeers", lopeers, { OPT|IP_VERSION, NO, NO, NO }, 171 { "-4|-6", "", "", "" }, 172 "obtain and print a list of all peers and clients showing dstadr [IP version]" }, 173 { ":config", config, { NTP_STR, NO, NO, NO }, 174 { "<configuration command line>", "", "", "" }, 175 "send a remote configuration command to ntpd" }, 176 { "config-from-file", config_from_file, { NTP_STR, NO, NO, NO }, 177 { "<configuration filename>", "", "", "" }, 178 "configure ntpd using the configuration filename" }, 179 { "mrulist", mrulist, { OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR }, 180 { "tag=value", "tag=value", "tag=value", "tag=value" }, 181 "display the list of most recently seen source addresses, tags mincount=... resall=0x... resany=0x..." }, 182 { "ifstats", ifstats, { NO, NO, NO, NO }, 183 { "", "", "", "" }, 184 "show statistics for each local address ntpd is using" }, 185 { "reslist", reslist, { NO, NO, NO, NO }, 186 { "", "", "", "" }, 187 "show ntpd access control list" }, 188 { "sysinfo", sysinfo, { NO, NO, NO, NO }, 189 { "", "", "", "" }, 190 "display system summary" }, 191 { "kerninfo", kerninfo, { NO, NO, NO, NO }, 192 { "", "", "", "" }, 193 "display kernel loop and PPS statistics" }, 194 { "sysstats", sysstats, { NO, NO, NO, NO }, 195 { "", "", "", "" }, 196 "display system uptime and packet counts" }, 197 { "monstats", monstats, { NO, NO, NO, NO }, 198 { "", "", "", "" }, 199 "display monitor (mrulist) counters and limits" }, 200 { "authinfo", authinfo, { NO, NO, NO, NO }, 201 { "", "", "", "" }, 202 "display symmetric authentication counters" }, 203 { "iostats", iostats, { NO, NO, NO, NO }, 204 { "", "", "", "" }, 205 "display network input and output counters" }, 206 { "timerstats", timerstats, { NO, NO, NO, NO }, 207 { "", "", "", "" }, 208 "display interval timer counters" }, 209 { 0, 0, { NO, NO, NO, NO }, 210 { "-4|-6", "", "", "" }, "" } 211 }; 212 213 214 /* 215 * Variable list data space 216 */ 217 #define MAXLINE 512 /* maximum length of a line */ 218 #define MAXLIST 128 /* maximum variables in list */ 219 #define LENHOSTNAME 256 /* host name limit */ 220 221 #define MRU_GOT_COUNT 0x1 222 #define MRU_GOT_LAST 0x2 223 #define MRU_GOT_FIRST 0x4 224 #define MRU_GOT_MV 0x8 225 #define MRU_GOT_RS 0x10 226 #define MRU_GOT_ADDR 0x20 227 #define MRU_GOT_ALL (MRU_GOT_COUNT | MRU_GOT_LAST | MRU_GOT_FIRST \ 228 | MRU_GOT_MV | MRU_GOT_RS | MRU_GOT_ADDR) 229 230 /* 231 * mrulist() depends on MRUSORT_DEF and MRUSORT_RDEF being the first two 232 */ 233 typedef enum mru_sort_order_tag { 234 MRUSORT_DEF = 0, /* lstint ascending */ 235 MRUSORT_R_DEF, /* lstint descending */ 236 MRUSORT_AVGINT, /* avgint ascending */ 237 MRUSORT_R_AVGINT, /* avgint descending */ 238 MRUSORT_ADDR, /* IPv4 asc. then IPv6 asc. */ 239 MRUSORT_R_ADDR, /* IPv6 desc. then IPv4 desc. */ 240 MRUSORT_COUNT, /* hit count ascending */ 241 MRUSORT_R_COUNT, /* hit count descending */ 242 MRUSORT_MAX, /* special: count of this enum */ 243 } mru_sort_order; 244 245 const char * const mru_sort_keywords[MRUSORT_MAX] = { 246 "lstint", /* MRUSORT_DEF */ 247 "-lstint", /* MRUSORT_R_DEF */ 248 "avgint", /* MRUSORT_AVGINT */ 249 "-avgint", /* MRUSORT_R_AVGINT */ 250 "addr", /* MRUSORT_ADDR */ 251 "-addr", /* MRUSORT_R_ADDR */ 252 "count", /* MRUSORT_COUNT */ 253 "-count", /* MRUSORT_R_COUNT */ 254 }; 255 256 typedef int (*qsort_cmp)(const void *, const void *); 257 258 /* 259 * Old CTL_PST defines for version 2. 260 */ 261 #define OLD_CTL_PST_CONFIG 0x80 262 #define OLD_CTL_PST_AUTHENABLE 0x40 263 #define OLD_CTL_PST_AUTHENTIC 0x20 264 #define OLD_CTL_PST_REACH 0x10 265 #define OLD_CTL_PST_SANE 0x08 266 #define OLD_CTL_PST_DISP 0x04 267 268 #define OLD_CTL_PST_SEL_REJECT 0 269 #define OLD_CTL_PST_SEL_SELCAND 1 270 #define OLD_CTL_PST_SEL_SYNCCAND 2 271 #define OLD_CTL_PST_SEL_SYSPEER 3 272 273 char flash2[] = " .+* "; /* flash decode for version 2 */ 274 char flash3[] = " x.-+#*o"; /* flash decode for peer status version 3 */ 275 276 struct varlist { 277 const char *name; 278 char *value; 279 } g_varlist[MAXLIST] = { { 0, 0 } }; 280 281 /* 282 * Imported from ntpq.c 283 */ 284 extern int showhostnames; 285 extern int wideremote; 286 extern int rawmode; 287 extern struct servent *server_entry; 288 extern struct association *assoc_cache; 289 extern u_char pktversion; 290 291 typedef struct mru_tag mru; 292 struct mru_tag { 293 mru * hlink; /* next in hash table bucket */ 294 DECL_DLIST_LINK(mru, mlink); 295 int count; 296 l_fp last; 297 l_fp first; 298 u_char mode; 299 u_char ver; 300 u_short rs; 301 sockaddr_u addr; 302 }; 303 304 typedef struct ifstats_row_tag { 305 u_int ifnum; 306 sockaddr_u addr; 307 sockaddr_u bcast; 308 int enabled; 309 u_int flags; 310 u_int mcast_count; 311 char name[32]; 312 u_int peer_count; 313 u_int received; 314 u_int sent; 315 u_int send_errors; 316 u_int ttl; 317 u_int uptime; 318 } ifstats_row; 319 320 typedef struct reslist_row_tag { 321 u_int idx; 322 sockaddr_u addr; 323 sockaddr_u mask; 324 u_long hits; 325 char flagstr[128]; 326 } reslist_row; 327 328 typedef struct var_display_collection_tag { 329 const char * const tag; /* system variable */ 330 const char * const display; /* descriptive text */ 331 u_char type; /* NTP_STR, etc */ 332 union { 333 char * str; 334 sockaddr_u sau; /* NTP_ADD */ 335 l_fp lfp; /* NTP_LFP */ 336 } v; /* retrieved value */ 337 } vdc; 338 #if !defined(MISSING_C99_STRUCT_INIT) 339 # define VDC_INIT(a, b, c) { .tag = a, .display = b, .type = c } 340 #else 341 # define VDC_INIT(a, b, c) { a, b, c } 342 #endif 343 /* 344 * other local function prototypes 345 */ 346 static int mrulist_ctrl_c_hook(void); 347 static mru * add_mru(mru *); 348 static int collect_mru_list(const char *, l_fp *); 349 static int fetch_nonce(char *, size_t); 350 static int qcmp_mru_avgint(const void *, const void *); 351 static int qcmp_mru_r_avgint(const void *, const void *); 352 static int qcmp_mru_addr(const void *, const void *); 353 static int qcmp_mru_r_addr(const void *, const void *); 354 static int qcmp_mru_count(const void *, const void *); 355 static int qcmp_mru_r_count(const void *, const void *); 356 static void validate_ifnum(FILE *, u_int, int *, ifstats_row *); 357 static void another_ifstats_field(int *, ifstats_row *, FILE *); 358 static void collect_display_vdc(associd_t as, vdc *table, 359 int decodestatus, FILE *fp); 360 361 /* 362 * static globals 363 */ 364 static u_int mru_count; 365 static u_int mru_dupes; 366 volatile int mrulist_interrupted; 367 static mru mru_list; /* listhead */ 368 static mru ** hash_table; 369 370 /* 371 * qsort comparison function table for mrulist(). The first two 372 * entries are NULL because they are handled without qsort(). 373 */ 374 static const qsort_cmp mru_qcmp_table[MRUSORT_MAX] = { 375 NULL, /* MRUSORT_DEF unused */ 376 NULL, /* MRUSORT_R_DEF unused */ 377 &qcmp_mru_avgint, /* MRUSORT_AVGINT */ 378 &qcmp_mru_r_avgint, /* MRUSORT_R_AVGINT */ 379 &qcmp_mru_addr, /* MRUSORT_ADDR */ 380 &qcmp_mru_r_addr, /* MRUSORT_R_ADDR */ 381 &qcmp_mru_count, /* MRUSORT_COUNT */ 382 &qcmp_mru_r_count, /* MRUSORT_R_COUNT */ 383 }; 384 385 /* 386 * checkassocid - return the association ID, checking to see if it is valid 387 */ 388 static associd_t 389 checkassocid( 390 u_int32 value 391 ) 392 { 393 associd_t associd; 394 u_long ulvalue; 395 396 associd = (associd_t)value; 397 if (0 == associd || value != associd) { 398 ulvalue = value; 399 fprintf(stderr, 400 "***Invalid association ID %lu specified\n", 401 ulvalue); 402 return 0; 403 } 404 405 return associd; 406 } 407 408 409 /* 410 * findlistvar - Look for the named variable in a varlist. If found, 411 * return a pointer to it. Otherwise, if the list has 412 * slots available, return the pointer to the first free 413 * slot, or NULL if it's full. 414 */ 415 static struct varlist * 416 findlistvar( 417 struct varlist *list, 418 char *name 419 ) 420 { 421 struct varlist *vl; 422 423 for (vl = list; vl < list + MAXLIST && vl->name != NULL; vl++) 424 if (!strcmp(name, vl->name)) 425 return vl; 426 if (vl < list + MAXLIST) 427 return vl; 428 429 return NULL; 430 } 431 432 433 /* 434 * doaddvlist - add variable(s) to the variable list 435 */ 436 static void 437 doaddvlist( 438 struct varlist *vlist, 439 const char *vars 440 ) 441 { 442 struct varlist *vl; 443 size_t len; 444 char *name; 445 char *value; 446 447 len = strlen(vars); 448 while (nextvar(&len, &vars, &name, &value)) { 449 INSIST(name && value); 450 vl = findlistvar(vlist, name); 451 if (NULL == vl) { 452 fprintf(stderr, "Variable list full\n"); 453 return; 454 } 455 456 if (NULL == vl->name) { 457 vl->name = estrdup(name); 458 } else if (vl->value != NULL) { 459 free(vl->value); 460 vl->value = NULL; 461 } 462 463 if (value != NULL) 464 vl->value = estrdup(value); 465 } 466 } 467 468 469 /* 470 * dormvlist - remove variable(s) from the variable list 471 */ 472 static void 473 dormvlist( 474 struct varlist *vlist, 475 const char *vars 476 ) 477 { 478 struct varlist *vl; 479 size_t len; 480 char *name; 481 char *value; 482 483 len = strlen(vars); 484 while (nextvar(&len, &vars, &name, &value)) { 485 INSIST(name && value); 486 vl = findlistvar(vlist, name); 487 if (vl == 0 || vl->name == 0) { 488 (void) fprintf(stderr, "Variable `%s' not found\n", 489 name); 490 } else { 491 free((void *)(intptr_t)vl->name); 492 if (vl->value != 0) 493 free(vl->value); 494 for ( ; (vl+1) < (g_varlist + MAXLIST) 495 && (vl+1)->name != 0; vl++) { 496 vl->name = (vl+1)->name; 497 vl->value = (vl+1)->value; 498 } 499 vl->name = vl->value = 0; 500 } 501 } 502 } 503 504 505 /* 506 * doclearvlist - clear a variable list 507 */ 508 static void 509 doclearvlist( 510 struct varlist *vlist 511 ) 512 { 513 register struct varlist *vl; 514 515 for (vl = vlist; vl < vlist + MAXLIST && vl->name != 0; vl++) { 516 free((void *)(intptr_t)vl->name); 517 vl->name = 0; 518 if (vl->value != 0) { 519 free(vl->value); 520 vl->value = 0; 521 } 522 } 523 } 524 525 526 /* 527 * makequerydata - form a data buffer to be included with a query 528 */ 529 static void 530 makequerydata( 531 struct varlist *vlist, 532 size_t *datalen, 533 char *data 534 ) 535 { 536 register struct varlist *vl; 537 register char *cp, *cpend; 538 register size_t namelen, valuelen; 539 register size_t totallen; 540 541 cp = data; 542 cpend = data + *datalen; 543 544 for (vl = vlist; vl < vlist + MAXLIST && vl->name != 0; vl++) { 545 namelen = strlen(vl->name); 546 if (vl->value == 0) 547 valuelen = 0; 548 else 549 valuelen = strlen(vl->value); 550 totallen = namelen + valuelen + (valuelen != 0) + (cp != data); 551 if (cp + totallen > cpend) { 552 fprintf(stderr, 553 "***Ignoring variables starting with `%s'\n", 554 vl->name); 555 break; 556 } 557 558 if (cp != data) 559 *cp++ = ','; 560 memcpy(cp, vl->name, (size_t)namelen); 561 cp += namelen; 562 if (valuelen != 0) { 563 *cp++ = '='; 564 memcpy(cp, vl->value, (size_t)valuelen); 565 cp += valuelen; 566 } 567 } 568 *datalen = (size_t)(cp - data); 569 } 570 571 572 /* 573 * doquerylist - send a message including variables in a list 574 */ 575 static int 576 doquerylist( 577 struct varlist *vlist, 578 int op, 579 associd_t associd, 580 int auth, 581 u_short *rstatus, 582 size_t *dsize, 583 const char **datap 584 ) 585 { 586 char data[CTL_MAX_DATA_LEN]; 587 size_t datalen; 588 589 datalen = sizeof(data); 590 makequerydata(vlist, &datalen, data); 591 592 return doquery(op, associd, auth, datalen, data, rstatus, dsize, 593 datap); 594 } 595 596 597 /* 598 * doprintvlist - print the variables on a list 599 */ 600 static void 601 doprintvlist( 602 struct varlist *vlist, 603 FILE *fp 604 ) 605 { 606 size_t n; 607 608 if (NULL == vlist->name) { 609 fprintf(fp, "No variables on list\n"); 610 return; 611 } 612 for (n = 0; n < MAXLIST && vlist[n].name != NULL; n++) { 613 if (NULL == vlist[n].value) 614 fprintf(fp, "%s\n", vlist[n].name); 615 else 616 fprintf(fp, "%s=%s\n", vlist[n].name, 617 vlist[n].value); 618 } 619 } 620 621 /* 622 * addvars - add variables to the variable list 623 */ 624 /*ARGSUSED*/ 625 static void 626 addvars( 627 struct parse *pcmd, 628 FILE *fp 629 ) 630 { 631 doaddvlist(g_varlist, pcmd->argval[0].string); 632 } 633 634 635 /* 636 * rmvars - remove variables from the variable list 637 */ 638 /*ARGSUSED*/ 639 static void 640 rmvars( 641 struct parse *pcmd, 642 FILE *fp 643 ) 644 { 645 dormvlist(g_varlist, pcmd->argval[0].string); 646 } 647 648 649 /* 650 * clearvars - clear the variable list 651 */ 652 /*ARGSUSED*/ 653 static void 654 clearvars( 655 struct parse *pcmd, 656 FILE *fp 657 ) 658 { 659 doclearvlist(g_varlist); 660 } 661 662 663 /* 664 * showvars - show variables on the variable list 665 */ 666 /*ARGSUSED*/ 667 static void 668 showvars( 669 struct parse *pcmd, 670 FILE *fp 671 ) 672 { 673 doprintvlist(g_varlist, fp); 674 } 675 676 677 /* 678 * dolist - send a request with the given list of variables 679 */ 680 static int 681 dolist( 682 struct varlist *vlist, 683 associd_t associd, 684 int op, 685 int type, 686 FILE *fp 687 ) 688 { 689 const char *datap; 690 int res; 691 size_t dsize; 692 u_short rstatus; 693 int quiet; 694 695 /* 696 * if we're asking for specific variables don't include the 697 * status header line in the output. 698 */ 699 if (old_rv) 700 quiet = 0; 701 else 702 quiet = (vlist->name != NULL); 703 704 res = doquerylist(vlist, op, associd, 0, &rstatus, &dsize, &datap); 705 706 if (res != 0) 707 return 0; 708 709 if (numhosts > 1) 710 fprintf(fp, "server=%s ", currenthost); 711 if (dsize == 0) { 712 if (associd == 0) 713 fprintf(fp, "No system%s variables returned\n", 714 (type == TYPE_CLOCK) ? " clock" : ""); 715 else 716 fprintf(fp, 717 "No information returned for%s association %u\n", 718 (type == TYPE_CLOCK) ? " clock" : "", 719 associd); 720 return 1; 721 } 722 723 if (!quiet) 724 fprintf(fp, "associd=%u ", associd); 725 printvars(dsize, datap, (int)rstatus, type, quiet, fp); 726 return 1; 727 } 728 729 730 /* 731 * readlist - send a read variables request with the variables on the list 732 */ 733 static void 734 readlist( 735 struct parse *pcmd, 736 FILE *fp 737 ) 738 { 739 associd_t associd; 740 int type; 741 742 if (pcmd->nargs == 0) { 743 associd = 0; 744 } else { 745 /* HMS: I think we want the u_int32 target here, not the u_long */ 746 if (pcmd->argval[0].uval == 0) 747 associd = 0; 748 else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0) 749 return; 750 } 751 752 type = (0 == associd) 753 ? TYPE_SYS 754 : TYPE_PEER; 755 dolist(g_varlist, associd, CTL_OP_READVAR, type, fp); 756 } 757 758 759 /* 760 * writelist - send a write variables request with the variables on the list 761 */ 762 static void 763 writelist( 764 struct parse *pcmd, 765 FILE *fp 766 ) 767 { 768 const char *datap; 769 int res; 770 associd_t associd; 771 size_t dsize; 772 u_short rstatus; 773 774 if (pcmd->nargs == 0) { 775 associd = 0; 776 } else { 777 /* HMS: Do we really want uval here? */ 778 if (pcmd->argval[0].uval == 0) 779 associd = 0; 780 else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0) 781 return; 782 } 783 784 res = doquerylist(g_varlist, CTL_OP_WRITEVAR, associd, 1, &rstatus, 785 &dsize, &datap); 786 787 if (res != 0) 788 return; 789 790 if (numhosts > 1) 791 (void) fprintf(fp, "server=%s ", currenthost); 792 if (dsize == 0) 793 (void) fprintf(fp, "done! (no data returned)\n"); 794 else { 795 (void) fprintf(fp,"associd=%u ", associd); 796 printvars(dsize, datap, (int)rstatus, 797 (associd != 0) ? TYPE_PEER : TYPE_SYS, 0, fp); 798 } 799 return; 800 } 801 802 803 /* 804 * readvar - send a read variables request with the specified variables 805 */ 806 static void 807 readvar( 808 struct parse *pcmd, 809 FILE *fp 810 ) 811 { 812 associd_t associd; 813 size_t tmpcount; 814 size_t u; 815 int type; 816 struct varlist tmplist[MAXLIST]; 817 818 819 /* HMS: uval? */ 820 if (pcmd->nargs == 0 || pcmd->argval[0].uval == 0) 821 associd = 0; 822 else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0) 823 return; 824 825 ZERO(tmplist); 826 if (pcmd->nargs > 1) { 827 tmpcount = pcmd->nargs - 1; 828 for (u = 0; u < tmpcount; u++) 829 doaddvlist(tmplist, pcmd->argval[1 + u].string); 830 } 831 832 type = (0 == associd) 833 ? TYPE_SYS 834 : TYPE_PEER; 835 dolist(tmplist, associd, CTL_OP_READVAR, type, fp); 836 837 doclearvlist(tmplist); 838 } 839 840 841 /* 842 * writevar - send a write variables request with the specified variables 843 */ 844 static void 845 writevar( 846 struct parse *pcmd, 847 FILE *fp 848 ) 849 { 850 const char *datap; 851 int res; 852 associd_t associd; 853 int type; 854 size_t dsize; 855 u_short rstatus; 856 struct varlist tmplist[MAXLIST]; 857 858 /* HMS: uval? */ 859 if (pcmd->argval[0].uval == 0) 860 associd = 0; 861 else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0) 862 return; 863 864 ZERO(tmplist); 865 doaddvlist(tmplist, pcmd->argval[1].string); 866 867 res = doquerylist(tmplist, CTL_OP_WRITEVAR, associd, 1, &rstatus, 868 &dsize, &datap); 869 870 doclearvlist(tmplist); 871 872 if (res != 0) 873 return; 874 875 if (numhosts > 1) 876 fprintf(fp, "server=%s ", currenthost); 877 if (dsize == 0) 878 fprintf(fp, "done! (no data returned)\n"); 879 else { 880 fprintf(fp,"associd=%u ", associd); 881 type = (0 == associd) 882 ? TYPE_SYS 883 : TYPE_PEER; 884 printvars(dsize, datap, (int)rstatus, type, 0, fp); 885 } 886 return; 887 } 888 889 890 /* 891 * clocklist - send a clock variables request with the variables on the list 892 */ 893 static void 894 clocklist( 895 struct parse *pcmd, 896 FILE *fp 897 ) 898 { 899 associd_t associd; 900 901 /* HMS: uval? */ 902 if (pcmd->nargs == 0) { 903 associd = 0; 904 } else { 905 if (pcmd->argval[0].uval == 0) 906 associd = 0; 907 else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0) 908 return; 909 } 910 911 dolist(g_varlist, associd, CTL_OP_READCLOCK, TYPE_CLOCK, fp); 912 } 913 914 915 /* 916 * clockvar - send a clock variables request with the specified variables 917 */ 918 static void 919 clockvar( 920 struct parse *pcmd, 921 FILE *fp 922 ) 923 { 924 associd_t associd; 925 struct varlist tmplist[MAXLIST]; 926 927 /* HMS: uval? */ 928 if (pcmd->nargs == 0 || pcmd->argval[0].uval == 0) 929 associd = 0; 930 else if ((associd = checkassocid(pcmd->argval[0].uval)) == 0) 931 return; 932 933 ZERO(tmplist); 934 if (pcmd->nargs >= 2) 935 doaddvlist(tmplist, pcmd->argval[1].string); 936 937 dolist(tmplist, associd, CTL_OP_READCLOCK, TYPE_CLOCK, fp); 938 939 doclearvlist(tmplist); 940 } 941 942 943 /* 944 * findassidrange - verify a range of association ID's 945 */ 946 static int 947 findassidrange( 948 u_int32 assid1, 949 u_int32 assid2, 950 int * from, 951 int * to, 952 FILE * fp 953 ) 954 { 955 associd_t assids[2]; 956 int ind[COUNTOF(assids)]; 957 u_int i; 958 size_t a; 959 960 961 if (0 == numassoc) 962 dogetassoc(fp); 963 964 assids[0] = checkassocid(assid1); 965 if (0 == assids[0]) 966 return 0; 967 assids[1] = checkassocid(assid2); 968 if (0 == assids[1]) 969 return 0; 970 971 for (a = 0; a < COUNTOF(assids); a++) { 972 ind[a] = -1; 973 for (i = 0; i < numassoc; i++) 974 if (assoc_cache[i].assid == assids[a]) 975 ind[a] = i; 976 } 977 for (a = 0; a < COUNTOF(assids); a++) 978 if (-1 == ind[a]) { 979 fprintf(stderr, 980 "***Association ID %u not found in list\n", 981 assids[a]); 982 return 0; 983 } 984 985 if (ind[0] < ind[1]) { 986 *from = ind[0]; 987 *to = ind[1]; 988 } else { 989 *to = ind[0]; 990 *from = ind[1]; 991 } 992 return 1; 993 } 994 995 996 997 /* 998 * mreadlist - send a read variables request for multiple associations 999 */ 1000 static void 1001 mreadlist( 1002 struct parse *pcmd, 1003 FILE *fp 1004 ) 1005 { 1006 int i; 1007 int from; 1008 int to; 1009 1010 if (!findassidrange(pcmd->argval[0].uval, pcmd->argval[1].uval, 1011 &from, &to, fp)) 1012 return; 1013 1014 for (i = from; i <= to; i++) { 1015 if (i != from) 1016 fprintf(fp, "\n"); 1017 if (!dolist(g_varlist, assoc_cache[i].assid, 1018 CTL_OP_READVAR, TYPE_PEER, fp)) 1019 return; 1020 } 1021 return; 1022 } 1023 1024 1025 /* 1026 * mreadvar - send a read variables request for multiple associations 1027 */ 1028 static void 1029 mreadvar( 1030 struct parse *pcmd, 1031 FILE *fp 1032 ) 1033 { 1034 int i; 1035 int from; 1036 int to; 1037 struct varlist tmplist[MAXLIST]; 1038 struct varlist *pvars; 1039 1040 if (!findassidrange(pcmd->argval[0].uval, pcmd->argval[1].uval, 1041 &from, &to, fp)) 1042 return; 1043 1044 ZERO(tmplist); 1045 if (pcmd->nargs >= 3) { 1046 doaddvlist(tmplist, pcmd->argval[2].string); 1047 pvars = tmplist; 1048 } else { 1049 pvars = g_varlist; 1050 } 1051 1052 for (i = from; i <= to; i++) { 1053 if (!dolist(pvars, assoc_cache[i].assid, CTL_OP_READVAR, 1054 TYPE_PEER, fp)) 1055 break; 1056 } 1057 1058 if (pvars == tmplist) 1059 doclearvlist(tmplist); 1060 1061 return; 1062 } 1063 1064 1065 /* 1066 * dogetassoc - query the host for its list of associations 1067 */ 1068 int 1069 dogetassoc( 1070 FILE *fp 1071 ) 1072 { 1073 const char *datap; 1074 const u_short *pus; 1075 int res; 1076 size_t dsize; 1077 u_short rstatus; 1078 1079 res = doquery(CTL_OP_READSTAT, 0, 0, 0, (char *)0, &rstatus, 1080 &dsize, &datap); 1081 1082 if (res != 0) 1083 return 0; 1084 1085 if (dsize == 0) { 1086 if (numhosts > 1) 1087 fprintf(fp, "server=%s ", currenthost); 1088 fprintf(fp, "No association ID's returned\n"); 1089 return 0; 1090 } 1091 1092 if (dsize & 0x3) { 1093 if (numhosts > 1) 1094 fprintf(stderr, "server=%s ", currenthost); 1095 fprintf(stderr, 1096 "***Server returned %zu octets, should be multiple of 4\n", 1097 dsize); 1098 return 0; 1099 } 1100 1101 numassoc = 0; 1102 1103 while (dsize > 0) { 1104 if (numassoc >= assoc_cache_slots) { 1105 grow_assoc_cache(); 1106 } 1107 pus = (const void *)datap; 1108 assoc_cache[numassoc].assid = ntohs(*pus); 1109 datap += sizeof(*pus); 1110 pus = (const void *)datap; 1111 assoc_cache[numassoc].status = ntohs(*pus); 1112 datap += sizeof(*pus); 1113 dsize -= 2 * sizeof(*pus); 1114 if (debug) { 1115 fprintf(stderr, "[%u] ", 1116 assoc_cache[numassoc].assid); 1117 } 1118 numassoc++; 1119 } 1120 if (debug) { 1121 fprintf(stderr, "\n%d associations total\n", numassoc); 1122 } 1123 sortassoc(); 1124 return 1; 1125 } 1126 1127 1128 /* 1129 * printassoc - print the current list of associations 1130 */ 1131 static void 1132 printassoc( 1133 int showall, 1134 FILE *fp 1135 ) 1136 { 1137 register char *bp; 1138 u_int i; 1139 u_char statval; 1140 int event; 1141 u_long event_count; 1142 const char *conf; 1143 const char *reach; 1144 const char *auth; 1145 const char *condition = ""; 1146 const char *last_event; 1147 char buf[128]; 1148 1149 if (numassoc == 0) { 1150 (void) fprintf(fp, "No association ID's in list\n"); 1151 return; 1152 } 1153 1154 /* 1155 * Output a header 1156 */ 1157 (void) fprintf(fp, 1158 "ind assid status conf reach auth condition last_event cnt\n"); 1159 (void) fprintf(fp, 1160 "===========================================================\n"); 1161 for (i = 0; i < numassoc; i++) { 1162 statval = (u_char) CTL_PEER_STATVAL(assoc_cache[i].status); 1163 if (!showall && !(statval & (CTL_PST_CONFIG|CTL_PST_REACH))) 1164 continue; 1165 event = CTL_PEER_EVENT(assoc_cache[i].status); 1166 event_count = CTL_PEER_NEVNT(assoc_cache[i].status); 1167 if (statval & CTL_PST_CONFIG) 1168 conf = "yes"; 1169 else 1170 conf = "no"; 1171 if (statval & CTL_PST_BCAST) { 1172 reach = "none"; 1173 if (statval & CTL_PST_AUTHENABLE) 1174 auth = "yes"; 1175 else 1176 auth = "none"; 1177 } else { 1178 if (statval & CTL_PST_REACH) 1179 reach = "yes"; 1180 else 1181 reach = "no"; 1182 if (statval & CTL_PST_AUTHENABLE) { 1183 if (statval & CTL_PST_AUTHENTIC) 1184 auth = "ok "; 1185 else 1186 auth = "bad"; 1187 } else { 1188 auth = "none"; 1189 } 1190 } 1191 if (pktversion > NTP_OLDVERSION) { 1192 switch (statval & 0x7) { 1193 1194 case CTL_PST_SEL_REJECT: 1195 condition = "reject"; 1196 break; 1197 1198 case CTL_PST_SEL_SANE: 1199 condition = "falsetick"; 1200 break; 1201 1202 case CTL_PST_SEL_CORRECT: 1203 condition = "excess"; 1204 break; 1205 1206 case CTL_PST_SEL_SELCAND: 1207 condition = "outlier"; 1208 break; 1209 1210 case CTL_PST_SEL_SYNCCAND: 1211 condition = "candidate"; 1212 break; 1213 1214 case CTL_PST_SEL_EXCESS: 1215 condition = "backup"; 1216 break; 1217 1218 case CTL_PST_SEL_SYSPEER: 1219 condition = "sys.peer"; 1220 break; 1221 1222 case CTL_PST_SEL_PPS: 1223 condition = "pps.peer"; 1224 break; 1225 } 1226 } else { 1227 switch (statval & 0x3) { 1228 1229 case OLD_CTL_PST_SEL_REJECT: 1230 if (!(statval & OLD_CTL_PST_SANE)) 1231 condition = "insane"; 1232 else if (!(statval & OLD_CTL_PST_DISP)) 1233 condition = "hi_disp"; 1234 else 1235 condition = ""; 1236 break; 1237 1238 case OLD_CTL_PST_SEL_SELCAND: 1239 condition = "sel_cand"; 1240 break; 1241 1242 case OLD_CTL_PST_SEL_SYNCCAND: 1243 condition = "sync_cand"; 1244 break; 1245 1246 case OLD_CTL_PST_SEL_SYSPEER: 1247 condition = "sys_peer"; 1248 break; 1249 } 1250 } 1251 switch (PEER_EVENT|event) { 1252 1253 case PEVNT_MOBIL: 1254 last_event = "mobilize"; 1255 break; 1256 1257 case PEVNT_DEMOBIL: 1258 last_event = "demobilize"; 1259 break; 1260 1261 case PEVNT_REACH: 1262 last_event = "reachable"; 1263 break; 1264 1265 case PEVNT_UNREACH: 1266 last_event = "unreachable"; 1267 break; 1268 1269 case PEVNT_RESTART: 1270 last_event = "restart"; 1271 break; 1272 1273 case PEVNT_REPLY: 1274 last_event = "no_reply"; 1275 break; 1276 1277 case PEVNT_RATE: 1278 last_event = "rate_exceeded"; 1279 break; 1280 1281 case PEVNT_DENY: 1282 last_event = "access_denied"; 1283 break; 1284 1285 case PEVNT_ARMED: 1286 last_event = "leap_armed"; 1287 break; 1288 1289 case PEVNT_NEWPEER: 1290 last_event = "sys_peer"; 1291 break; 1292 1293 case PEVNT_CLOCK: 1294 last_event = "clock_alarm"; 1295 break; 1296 1297 default: 1298 last_event = ""; 1299 break; 1300 } 1301 snprintf(buf, sizeof(buf), 1302 "%3d %5u %04x %3.3s %4s %4.4s %9.9s %11s %2lu", 1303 i + 1, assoc_cache[i].assid, 1304 assoc_cache[i].status, conf, reach, auth, 1305 condition, last_event, event_count); 1306 bp = buf + strlen(buf); 1307 while (bp > buf && ' ' == bp[-1]) 1308 --bp; 1309 bp[0] = '\0'; 1310 fprintf(fp, "%s\n", buf); 1311 } 1312 } 1313 1314 1315 /* 1316 * associations - get, record and print a list of associations 1317 */ 1318 /*ARGSUSED*/ 1319 static void 1320 associations( 1321 struct parse *pcmd, 1322 FILE *fp 1323 ) 1324 { 1325 if (dogetassoc(fp)) 1326 printassoc(0, fp); 1327 } 1328 1329 1330 /* 1331 * lassociations - get, record and print a long list of associations 1332 */ 1333 /*ARGSUSED*/ 1334 static void 1335 lassociations( 1336 struct parse *pcmd, 1337 FILE *fp 1338 ) 1339 { 1340 if (dogetassoc(fp)) 1341 printassoc(1, fp); 1342 } 1343 1344 1345 /* 1346 * passociations - print the association list 1347 */ 1348 /*ARGSUSED*/ 1349 static void 1350 passociations( 1351 struct parse *pcmd, 1352 FILE *fp 1353 ) 1354 { 1355 printassoc(0, fp); 1356 } 1357 1358 1359 /* 1360 * lpassociations - print the long association list 1361 */ 1362 /*ARGSUSED*/ 1363 static void 1364 lpassociations( 1365 struct parse *pcmd, 1366 FILE *fp 1367 ) 1368 { 1369 printassoc(1, fp); 1370 } 1371 1372 1373 /* 1374 * saveconfig - dump ntp server configuration to server file 1375 */ 1376 static void 1377 saveconfig( 1378 struct parse *pcmd, 1379 FILE *fp 1380 ) 1381 { 1382 const char *datap; 1383 int res; 1384 size_t dsize; 1385 u_short rstatus; 1386 1387 if (0 == pcmd->nargs) 1388 return; 1389 1390 res = doquery(CTL_OP_SAVECONFIG, 0, 1, 1391 strlen(pcmd->argval[0].string), 1392 pcmd->argval[0].string, &rstatus, &dsize, 1393 &datap); 1394 1395 if (res != 0) 1396 return; 1397 1398 if (0 == dsize) 1399 fprintf(fp, "(no response message, curiously)"); 1400 else 1401 fprintf(fp, "%.*s", (int)dsize, datap); /* cast is wobbly */ 1402 } 1403 1404 1405 #ifdef UNUSED 1406 /* 1407 * radiostatus - print the radio status returned by the server 1408 */ 1409 /*ARGSUSED*/ 1410 static void 1411 radiostatus( 1412 struct parse *pcmd, 1413 FILE *fp 1414 ) 1415 { 1416 char *datap; 1417 int res; 1418 int dsize; 1419 u_short rstatus; 1420 1421 res = doquery(CTL_OP_READCLOCK, 0, 0, 0, (char *)0, &rstatus, 1422 &dsize, &datap); 1423 1424 if (res != 0) 1425 return; 1426 1427 if (numhosts > 1) 1428 (void) fprintf(fp, "server=%s ", currenthost); 1429 if (dsize == 0) { 1430 (void) fprintf(fp, "No radio status string returned\n"); 1431 return; 1432 } 1433 1434 asciize(dsize, datap, fp); 1435 } 1436 #endif /* UNUSED */ 1437 1438 /* 1439 * when - print how long its been since his last packet arrived 1440 */ 1441 static long 1442 when( 1443 l_fp *ts, 1444 l_fp *rec, 1445 l_fp *reftime 1446 ) 1447 { 1448 l_fp *lasttime; 1449 1450 if (rec->l_ui != 0) 1451 lasttime = rec; 1452 else if (reftime->l_ui != 0) 1453 lasttime = reftime; 1454 else 1455 return 0; 1456 1457 if (ts->l_ui < lasttime->l_ui) 1458 return -1; 1459 return (ts->l_ui - lasttime->l_ui); 1460 } 1461 1462 1463 /* 1464 * Pretty-print an interval into the given buffer, in a human-friendly format. 1465 */ 1466 static char * 1467 prettyinterval( 1468 char *buf, 1469 size_t cb, 1470 long diff 1471 ) 1472 { 1473 if (diff <= 0) { 1474 buf[0] = '-'; 1475 buf[1] = 0; 1476 return buf; 1477 } 1478 1479 if (diff <= 2048) { 1480 snprintf(buf, cb, "%u", (unsigned int)diff); 1481 return buf; 1482 } 1483 1484 diff = (diff + 29) / 60; 1485 if (diff <= 300) { 1486 snprintf(buf, cb, "%um", (unsigned int)diff); 1487 return buf; 1488 } 1489 1490 diff = (diff + 29) / 60; 1491 if (diff <= 96) { 1492 snprintf(buf, cb, "%uh", (unsigned int)diff); 1493 return buf; 1494 } 1495 1496 diff = (diff + 11) / 24; 1497 if (diff <= 999) { 1498 snprintf(buf, cb, "%ud", (unsigned int)diff); 1499 return buf; 1500 } 1501 1502 /* years are only approximated... */ 1503 diff = (long)floor(diff / 365.25 + 0.5); 1504 if (diff <= 999) { 1505 snprintf(buf, cb, "%uy", (unsigned int)diff); 1506 return buf; 1507 } 1508 /* Ok, this amounts to infinity... */ 1509 strlcpy(buf, "INF", cb); 1510 return buf; 1511 } 1512 1513 static char 1514 decodeaddrtype( 1515 sockaddr_u *sock 1516 ) 1517 { 1518 char ch = '-'; 1519 u_int32 dummy; 1520 1521 switch(AF(sock)) { 1522 case AF_INET: 1523 dummy = SRCADR(sock); 1524 ch = (char)(((dummy&0xf0000000)==0xe0000000) ? 'm' : 1525 ((dummy&0x000000ff)==0x000000ff) ? 'b' : 1526 ((dummy&0xffffffff)==0x7f000001) ? 'l' : 1527 ((dummy&0xffffffe0)==0x00000000) ? '-' : 1528 'u'); 1529 break; 1530 case AF_INET6: 1531 if (IN6_IS_ADDR_MULTICAST(PSOCK_ADDR6(sock))) 1532 ch = 'm'; 1533 else 1534 ch = 'u'; 1535 break; 1536 default: 1537 ch = '-'; 1538 break; 1539 } 1540 return ch; 1541 } 1542 1543 /* 1544 * A list of variables required by the peers command 1545 */ 1546 struct varlist opeervarlist[] = { 1547 { "srcadr", 0 }, /* 0 */ 1548 { "dstadr", 0 }, /* 1 */ 1549 { "stratum", 0 }, /* 2 */ 1550 { "hpoll", 0 }, /* 3 */ 1551 { "ppoll", 0 }, /* 4 */ 1552 { "reach", 0 }, /* 5 */ 1553 { "delay", 0 }, /* 6 */ 1554 { "offset", 0 }, /* 7 */ 1555 { "jitter", 0 }, /* 8 */ 1556 { "dispersion", 0 }, /* 9 */ 1557 { "rec", 0 }, /* 10 */ 1558 { "reftime", 0 }, /* 11 */ 1559 { "srcport", 0 }, /* 12 */ 1560 { "hmode", 0 }, /* 13 */ 1561 { 0, 0 } 1562 }; 1563 1564 struct varlist peervarlist[] = { 1565 { "srcadr", 0 }, /* 0 */ 1566 { "refid", 0 }, /* 1 */ 1567 { "stratum", 0 }, /* 2 */ 1568 { "hpoll", 0 }, /* 3 */ 1569 { "ppoll", 0 }, /* 4 */ 1570 { "reach", 0 }, /* 5 */ 1571 { "delay", 0 }, /* 6 */ 1572 { "offset", 0 }, /* 7 */ 1573 { "jitter", 0 }, /* 8 */ 1574 { "dispersion", 0 }, /* 9 */ 1575 { "rec", 0 }, /* 10 */ 1576 { "reftime", 0 }, /* 11 */ 1577 { "srcport", 0 }, /* 12 */ 1578 { "hmode", 0 }, /* 13 */ 1579 { "srchost", 0 }, /* 14 */ 1580 { 0, 0 } 1581 }; 1582 1583 struct varlist apeervarlist[] = { 1584 { "srcadr", 0 }, /* 0 */ 1585 { "refid", 0 }, /* 1 */ 1586 { "assid", 0 }, /* 2 */ 1587 { "stratum", 0 }, /* 3 */ 1588 { "hpoll", 0 }, /* 4 */ 1589 { "ppoll", 0 }, /* 5 */ 1590 { "reach", 0 }, /* 6 */ 1591 { "delay", 0 }, /* 7 */ 1592 { "offset", 0 }, /* 8 */ 1593 { "jitter", 0 }, /* 9 */ 1594 { "dispersion", 0 }, /* 10 */ 1595 { "rec", 0 }, /* 11 */ 1596 { "reftime", 0 }, /* 12 */ 1597 { "srcport", 0 }, /* 13 */ 1598 { "hmode", 0 }, /* 14 */ 1599 { "srchost", 0 }, /* 15 */ 1600 { 0, 0 } 1601 }; 1602 1603 1604 /* 1605 * Decode an incoming data buffer and print a line in the peer list 1606 */ 1607 static int 1608 doprintpeers( 1609 struct varlist *pvl, 1610 int associd, 1611 int rstatus, 1612 size_t datalen, 1613 const char *data, 1614 FILE *fp, 1615 int af 1616 ) 1617 { 1618 char *name; 1619 char *value = NULL; 1620 int c; 1621 size_t len; 1622 int have_srchost; 1623 int have_dstadr; 1624 int have_da_rid; 1625 int have_jitter; 1626 sockaddr_u srcadr; 1627 sockaddr_u dstadr; 1628 sockaddr_u dum_store; 1629 sockaddr_u refidadr; 1630 long hmode = 0; 1631 u_long srcport = 0; 1632 u_int32 u32; 1633 const char *dstadr_refid = "0.0.0.0"; 1634 const char *serverlocal; 1635 size_t drlen; 1636 u_long stratum = 0; 1637 long ppoll = 0; 1638 long hpoll = 0; 1639 u_long reach = 0; 1640 l_fp estoffset; 1641 l_fp estdelay; 1642 l_fp estjitter; 1643 l_fp estdisp; 1644 l_fp reftime; 1645 l_fp rec; 1646 l_fp ts; 1647 u_long poll_sec; 1648 u_long flash = 0; 1649 char type = '?'; 1650 char clock_name[LENHOSTNAME]; 1651 char whenbuf[12], pollbuf[12]; 1652 /* [Bug 3482] formally whenbuf & pollbuf should be able to hold 1653 * a full signed int. Not that we would use that much string 1654 * data for it... 1655 */ 1656 get_systime(&ts); 1657 1658 have_srchost = FALSE; 1659 have_dstadr = FALSE; 1660 have_da_rid = FALSE; 1661 have_jitter = FALSE; 1662 ZERO_SOCK(&srcadr); 1663 ZERO_SOCK(&dstadr); 1664 clock_name[0] = '\0'; 1665 ZERO(estoffset); 1666 ZERO(estdelay); 1667 ZERO(estjitter); 1668 ZERO(estdisp); 1669 1670 while (nextvar(&datalen, &data, &name, &value)) { 1671 INSIST(name && value); 1672 if (!strcmp("srcadr", name) || 1673 !strcmp("peeradr", name)) { 1674 if (!decodenetnum(value, &srcadr)) 1675 fprintf(stderr, "malformed %s=%s\n", 1676 name, value); 1677 } else if (!strcmp("srchost", name)) { 1678 if (pvl == peervarlist || pvl == apeervarlist) { 1679 len = strlen(value); 1680 if (2 < len && 1681 (size_t)len < sizeof(clock_name)) { 1682 /* strip quotes */ 1683 value++; 1684 len -= 2; 1685 memcpy(clock_name, value, len); 1686 clock_name[len] = '\0'; 1687 have_srchost = TRUE; 1688 } 1689 } 1690 } else if (!strcmp("dstadr", name)) { 1691 if (decodenetnum(value, &dum_store)) { 1692 type = decodeaddrtype(&dum_store); 1693 have_dstadr = TRUE; 1694 dstadr = dum_store; 1695 if (pvl == opeervarlist) { 1696 have_da_rid = TRUE; 1697 dstadr_refid = trunc_left(stoa(&dstadr), 15); 1698 } 1699 } 1700 } else if (!strcmp("hmode", name)) { 1701 decodeint(value, &hmode); 1702 } else if (!strcmp("refid", name)) { 1703 if ( (pvl == peervarlist) 1704 && (drefid == REFID_IPV4)) { 1705 have_da_rid = TRUE; 1706 drlen = strlen(value); 1707 if (0 == drlen) { 1708 dstadr_refid = ""; 1709 } else if (drlen <= 4) { 1710 ZERO(u32); 1711 memcpy(&u32, value, drlen); 1712 dstadr_refid = refid_str(u32, 1); 1713 } else if (decodenetnum(value, &refidadr)) { 1714 if (SOCK_UNSPEC(&refidadr)) 1715 dstadr_refid = "0.0.0.0"; 1716 else if (ISREFCLOCKADR(&refidadr)) 1717 dstadr_refid = 1718 refnumtoa(&refidadr); 1719 else 1720 dstadr_refid = 1721 stoa(&refidadr); 1722 } else { 1723 have_da_rid = FALSE; 1724 } 1725 } else if ( (pvl == apeervarlist) 1726 || (pvl == peervarlist)) { 1727 /* no need to check drefid == REFID_HASH */ 1728 have_da_rid = TRUE; 1729 drlen = strlen(value); 1730 if (0 == drlen) { 1731 dstadr_refid = ""; 1732 } else if (drlen <= 4) { 1733 ZERO(u32); 1734 memcpy(&u32, value, drlen); 1735 dstadr_refid = refid_str(u32, 1); 1736 //fprintf(stderr, "apeervarlist S1 refid: value=<%s>\n", value); 1737 } else if (decodenetnum(value, &refidadr)) { 1738 if (SOCK_UNSPEC(&refidadr)) 1739 dstadr_refid = "0.0.0.0"; 1740 else if (ISREFCLOCKADR(&refidadr)) 1741 dstadr_refid = 1742 refnumtoa(&refidadr); 1743 else { 1744 char *buf = emalloc(10); 1745 int i = ntohl(refidadr.sa4.sin_addr.s_addr); 1746 1747 snprintf(buf, 10, 1748 "%0x", i); 1749 dstadr_refid = buf; 1750 //fprintf(stderr, "apeervarlist refid: value=<%x>\n", i); 1751 } 1752 //fprintf(stderr, "apeervarlist refid: value=<%s>\n", value); 1753 } else { 1754 have_da_rid = FALSE; 1755 } 1756 } 1757 } else if (!strcmp("stratum", name)) { 1758 decodeuint(value, &stratum); 1759 } else if (!strcmp("hpoll", name)) { 1760 if (decodeint(value, &hpoll) && hpoll < 0) 1761 hpoll = NTP_MINPOLL; 1762 } else if (!strcmp("ppoll", name)) { 1763 if (decodeint(value, &ppoll) && ppoll < 0) 1764 ppoll = NTP_MINPOLL; 1765 } else if (!strcmp("reach", name)) { 1766 decodeuint(value, &reach); 1767 } else if (!strcmp("delay", name)) { 1768 decodetime(value, &estdelay); 1769 } else if (!strcmp("offset", name)) { 1770 decodetime(value, &estoffset); 1771 } else if (!strcmp("jitter", name)) { 1772 if ((pvl == peervarlist || pvl == apeervarlist) 1773 && decodetime(value, &estjitter)) 1774 have_jitter = 1; 1775 } else if (!strcmp("rootdisp", name) || 1776 !strcmp("dispersion", name)) { 1777 decodetime(value, &estdisp); 1778 } else if (!strcmp("rec", name)) { 1779 decodets(value, &rec); 1780 } else if (!strcmp("srcport", name) || 1781 !strcmp("peerport", name)) { 1782 decodeuint(value, &srcport); 1783 } else if (!strcmp("reftime", name)) { 1784 if (!decodets(value, &reftime)) 1785 L_CLR(&reftime); 1786 } else if (!strcmp("flash", name)) { 1787 decodeuint(value, &flash); 1788 } else { 1789 // fprintf(stderr, "UNRECOGNIZED name=%s ", name); 1790 } 1791 } 1792 1793 /* 1794 * hmode gives the best guidance for the t column. If the response 1795 * did not include hmode we'll use the old decodeaddrtype() result. 1796 */ 1797 switch (hmode) { 1798 1799 case MODE_BCLIENT: 1800 /* broadcastclient or multicastclient */ 1801 type = 'b'; 1802 break; 1803 1804 case MODE_BROADCAST: 1805 /* broadcast or multicast server */ 1806 if (IS_MCAST(&srcadr)) 1807 type = 'M'; 1808 else 1809 type = 'B'; 1810 break; 1811 1812 case MODE_CLIENT: 1813 if (ISREFCLOCKADR(&srcadr)) 1814 type = 'l'; /* local refclock*/ 1815 else if (SOCK_UNSPEC(&srcadr)) 1816 type = 'p'; /* pool */ 1817 else if (IS_MCAST(&srcadr)) 1818 type = 'a'; /* manycastclient */ 1819 else 1820 type = 'u'; /* unicast */ 1821 break; 1822 1823 case MODE_ACTIVE: 1824 type = 's'; /* symmetric active */ 1825 break; /* configured */ 1826 1827 case MODE_PASSIVE: 1828 type = 'S'; /* symmetric passive */ 1829 break; /* ephemeral */ 1830 } 1831 1832 /* 1833 * Got everything, format the line 1834 */ 1835 poll_sec = 1 << min(ppoll, hpoll); 1836 if (pktversion > NTP_OLDVERSION) 1837 c = flash3[CTL_PEER_STATVAL(rstatus) & 0x7]; 1838 else 1839 c = flash2[CTL_PEER_STATVAL(rstatus) & 0x3]; 1840 if (numhosts > 1) { 1841 if ((pvl == peervarlist || pvl == apeervarlist) 1842 && have_dstadr) { 1843 serverlocal = nntohost_col(&dstadr, 1844 (size_t)min(LIB_BUFLENGTH - 1, maxhostlen), 1845 TRUE); 1846 } else { 1847 if (currenthostisnum) 1848 serverlocal = trunc_left(currenthost, 1849 maxhostlen); 1850 else 1851 serverlocal = currenthost; 1852 } 1853 fprintf(fp, "%-*s ", (int)maxhostlen, serverlocal); 1854 } 1855 if (AF_UNSPEC == af || AF(&srcadr) == af) { 1856 if (!have_srchost) 1857 strlcpy(clock_name, nntohost(&srcadr), 1858 sizeof(clock_name)); 1859 /* wide and long source - space over on next line */ 1860 /* allow for host + sp if > 1 and regular tally + source + sp */ 1861 if (wideremote && 15 < strlen(clock_name)) 1862 fprintf(fp, "%c%s\n%*s", c, clock_name, 1863 ((numhosts > 1) ? (int)maxhostlen + 1 : 0) 1864 + 1 + 15 + 1, ""); 1865 else 1866 fprintf(fp, "%c%-15.15s ", c, clock_name); 1867 if ((flash & TEST12) && (pvl != opeervarlist)) { 1868 drlen = fprintf(fp, "(loop)"); 1869 } else if (!have_da_rid) { 1870 drlen = 0; 1871 } else { 1872 drlen = strlen(dstadr_refid); 1873 makeascii(drlen, dstadr_refid, fp); 1874 } 1875 if (pvl == apeervarlist) { 1876 while (drlen++ < 9) 1877 fputc(' ', fp); 1878 fprintf(fp, "%-6d", associd); 1879 } else { 1880 while (drlen++ < 15) 1881 fputc(' ', fp); 1882 } 1883 fprintf(fp, 1884 " %2ld %c %4.4s %4.4s %3lo %7.7s %8.7s %7.7s\n", 1885 stratum, type, 1886 prettyinterval(whenbuf, sizeof(whenbuf), 1887 when(&ts, &rec, &reftime)), 1888 prettyinterval(pollbuf, sizeof(pollbuf), 1889 (int)poll_sec), 1890 reach, lfptoms(&estdelay, 3), 1891 lfptoms(&estoffset, 3), 1892 (have_jitter) 1893 ? lfptoms(&estjitter, 3) 1894 : lfptoms(&estdisp, 3)); 1895 return (1); 1896 } 1897 else 1898 return(1); 1899 } 1900 1901 1902 /* 1903 * dogetpeers - given an association ID, read and print the spreadsheet 1904 * peer variables. 1905 */ 1906 static int 1907 dogetpeers( 1908 struct varlist *pvl, 1909 associd_t associd, 1910 FILE *fp, 1911 int af 1912 ) 1913 { 1914 const char *datap; 1915 int res; 1916 size_t dsize; 1917 u_short rstatus; 1918 1919 #ifdef notdef 1920 res = doquerylist(pvl, CTL_OP_READVAR, associd, 0, &rstatus, 1921 &dsize, &datap); 1922 #else 1923 /* 1924 * Damn fuzzballs 1925 */ 1926 res = doquery(CTL_OP_READVAR, associd, 0, 0, NULL, &rstatus, 1927 &dsize, &datap); 1928 #endif 1929 1930 if (res != 0) 1931 return 0; 1932 1933 if (dsize == 0) { 1934 if (numhosts > 1) 1935 fprintf(stderr, "server=%s ", currenthost); 1936 fprintf(stderr, 1937 "***No information returned for association %u\n", 1938 associd); 1939 return 0; 1940 } 1941 1942 return doprintpeers(pvl, associd, (int)rstatus, dsize, datap, 1943 fp, af); 1944 } 1945 1946 1947 /* 1948 * peers - print a peer spreadsheet 1949 */ 1950 static void 1951 dopeers( 1952 int showall, 1953 FILE *fp, 1954 int af 1955 ) 1956 { 1957 u_int u; 1958 char fullname[LENHOSTNAME]; 1959 sockaddr_u netnum; 1960 const char * name_or_num; 1961 size_t sl; 1962 1963 if (!dogetassoc(fp)) 1964 return; 1965 1966 for (u = 0; u < numhosts; u++) { 1967 if (getnetnum(chosts[u].name, &netnum, fullname, af)) { 1968 name_or_num = nntohost(&netnum); 1969 sl = strlen(name_or_num); 1970 maxhostlen = max(maxhostlen, sl); 1971 } 1972 } 1973 if (numhosts > 1) 1974 fprintf(fp, "%-*.*s ", (int)maxhostlen, (int)maxhostlen, 1975 "server (local)"); 1976 fprintf(fp, 1977 " remote refid st t when poll reach delay offset jitter\n"); 1978 if (numhosts > 1) 1979 for (u = 0; u <= maxhostlen; u++) 1980 fprintf(fp, "="); 1981 fprintf(fp, 1982 "==============================================================================\n"); 1983 1984 for (u = 0; u < numassoc; u++) { 1985 if (!showall && 1986 !(CTL_PEER_STATVAL(assoc_cache[u].status) 1987 & (CTL_PST_CONFIG|CTL_PST_REACH))) { 1988 if (debug) 1989 fprintf(stderr, "eliding [%d]\n", 1990 (int)assoc_cache[u].assid); 1991 continue; 1992 } 1993 if (!dogetpeers(peervarlist, (int)assoc_cache[u].assid, 1994 fp, af)) 1995 return; 1996 } 1997 return; 1998 } 1999 2000 2001 /* 2002 * doapeers - print a peer spreadsheet with assocIDs 2003 */ 2004 static void 2005 doapeers( 2006 int showall, 2007 FILE *fp, 2008 int af 2009 ) 2010 { 2011 u_int u; 2012 char fullname[LENHOSTNAME]; 2013 sockaddr_u netnum; 2014 const char * name_or_num; 2015 size_t sl; 2016 2017 if (!dogetassoc(fp)) 2018 return; 2019 2020 for (u = 0; u < numhosts; u++) { 2021 if (getnetnum(chosts[u].name, &netnum, fullname, af)) { 2022 name_or_num = nntohost(&netnum); 2023 sl = strlen(name_or_num); 2024 maxhostlen = max(maxhostlen, sl); 2025 } 2026 } 2027 if (numhosts > 1) 2028 fprintf(fp, "%-*.*s ", (int)maxhostlen, (int)maxhostlen, 2029 "server (local)"); 2030 fprintf(fp, 2031 " remote refid assid st t when poll reach delay offset jitter\n"); 2032 if (numhosts > 1) 2033 for (u = 0; u <= maxhostlen; u++) 2034 fprintf(fp, "="); 2035 fprintf(fp, 2036 "==============================================================================\n"); 2037 2038 for (u = 0; u < numassoc; u++) { 2039 if (!showall && 2040 !(CTL_PEER_STATVAL(assoc_cache[u].status) 2041 & (CTL_PST_CONFIG|CTL_PST_REACH))) { 2042 if (debug) 2043 fprintf(stderr, "eliding [%d]\n", 2044 (int)assoc_cache[u].assid); 2045 continue; 2046 } 2047 if (!dogetpeers(apeervarlist, (int)assoc_cache[u].assid, 2048 fp, af)) 2049 return; 2050 } 2051 return; 2052 } 2053 2054 2055 /* 2056 * peers - print a peer spreadsheet 2057 */ 2058 /*ARGSUSED*/ 2059 static void 2060 peers( 2061 struct parse *pcmd, 2062 FILE *fp 2063 ) 2064 { 2065 if (drefid == REFID_HASH) { 2066 apeers(pcmd, fp); 2067 } else { 2068 int af = 0; 2069 2070 if (pcmd->nargs == 1) { 2071 if (pcmd->argval->ival == 6) 2072 af = AF_INET6; 2073 else 2074 af = AF_INET; 2075 } 2076 dopeers(0, fp, af); 2077 } 2078 } 2079 2080 2081 /* 2082 * apeers - print a peer spreadsheet, with assocIDs 2083 */ 2084 /*ARGSUSED*/ 2085 static void 2086 apeers( 2087 struct parse *pcmd, 2088 FILE *fp 2089 ) 2090 { 2091 int af = 0; 2092 2093 if (pcmd->nargs == 1) { 2094 if (pcmd->argval->ival == 6) 2095 af = AF_INET6; 2096 else 2097 af = AF_INET; 2098 } 2099 doapeers(0, fp, af); 2100 } 2101 2102 2103 /* 2104 * lpeers - print a peer spreadsheet including all fuzzball peers 2105 */ 2106 /*ARGSUSED*/ 2107 static void 2108 lpeers( 2109 struct parse *pcmd, 2110 FILE *fp 2111 ) 2112 { 2113 int af = 0; 2114 2115 if (pcmd->nargs == 1) { 2116 if (pcmd->argval->ival == 6) 2117 af = AF_INET6; 2118 else 2119 af = AF_INET; 2120 } 2121 dopeers(1, fp, af); 2122 } 2123 2124 2125 /* 2126 * opeers - print a peer spreadsheet 2127 */ 2128 static void 2129 doopeers( 2130 int showall, 2131 FILE *fp, 2132 int af 2133 ) 2134 { 2135 u_int i; 2136 char fullname[LENHOSTNAME]; 2137 sockaddr_u netnum; 2138 2139 if (!dogetassoc(fp)) 2140 return; 2141 2142 for (i = 0; i < numhosts; ++i) { 2143 if (getnetnum(chosts[i].name, &netnum, fullname, af)) 2144 if (strlen(fullname) > maxhostlen) 2145 maxhostlen = strlen(fullname); 2146 } 2147 if (numhosts > 1) 2148 fprintf(fp, "%-*.*s ", (int)maxhostlen, (int)maxhostlen, 2149 "server"); 2150 fprintf(fp, 2151 " remote local st t when poll reach delay offset disp\n"); 2152 if (numhosts > 1) 2153 for (i = 0; i <= maxhostlen; ++i) 2154 fprintf(fp, "="); 2155 fprintf(fp, 2156 "==============================================================================\n"); 2157 2158 for (i = 0; i < numassoc; i++) { 2159 if (!showall && 2160 !(CTL_PEER_STATVAL(assoc_cache[i].status) & 2161 (CTL_PST_CONFIG | CTL_PST_REACH))) 2162 continue; 2163 if (!dogetpeers(opeervarlist, assoc_cache[i].assid, fp, af)) 2164 return; 2165 } 2166 return; 2167 } 2168 2169 2170 /* 2171 * opeers - print a peer spreadsheet the old way 2172 */ 2173 /*ARGSUSED*/ 2174 static void 2175 opeers( 2176 struct parse *pcmd, 2177 FILE *fp 2178 ) 2179 { 2180 int af = 0; 2181 2182 if (pcmd->nargs == 1) { 2183 if (pcmd->argval->ival == 6) 2184 af = AF_INET6; 2185 else 2186 af = AF_INET; 2187 } 2188 doopeers(0, fp, af); 2189 } 2190 2191 2192 /* 2193 * lopeers - print a peer spreadsheet including all fuzzball peers 2194 */ 2195 /*ARGSUSED*/ 2196 static void 2197 lopeers( 2198 struct parse *pcmd, 2199 FILE *fp 2200 ) 2201 { 2202 int af = 0; 2203 2204 if (pcmd->nargs == 1) { 2205 if (pcmd->argval->ival == 6) 2206 af = AF_INET6; 2207 else 2208 af = AF_INET; 2209 } 2210 doopeers(1, fp, af); 2211 } 2212 2213 2214 /* 2215 * config - send a configuration command to a remote host 2216 */ 2217 static void 2218 config ( 2219 struct parse *pcmd, 2220 FILE *fp 2221 ) 2222 { 2223 const char *cfgcmd; 2224 u_short rstatus; 2225 size_t rsize; 2226 const char *rdata; 2227 char *resp; 2228 int res; 2229 int col; 2230 int i; 2231 2232 cfgcmd = pcmd->argval[0].string; 2233 2234 if (debug > 2) 2235 fprintf(stderr, 2236 "In Config\n" 2237 "Keyword = %s\n" 2238 "Command = %s\n", pcmd->keyword, cfgcmd); 2239 2240 res = doquery(CTL_OP_CONFIGURE, 0, 1, 2241 strlen(cfgcmd), cfgcmd, 2242 &rstatus, &rsize, &rdata); 2243 2244 if (res != 0) 2245 return; 2246 2247 if (rsize > 0 && '\n' == rdata[rsize - 1]) 2248 rsize--; 2249 2250 resp = emalloc(rsize + 1); 2251 memcpy(resp, rdata, rsize); 2252 resp[rsize] = '\0'; 2253 2254 col = -1; 2255 if (1 == sscanf(resp, "column %d syntax error", &col) 2256 && col >= 0 && (size_t)col <= strlen(cfgcmd) + 1) { 2257 if (interactive) 2258 fputs(" *", stdout); /* "ntpq> :config " */ 2259 else 2260 printf("%s\n", cfgcmd); 2261 for (i = 0; i < col; i++) 2262 fputc('_', stdout); 2263 fputs("^\n", stdout); 2264 } 2265 printf("%s\n", resp); 2266 free(resp); 2267 } 2268 2269 2270 /* 2271 * config_from_file - remotely configure an ntpd daemon using the 2272 * specified configuration file 2273 * SK: This function is a kludge at best and is full of bad design 2274 * bugs: 2275 * 1. ntpq uses UDP, which means that there is no guarantee of in-order, 2276 * error-free delivery. 2277 * 2. The maximum length of a packet is constrained, and as a result, the 2278 * maximum length of a line in a configuration file is constrained. 2279 * Longer lines will lead to unpredictable results. 2280 * 3. Since this function is sending a line at a time, we can't update 2281 * the control key through the configuration file (YUCK!!) 2282 * 2283 * Pearly: There are a few places where 'size_t' is cast to 'int' based 2284 * on the assumption that 'int' can hold the size of the involved 2285 * buffers without overflow. 2286 */ 2287 static void 2288 config_from_file ( 2289 struct parse *pcmd, 2290 FILE *fp 2291 ) 2292 { 2293 u_short rstatus; 2294 size_t rsize; 2295 const char *rdata; 2296 char * cp; 2297 int res; 2298 FILE *config_fd; 2299 char config_cmd[MAXLINE]; 2300 size_t config_len; 2301 int i; 2302 int retry_limit; 2303 2304 if (debug > 2) 2305 fprintf(stderr, 2306 "In Config\n" 2307 "Keyword = %s\n" 2308 "Filename = %s\n", pcmd->keyword, 2309 pcmd->argval[0].string); 2310 2311 config_fd = fopen(pcmd->argval[0].string, "r"); 2312 if (NULL == config_fd) { 2313 printf("ERROR!! Couldn't open file: %s\n", 2314 pcmd->argval[0].string); 2315 return; 2316 } 2317 2318 printf("Sending configuration file, one line at a time.\n"); 2319 i = 0; 2320 while (fgets(config_cmd, MAXLINE, config_fd) != NULL) { 2321 /* Eliminate comments first. */ 2322 cp = strchr(config_cmd, '#'); 2323 config_len = (NULL != cp) 2324 ? (size_t)(cp - config_cmd) 2325 : strlen(config_cmd); 2326 2327 /* [Bug 3015] make sure there's no trailing whitespace; 2328 * the fix for [Bug 2853] on the server side forbids 2329 * those. And don't transmit empty lines, as this would 2330 * just be waste. 2331 */ 2332 while (config_len != 0 && 2333 (u_char)config_cmd[config_len-1] <= ' ') 2334 --config_len; 2335 config_cmd[config_len] = '\0'; 2336 2337 ++i; 2338 if (0 == config_len) 2339 continue; 2340 2341 retry_limit = 2; 2342 do 2343 res = doquery(CTL_OP_CONFIGURE, 0, 1, 2344 config_len, config_cmd, 2345 &rstatus, &rsize, &rdata); 2346 while (res != 0 && retry_limit--); 2347 if (res != 0) { 2348 printf("Line No: %d query failed: %.*s\n" 2349 "Subsequent lines not sent.\n", 2350 i, (int)config_len, config_cmd); 2351 fclose(config_fd); 2352 return; 2353 } 2354 2355 /* Right-strip the result code string, then output the 2356 * last line executed, with result code. */ 2357 while (rsize != 0 && (u_char)rdata[rsize - 1] <= ' ') 2358 --rsize; 2359 printf("Line No: %d %.*s: %.*s\n", i, 2360 (int)rsize, rdata, 2361 (int)config_len, config_cmd); 2362 } 2363 printf("Done sending file\n"); 2364 fclose(config_fd); 2365 } 2366 2367 2368 static int 2369 fetch_nonce( 2370 char * nonce, 2371 size_t cb_nonce 2372 ) 2373 { 2374 const char nonce_eq[] = "nonce="; 2375 int qres; 2376 u_short rstatus; 2377 size_t rsize; 2378 const char * rdata; 2379 size_t chars; 2380 2381 /* 2382 * Retrieve a nonce specific to this client to demonstrate to 2383 * ntpd that we're capable of receiving responses to our source 2384 * IP address, and thereby unlikely to be forging the source. 2385 */ 2386 qres = doquery(CTL_OP_REQ_NONCE, 0, 0, 0, NULL, &rstatus, 2387 &rsize, &rdata); 2388 if (qres) { 2389 fprintf(stderr, "nonce request failed\n"); 2390 return FALSE; 2391 } 2392 2393 if ((size_t)rsize <= sizeof(nonce_eq) - 1 || 2394 strncmp(rdata, nonce_eq, sizeof(nonce_eq) - 1)) { 2395 fprintf(stderr, "unexpected nonce response format: %.*s\n", 2396 (int)rsize, rdata); /* cast is wobbly */ 2397 return FALSE; 2398 } 2399 chars = rsize - (sizeof(nonce_eq) - 1); 2400 if (chars >= cb_nonce) 2401 return FALSE; 2402 memcpy(nonce, rdata + sizeof(nonce_eq) - 1, chars); 2403 nonce[chars] = '\0'; 2404 while (chars > 0 && 2405 ('\r' == nonce[chars - 1] || '\n' == nonce[chars - 1])) { 2406 chars--; 2407 nonce[chars] = '\0'; 2408 } 2409 2410 return TRUE; 2411 } 2412 2413 2414 /* 2415 * add_mru Add and entry to mru list, hash table, and allocate 2416 * and return a replacement. 2417 * This is a helper for collect_mru_list(). 2418 */ 2419 static mru * 2420 add_mru( 2421 mru *add 2422 ) 2423 { 2424 u_short hash; 2425 mru *mon; 2426 mru *unlinked; 2427 2428 2429 hash = NTP_HASH_ADDR(&add->addr); 2430 /* see if we have it among previously received entries */ 2431 for (mon = hash_table[hash]; mon != NULL; mon = mon->hlink) 2432 if (SOCK_EQ(&mon->addr, &add->addr)) 2433 break; 2434 if (mon != NULL) { 2435 if (!L_ISGEQ(&add->first, &mon->first)) { 2436 fprintf(stderr, 2437 "add_mru duplicate %s new first ts %08x.%08x precedes prior %08x.%08x\n", 2438 sptoa(&add->addr), add->last.l_ui, 2439 add->last.l_uf, mon->last.l_ui, 2440 mon->last.l_uf); 2441 exit(1); 2442 } 2443 UNLINK_DLIST(mon, mlink); 2444 UNLINK_SLIST(unlinked, hash_table[hash], mon, hlink, mru); 2445 INSIST(unlinked == mon); 2446 mru_dupes++; 2447 TRACE(2, ("(updated from %08x.%08x) ", mon->last.l_ui, 2448 mon->last.l_uf)); 2449 } 2450 LINK_DLIST(mru_list, add, mlink); 2451 LINK_SLIST(hash_table[hash], add, hlink); 2452 TRACE(2, ("add_mru %08x.%08x c %d m %d v %d rest %x first %08x.%08x %s\n", 2453 add->last.l_ui, add->last.l_uf, add->count, 2454 (int)add->mode, (int)add->ver, (u_int)add->rs, 2455 add->first.l_ui, add->first.l_uf, sptoa(&add->addr))); 2456 /* if we didn't update an existing entry, alloc replacement */ 2457 if (NULL == mon) { 2458 mon = emalloc(sizeof(*mon)); 2459 mru_count++; 2460 } 2461 ZERO(*mon); 2462 2463 return mon; 2464 } 2465 2466 2467 /* MGOT macro is specific to collect_mru_list() */ 2468 #define MGOT(bit) \ 2469 do { \ 2470 got |= (bit); \ 2471 if (MRU_GOT_ALL == got) { \ 2472 got = 0; \ 2473 mon = add_mru(mon); \ 2474 ci++; \ 2475 } \ 2476 } while (0) 2477 2478 2479 int 2480 mrulist_ctrl_c_hook(void) 2481 { 2482 mrulist_interrupted = TRUE; 2483 return TRUE; 2484 } 2485 2486 2487 static int 2488 collect_mru_list( 2489 const char * parms, 2490 l_fp * pnow 2491 ) 2492 { 2493 const u_int sleep_msecs = 5; 2494 static int ntpd_row_limit = MRU_ROW_LIMIT; 2495 int c_mru_l_rc; /* this function's return code */ 2496 u_char got; /* MRU_GOT_* bits */ 2497 time_t next_report; 2498 size_t cb; 2499 mru *mon; 2500 mru *head; 2501 mru *recent; 2502 int list_complete; 2503 char nonce[128]; 2504 char buf[128]; 2505 char req_buf[CTL_MAX_DATA_LEN]; 2506 char *req; 2507 char *req_end; 2508 size_t chars; 2509 int qres; 2510 u_short rstatus; 2511 size_t rsize; 2512 const char *rdata; 2513 int limit; 2514 int frags; 2515 int cap_frags; 2516 char *tag; 2517 char *val; 2518 int si; /* server index in response */ 2519 int ci; /* client (our) index for validation */ 2520 int ri; /* request index (.# suffix) */ 2521 int mv; 2522 l_fp newest; 2523 l_fp last_older; 2524 sockaddr_u addr_older; 2525 int have_now; 2526 int have_addr_older; 2527 int have_last_older; 2528 u_int restarted_count; 2529 u_int nonce_uses; 2530 u_short hash; 2531 mru *unlinked; 2532 2533 if (!fetch_nonce(nonce, sizeof(nonce))) 2534 return FALSE; 2535 2536 nonce_uses = 0; 2537 restarted_count = 0; 2538 mru_count = 0; 2539 INIT_DLIST(mru_list, mlink); 2540 cb = NTP_HASH_SIZE * sizeof(*hash_table); 2541 INSIST(NULL == hash_table); 2542 hash_table = emalloc_zero(cb); 2543 2544 c_mru_l_rc = FALSE; 2545 list_complete = FALSE; 2546 have_now = FALSE; 2547 cap_frags = TRUE; 2548 got = 0; 2549 ri = 0; 2550 cb = sizeof(*mon); 2551 mon = emalloc_zero(cb); 2552 ZERO(*pnow); 2553 ZERO(last_older); 2554 next_report = time(NULL) + MRU_REPORT_SECS; 2555 2556 limit = min(3 * MAXFRAGS, ntpd_row_limit); 2557 frags = MAXFRAGS; 2558 snprintf(req_buf, sizeof(req_buf), "nonce=%s, frags=%d%s", 2559 nonce, frags, parms); 2560 nonce_uses++; 2561 2562 while (TRUE) { 2563 if (debug) 2564 fprintf(stderr, "READ_MRU parms: %s\n", req_buf); 2565 2566 qres = doqueryex(CTL_OP_READ_MRU, 0, 0, 2567 strlen(req_buf), req_buf, 2568 &rstatus, &rsize, &rdata, TRUE); 2569 2570 if (CERR_UNKNOWNVAR == qres && ri > 0) { 2571 /* 2572 * None of the supplied prior entries match, so 2573 * toss them from our list and try again. 2574 */ 2575 if (debug) 2576 fprintf(stderr, 2577 "no overlap between %d prior entries and server MRU list\n", 2578 ri); 2579 while (ri--) { 2580 recent = HEAD_DLIST(mru_list, mlink); 2581 INSIST(recent != NULL); 2582 if (debug) 2583 fprintf(stderr, 2584 "tossing prior entry %s to resync\n", 2585 sptoa(&recent->addr)); 2586 UNLINK_DLIST(recent, mlink); 2587 hash = NTP_HASH_ADDR(&recent->addr); 2588 UNLINK_SLIST(unlinked, hash_table[hash], 2589 recent, hlink, mru); 2590 INSIST(unlinked == recent); 2591 free(recent); 2592 mru_count--; 2593 } 2594 if (NULL == HEAD_DLIST(mru_list, mlink)) { 2595 restarted_count++; 2596 if (restarted_count > 8) { 2597 fprintf(stderr, 2598 "Giving up after 8 restarts from the beginning.\n" 2599 "With high-traffic NTP servers, this can occur if the\n" 2600 "MRU list is limited to less than about 16 seconds' of\n" 2601 "entries. See the 'mru' ntp.conf directive to adjust.\n"); 2602 goto cleanup_return; 2603 } 2604 if (debug) 2605 fprintf(stderr, 2606 "---> Restarting from the beginning, retry #%u\n", 2607 restarted_count); 2608 } 2609 } else if (CERR_UNKNOWNVAR == qres) { 2610 fprintf(stderr, 2611 "CERR_UNKNOWNVAR from ntpd but no priors given.\n"); 2612 goto cleanup_return; 2613 } else if (CERR_BADVALUE == qres) { 2614 if (cap_frags) { 2615 cap_frags = FALSE; 2616 if (debug) 2617 fprintf(stderr, 2618 "Reverted to row limit from fragments limit.\n"); 2619 } else { 2620 /* ntpd has lower cap on row limit */ 2621 ntpd_row_limit--; 2622 limit = min(limit, ntpd_row_limit); 2623 if (debug) 2624 fprintf(stderr, 2625 "Row limit reduced to %d following CERR_BADVALUE.\n", 2626 limit); 2627 } 2628 } else if (ERR_INCOMPLETE == qres || 2629 ERR_TIMEOUT == qres) { 2630 /* 2631 * Reduce the number of rows/frags requested by 2632 * half to recover from lost response fragments. 2633 */ 2634 if (cap_frags) { 2635 frags = max(2, frags / 2); 2636 if (debug) 2637 fprintf(stderr, 2638 "Frag limit reduced to %d following incomplete response.\n", 2639 frags); 2640 } else { 2641 limit = max(2, limit / 2); 2642 if (debug) 2643 fprintf(stderr, 2644 "Row limit reduced to %d following incomplete response.\n", 2645 limit); 2646 } 2647 } else if (qres) { 2648 show_error_msg(qres, 0); 2649 goto cleanup_return; 2650 } 2651 /* 2652 * This is a cheap cop-out implementation of rawmode 2653 * output for mrulist. A better approach would be to 2654 * dump similar output after the list is collected by 2655 * ntpq with a continuous sequence of indexes. This 2656 * cheap approach has indexes resetting to zero for 2657 * each query/response, and duplicates are not 2658 * coalesced. 2659 */ 2660 if (!qres && rawmode) 2661 printvars(rsize, rdata, rstatus, TYPE_SYS, 1, stdout); 2662 ci = 0; 2663 have_addr_older = FALSE; 2664 have_last_older = FALSE; 2665 while (!qres && nextvar(&rsize, &rdata, &tag, &val)) { 2666 INSIST(tag && val); 2667 if (debug > 1) 2668 fprintf(stderr, "nextvar gave: %s = %s\n", 2669 tag, val); 2670 switch(tag[0]) { 2671 2672 case 'a': 2673 if (!strcmp(tag, "addr.older")) { 2674 if (!have_last_older) { 2675 fprintf(stderr, 2676 "addr.older %s before last.older\n", 2677 val); 2678 goto cleanup_return; 2679 } 2680 if (!decodenetnum(val, &addr_older)) { 2681 fprintf(stderr, 2682 "addr.older %s garbled\n", 2683 val); 2684 goto cleanup_return; 2685 } 2686 hash = NTP_HASH_ADDR(&addr_older); 2687 for (recent = hash_table[hash]; 2688 recent != NULL; 2689 recent = recent->hlink) 2690 if (ADDR_PORT_EQ( 2691 &addr_older, 2692 &recent->addr)) 2693 break; 2694 if (NULL == recent) { 2695 fprintf(stderr, 2696 "addr.older %s not in hash table\n", 2697 val); 2698 goto cleanup_return; 2699 } 2700 if (!L_ISEQU(&last_older, 2701 &recent->last)) { 2702 fprintf(stderr, 2703 "last.older %08x.%08x mismatches %08x.%08x expected.\n", 2704 last_older.l_ui, 2705 last_older.l_uf, 2706 recent->last.l_ui, 2707 recent->last.l_uf); 2708 goto cleanup_return; 2709 } 2710 have_addr_older = TRUE; 2711 } else if (1 != sscanf(tag, "addr.%d", &si) 2712 || si != ci) 2713 goto nomatch; 2714 else if (decodenetnum(val, &mon->addr)) 2715 MGOT(MRU_GOT_ADDR); 2716 break; 2717 2718 case 'l': 2719 if (!strcmp(tag, "last.older")) { 2720 if ('0' != val[0] || 2721 'x' != val[1] || 2722 !hextolfp(val + 2, &last_older)) { 2723 fprintf(stderr, 2724 "last.older %s garbled\n", 2725 val); 2726 goto cleanup_return; 2727 } 2728 have_last_older = TRUE; 2729 } else if (!strcmp(tag, "last.newest")) { 2730 if (0 != got) { 2731 fprintf(stderr, 2732 "last.newest %s before complete row, got = 0x%x\n", 2733 val, (u_int)got); 2734 goto cleanup_return; 2735 } 2736 if (!have_now) { 2737 fprintf(stderr, 2738 "last.newest %s before now=\n", 2739 val); 2740 goto cleanup_return; 2741 } 2742 head = HEAD_DLIST(mru_list, mlink); 2743 if (NULL != head) { 2744 if ('0' != val[0] || 2745 'x' != val[1] || 2746 !hextolfp(val + 2, &newest) || 2747 !L_ISEQU(&newest, 2748 &head->last)) { 2749 fprintf(stderr, 2750 "last.newest %s mismatches %08x.%08x", 2751 val, 2752 head->last.l_ui, 2753 head->last.l_uf); 2754 goto cleanup_return; 2755 } 2756 } 2757 list_complete = TRUE; 2758 } else if (1 != sscanf(tag, "last.%d", &si) || 2759 si != ci || '0' != val[0] || 2760 'x' != val[1] || 2761 !hextolfp(val + 2, &mon->last)) { 2762 goto nomatch; 2763 } else { 2764 MGOT(MRU_GOT_LAST); 2765 /* 2766 * allow interrupted retrieval, 2767 * using most recent retrieved 2768 * entry's last seen timestamp 2769 * as the end of operation. 2770 */ 2771 *pnow = mon->last; 2772 } 2773 break; 2774 2775 case 'f': 2776 if (1 != sscanf(tag, "first.%d", &si) || 2777 si != ci || '0' != val[0] || 2778 'x' != val[1] || 2779 !hextolfp(val + 2, &mon->first)) 2780 goto nomatch; 2781 MGOT(MRU_GOT_FIRST); 2782 break; 2783 2784 case 'n': 2785 if (!strcmp(tag, "nonce")) { 2786 strlcpy(nonce, val, sizeof(nonce)); 2787 nonce_uses = 0; 2788 break; /* case */ 2789 } else if (strcmp(tag, "now") || 2790 '0' != val[0] || 2791 'x' != val[1] || 2792 !hextolfp(val + 2, pnow)) 2793 goto nomatch; 2794 have_now = TRUE; 2795 break; 2796 2797 case 'c': 2798 if (1 != sscanf(tag, "ct.%d", &si) || 2799 si != ci || 2800 1 != sscanf(val, "%d", &mon->count) 2801 || mon->count < 1) 2802 goto nomatch; 2803 MGOT(MRU_GOT_COUNT); 2804 break; 2805 2806 case 'm': 2807 if (1 != sscanf(tag, "mv.%d", &si) || 2808 si != ci || 2809 1 != sscanf(val, "%d", &mv)) 2810 goto nomatch; 2811 mon->mode = PKT_MODE(mv); 2812 mon->ver = PKT_VERSION(mv); 2813 MGOT(MRU_GOT_MV); 2814 break; 2815 2816 case 'r': 2817 if (1 != sscanf(tag, "rs.%d", &si) || 2818 si != ci || 2819 1 != sscanf(val, "0x%hx", &mon->rs)) 2820 goto nomatch; 2821 MGOT(MRU_GOT_RS); 2822 break; 2823 2824 default: 2825 nomatch: 2826 /* empty stmt */ ; 2827 /* ignore unknown tags */ 2828 } 2829 } 2830 if (have_now) 2831 list_complete = TRUE; 2832 if (list_complete) { 2833 INSIST(0 == ri || have_addr_older); 2834 } 2835 if (mrulist_interrupted) { 2836 printf("mrulist retrieval interrupted by operator.\n" 2837 "Displaying partial client list.\n"); 2838 fflush(stdout); 2839 } 2840 if (list_complete || mrulist_interrupted) { 2841 fprintf(stderr, 2842 "\rRetrieved %u unique MRU entries and %u updates.\n", 2843 mru_count, mru_dupes); 2844 fflush(stderr); 2845 break; 2846 } 2847 if (time(NULL) >= next_report) { 2848 next_report += MRU_REPORT_SECS; 2849 fprintf(stderr, "\r%u (%u updates) ", mru_count, 2850 mru_dupes); 2851 fflush(stderr); 2852 } 2853 2854 /* 2855 * Snooze for a bit between queries to let ntpd catch 2856 * up with other duties. 2857 */ 2858 #ifdef SYS_WINNT 2859 Sleep(sleep_msecs); 2860 #elif !defined(HAVE_NANOSLEEP) 2861 sleep((sleep_msecs / 1000) + 1); 2862 #else 2863 { 2864 struct timespec interv = { 0, 2865 1000 * sleep_msecs }; 2866 nanosleep(&interv, NULL); 2867 } 2868 #endif 2869 /* 2870 * If there were no errors, increase the number of rows 2871 * to a maximum of 3 * MAXFRAGS (the most packets ntpq 2872 * can handle in one response), on the assumption that 2873 * no less than 3 rows fit in each packet, capped at 2874 * our best guess at the server's row limit. 2875 */ 2876 if (!qres) { 2877 if (cap_frags) { 2878 frags = min(MAXFRAGS, frags + 1); 2879 } else { 2880 limit = min3(3 * MAXFRAGS, 2881 ntpd_row_limit, 2882 max(limit + 1, 2883 limit * 33 / 32)); 2884 } 2885 } 2886 /* 2887 * prepare next query with as many address and last-seen 2888 * timestamps as will fit in a single packet. 2889 */ 2890 req = req_buf; 2891 req_end = req_buf + sizeof(req_buf); 2892 #define REQ_ROOM (req_end - req) 2893 snprintf(req, REQ_ROOM, "nonce=%s, %s=%d%s", nonce, 2894 (cap_frags) 2895 ? "frags" 2896 : "limit", 2897 (cap_frags) 2898 ? frags 2899 : limit, 2900 parms); 2901 req += strlen(req); 2902 nonce_uses++; 2903 if (nonce_uses >= 4) { 2904 if (!fetch_nonce(nonce, sizeof(nonce))) 2905 goto cleanup_return; 2906 nonce_uses = 0; 2907 } 2908 2909 2910 for (ri = 0, recent = HEAD_DLIST(mru_list, mlink); 2911 recent != NULL; 2912 ri++, recent = NEXT_DLIST(mru_list, recent, mlink)) { 2913 2914 snprintf(buf, sizeof(buf), 2915 ", addr.%d=%s, last.%d=0x%08x.%08x", 2916 ri, sptoa(&recent->addr), ri, 2917 recent->last.l_ui, recent->last.l_uf); 2918 chars = strlen(buf); 2919 if ((size_t)REQ_ROOM <= chars) 2920 break; 2921 memcpy(req, buf, chars + 1); 2922 req += chars; 2923 } 2924 } 2925 2926 c_mru_l_rc = TRUE; 2927 goto retain_hash_table; 2928 2929 cleanup_return: 2930 free(hash_table); 2931 hash_table = NULL; 2932 2933 retain_hash_table: 2934 if (mon != NULL) 2935 free(mon); 2936 2937 return c_mru_l_rc; 2938 } 2939 2940 2941 /* 2942 * qcmp_mru_addr - sort MRU entries by remote address. 2943 * 2944 * All IPv4 addresses sort before any IPv6, addresses are sorted by 2945 * value within address family. 2946 */ 2947 static int 2948 qcmp_mru_addr( 2949 const void *v1, 2950 const void *v2 2951 ) 2952 { 2953 const mru * const * ppm1 = v1; 2954 const mru * const * ppm2 = v2; 2955 const mru * pm1; 2956 const mru * pm2; 2957 u_short af1; 2958 u_short af2; 2959 size_t cmplen; 2960 size_t addr_off; 2961 2962 pm1 = *ppm1; 2963 pm2 = *ppm2; 2964 2965 af1 = AF(&pm1->addr); 2966 af2 = AF(&pm2->addr); 2967 2968 if (af1 != af2) 2969 return (AF_INET == af1) 2970 ? -1 2971 : 1; 2972 2973 cmplen = SIZEOF_INADDR(af1); 2974 addr_off = (AF_INET == af1) 2975 ? offsetof(struct sockaddr_in, sin_addr) 2976 : offsetof(struct sockaddr_in6, sin6_addr); 2977 2978 return memcmp((const char *)&pm1->addr + addr_off, 2979 (const char *)&pm2->addr + addr_off, 2980 cmplen); 2981 } 2982 2983 2984 static int 2985 qcmp_mru_r_addr( 2986 const void *v1, 2987 const void *v2 2988 ) 2989 { 2990 return -qcmp_mru_addr(v1, v2); 2991 } 2992 2993 2994 /* 2995 * qcmp_mru_count - sort MRU entries by times seen (hit count). 2996 */ 2997 static int 2998 qcmp_mru_count( 2999 const void *v1, 3000 const void *v2 3001 ) 3002 { 3003 const mru * const * ppm1 = v1; 3004 const mru * const * ppm2 = v2; 3005 const mru * pm1; 3006 const mru * pm2; 3007 3008 pm1 = *ppm1; 3009 pm2 = *ppm2; 3010 3011 return (pm1->count < pm2->count) 3012 ? -1 3013 : ((pm1->count == pm2->count) 3014 ? 0 3015 : 1); 3016 } 3017 3018 3019 static int 3020 qcmp_mru_r_count( 3021 const void *v1, 3022 const void *v2 3023 ) 3024 { 3025 return -qcmp_mru_count(v1, v2); 3026 } 3027 3028 3029 /* 3030 * qcmp_mru_avgint - sort MRU entries by average interval. 3031 */ 3032 static int 3033 qcmp_mru_avgint( 3034 const void *v1, 3035 const void *v2 3036 ) 3037 { 3038 const mru * const * ppm1 = v1; 3039 const mru * const * ppm2 = v2; 3040 const mru * pm1; 3041 const mru * pm2; 3042 l_fp interval; 3043 double avg1; 3044 double avg2; 3045 3046 pm1 = *ppm1; 3047 pm2 = *ppm2; 3048 3049 interval = pm1->last; 3050 L_SUB(&interval, &pm1->first); 3051 LFPTOD(&interval, avg1); 3052 avg1 /= pm1->count; 3053 3054 interval = pm2->last; 3055 L_SUB(&interval, &pm2->first); 3056 LFPTOD(&interval, avg2); 3057 avg2 /= pm2->count; 3058 3059 if (avg1 < avg2) 3060 return -1; 3061 else if (avg1 > avg2) 3062 return 1; 3063 3064 /* secondary sort on lstint - rarely tested */ 3065 if (L_ISEQU(&pm1->last, &pm2->last)) 3066 return 0; 3067 else if (L_ISGEQ(&pm1->last, &pm2->last)) 3068 return -1; 3069 else 3070 return 1; 3071 } 3072 3073 3074 static int 3075 qcmp_mru_r_avgint( 3076 const void *v1, 3077 const void *v2 3078 ) 3079 { 3080 return -qcmp_mru_avgint(v1, v2); 3081 } 3082 3083 3084 /* 3085 * mrulist - ntpq's mrulist command to fetch an arbitrarily large Most 3086 * Recently Used (seen) remote address list from ntpd. 3087 * 3088 * Similar to ntpdc's monlist command, but not limited to a single 3089 * request/response, and thereby not limited to a few hundred remote 3090 * addresses. 3091 * 3092 * See ntpd/ntp_control.c read_mru_list() for comments on the way 3093 * CTL_OP_READ_MRU is designed to be used. 3094 * 3095 * mrulist intentionally differs from monlist in the way the avgint 3096 * column is calculated. monlist includes the time after the last 3097 * packet from the client until the monlist query time in the average, 3098 * while mrulist excludes it. That is, monlist's average interval grows 3099 * over time for remote addresses not heard from in some time, while it 3100 * remains unchanged in mrulist. This also affects the avgint value for 3101 * entries representing a single packet, with identical first and last 3102 * timestamps. mrulist shows 0 avgint, monlist shows a value identical 3103 * to lstint. 3104 */ 3105 static void 3106 mrulist( 3107 struct parse * pcmd, 3108 FILE * fp 3109 ) 3110 { 3111 const char mincount_eq[] = "mincount="; 3112 const char resall_eq[] = "resall="; 3113 const char resany_eq[] = "resany="; 3114 const char maxlstint_eq[] = "maxlstint="; 3115 const char laddr_eq[] = "laddr="; 3116 const char sort_eq[] = "sort="; 3117 mru_sort_order order; 3118 size_t n; 3119 char parms_buf[128]; 3120 char buf[24]; 3121 char *parms; 3122 const char *arg; 3123 size_t cb; 3124 mru **sorted; 3125 mru **ppentry; 3126 mru *recent; 3127 l_fp now; 3128 l_fp interval; 3129 double favgint; 3130 double flstint; 3131 int avgint; 3132 int lstint; 3133 size_t i; 3134 3135 mrulist_interrupted = FALSE; 3136 push_ctrl_c_handler(&mrulist_ctrl_c_hook); 3137 fprintf(stderr, 3138 "Ctrl-C will stop MRU retrieval and display partial results.\n"); 3139 fflush(stderr); 3140 3141 order = MRUSORT_DEF; 3142 parms_buf[0] = '\0'; 3143 parms = parms_buf; 3144 for (i = 0; i < pcmd->nargs; i++) { 3145 arg = pcmd->argval[i].string; 3146 if (arg != NULL) { 3147 cb = strlen(arg) + 1; 3148 if ((!strncmp(resall_eq, arg, sizeof(resall_eq) 3149 - 1) || !strncmp(resany_eq, arg, 3150 sizeof(resany_eq) - 1) || !strncmp( 3151 mincount_eq, arg, sizeof(mincount_eq) - 1) 3152 || !strncmp(laddr_eq, arg, sizeof(laddr_eq) 3153 - 1) || !strncmp(maxlstint_eq, arg, 3154 sizeof(laddr_eq) - 1)) && parms + cb + 2 <= 3155 parms_buf + sizeof(parms_buf)) { 3156 /* these are passed intact to ntpd */ 3157 memcpy(parms, ", ", 2); 3158 parms += 2; 3159 memcpy(parms, arg, cb); 3160 parms += cb - 1; 3161 } else if (!strncmp(sort_eq, arg, 3162 sizeof(sort_eq) - 1)) { 3163 arg += sizeof(sort_eq) - 1; 3164 for (n = 0; 3165 n < COUNTOF(mru_sort_keywords); 3166 n++) 3167 if (!strcmp(mru_sort_keywords[n], 3168 arg)) 3169 break; 3170 if (n < COUNTOF(mru_sort_keywords)) 3171 order = n; 3172 } else if (!strcmp("limited", arg) || 3173 !strcmp("kod", arg)) { 3174 /* transform to resany=... */ 3175 snprintf(buf, sizeof(buf), 3176 ", resany=0x%x", 3177 ('k' == arg[0]) 3178 ? RES_KOD 3179 : RES_LIMITED); 3180 cb = 1 + strlen(buf); 3181 if (parms + cb < 3182 parms_buf + sizeof(parms_buf)) { 3183 memcpy(parms, buf, cb); 3184 parms += cb - 1; 3185 } 3186 } else 3187 fprintf(stderr, 3188 "ignoring unrecognized mrulist parameter: %s\n", 3189 arg); 3190 } 3191 } 3192 parms = parms_buf; 3193 3194 if (!collect_mru_list(parms, &now)) 3195 return; 3196 3197 /* display the results */ 3198 if (rawmode) 3199 goto cleanup_return; 3200 3201 /* construct an array of entry pointers in default order */ 3202 sorted = eallocarray(mru_count, sizeof(*sorted)); 3203 ppentry = sorted; 3204 if (MRUSORT_R_DEF != order) { 3205 ITER_DLIST_BEGIN(mru_list, recent, mlink, mru) 3206 INSIST(ppentry < sorted + mru_count); 3207 *ppentry = recent; 3208 ppentry++; 3209 ITER_DLIST_END() 3210 } else { 3211 REV_ITER_DLIST_BEGIN(mru_list, recent, mlink, mru) 3212 INSIST(ppentry < sorted + mru_count); 3213 *ppentry = recent; 3214 ppentry++; 3215 REV_ITER_DLIST_END() 3216 } 3217 3218 if (ppentry - sorted != (int)mru_count) { 3219 fprintf(stderr, 3220 "mru_count %u should match MRU list depth %ld.\n", 3221 mru_count, (long)(ppentry - sorted)); 3222 free(sorted); 3223 goto cleanup_return; 3224 } 3225 3226 /* re-sort sorted[] if not default or reverse default */ 3227 if (MRUSORT_R_DEF < order) 3228 qsort(sorted, mru_count, sizeof(sorted[0]), 3229 mru_qcmp_table[order]); 3230 3231 mrulist_interrupted = FALSE; 3232 printf( "lstint avgint rstr r m v count rport remote address\n" 3233 "==============================================================================\n"); 3234 /* '=' x 78 */ 3235 for (ppentry = sorted; ppentry < sorted + mru_count; ppentry++) { 3236 recent = *ppentry; 3237 interval = now; 3238 L_SUB(&interval, &recent->last); 3239 LFPTOD(&interval, flstint); 3240 lstint = (int)(flstint + 0.5); 3241 interval = recent->last; 3242 L_SUB(&interval, &recent->first); 3243 LFPTOD(&interval, favgint); 3244 favgint /= recent->count; 3245 avgint = (int)(favgint + 0.5); 3246 fprintf(fp, "%6d %6d %4hx %c %d %d %6d %5u %s\n", 3247 lstint, avgint, recent->rs, 3248 (RES_KOD & recent->rs) 3249 ? 'K' 3250 : (RES_LIMITED & recent->rs) 3251 ? 'L' 3252 : '.', 3253 (int)recent->mode, (int)recent->ver, 3254 recent->count, SRCPORT(&recent->addr), 3255 nntohost(&recent->addr)); 3256 if (showhostnames) 3257 fflush(fp); 3258 if (mrulist_interrupted) { 3259 fputs("\n --interrupted--\n", fp); 3260 fflush(fp); 3261 break; 3262 } 3263 } 3264 fflush(fp); 3265 if (debug) { 3266 fprintf(stderr, 3267 "--- completed, freeing sorted[] pointers\n"); 3268 fflush(stderr); 3269 } 3270 free(sorted); 3271 3272 cleanup_return: 3273 if (debug) { 3274 fprintf(stderr, "... freeing MRU entries\n"); 3275 fflush(stderr); 3276 } 3277 ITER_DLIST_BEGIN(mru_list, recent, mlink, mru) 3278 free(recent); 3279 ITER_DLIST_END() 3280 if (debug) { 3281 fprintf(stderr, "... freeing hash_table[]\n"); 3282 fflush(stderr); 3283 } 3284 free(hash_table); 3285 hash_table = NULL; 3286 INIT_DLIST(mru_list, mlink); 3287 3288 pop_ctrl_c_handler(&mrulist_ctrl_c_hook); 3289 } 3290 3291 3292 /* 3293 * validate_ifnum - helper for ifstats() 3294 * 3295 * Ensures rows are received in order and complete. 3296 */ 3297 static void 3298 validate_ifnum( 3299 FILE * fp, 3300 u_int ifnum, 3301 int * pfields, 3302 ifstats_row * prow 3303 ) 3304 { 3305 if (prow->ifnum == ifnum) 3306 return; 3307 if (prow->ifnum + 1 <= ifnum) { 3308 if (*pfields < IFSTATS_FIELDS) 3309 fprintf(fp, "Warning: incomplete row with %d (of %d) fields\n", 3310 *pfields, IFSTATS_FIELDS); 3311 *pfields = 0; 3312 prow->ifnum = ifnum; 3313 return; 3314 } 3315 fprintf(stderr, 3316 "received if index %u, have %d of %d fields for index %u, aborting.\n", 3317 ifnum, *pfields, IFSTATS_FIELDS, prow->ifnum); 3318 exit(1); 3319 } 3320 3321 3322 /* 3323 * another_ifstats_field - helper for ifstats() 3324 * 3325 * If all fields for the row have been received, print it. 3326 */ 3327 static void 3328 another_ifstats_field( 3329 int * pfields, 3330 ifstats_row * prow, 3331 FILE * fp 3332 ) 3333 { 3334 u_int ifnum; 3335 3336 (*pfields)++; 3337 /* we understand 12 tags */ 3338 if (IFSTATS_FIELDS > *pfields) 3339 return; 3340 /* 3341 " interface name send\n" 3342 " # address/broadcast drop flag ttl mc received sent failed peers uptime\n" 3343 "==============================================================================\n"); 3344 */ 3345 fprintf(fp, 3346 "%3u %-24.24s %c %4x %3u %2u %6u %6u %6u %5u %8d\n" 3347 " %s\n", 3348 prow->ifnum, prow->name, 3349 (prow->enabled) 3350 ? '.' 3351 : 'D', 3352 prow->flags, prow->ttl, prow->mcast_count, 3353 prow->received, prow->sent, prow->send_errors, 3354 prow->peer_count, prow->uptime, sptoa(&prow->addr)); 3355 if (!SOCK_UNSPEC(&prow->bcast)) 3356 fprintf(fp, " %s\n", sptoa(&prow->bcast)); 3357 ifnum = prow->ifnum; 3358 ZERO(*prow); 3359 prow->ifnum = ifnum; 3360 } 3361 3362 3363 /* 3364 * ifstats - ntpq -c ifstats modeled on ntpdc -c ifstats. 3365 */ 3366 static void 3367 ifstats( 3368 struct parse * pcmd, 3369 FILE * fp 3370 ) 3371 { 3372 const char addr_fmt[] = "addr.%u"; 3373 const char bcast_fmt[] = "bcast.%u"; 3374 const char en_fmt[] = "en.%u"; /* enabled */ 3375 const char flags_fmt[] = "flags.%u"; 3376 const char mc_fmt[] = "mc.%u"; /* mcast count */ 3377 const char name_fmt[] = "name.%u"; 3378 const char pc_fmt[] = "pc.%u"; /* peer count */ 3379 const char rx_fmt[] = "rx.%u"; 3380 const char tl_fmt[] = "tl.%u"; /* ttl */ 3381 const char tx_fmt[] = "tx.%u"; 3382 const char txerr_fmt[] = "txerr.%u"; 3383 const char up_fmt[] = "up.%u"; /* uptime */ 3384 const char * datap; 3385 int qres; 3386 size_t dsize; 3387 u_short rstatus; 3388 char * tag; 3389 char * val; 3390 int fields; 3391 u_int ui; 3392 ifstats_row row; 3393 int comprende; 3394 size_t len; 3395 3396 qres = doquery(CTL_OP_READ_ORDLIST_A, 0, TRUE, 0, NULL, &rstatus, 3397 &dsize, &datap); 3398 if (qres) /* message already displayed */ 3399 return; 3400 3401 fprintf(fp, 3402 " interface name send\n" 3403 " # address/broadcast drop flag ttl mc received sent failed peers uptime\n" 3404 "==============================================================================\n"); 3405 /* '=' x 78 */ 3406 3407 ZERO(row); 3408 fields = 0; 3409 ui = 0; 3410 while (nextvar(&dsize, &datap, &tag, &val)) { 3411 INSIST(tag && val); 3412 if (debug > 1) 3413 fprintf(stderr, "nextvar gave: %s = %s\n", tag, val); 3414 comprende = FALSE; 3415 switch(tag[0]) { 3416 3417 case 'a': 3418 if (1 == sscanf(tag, addr_fmt, &ui) && 3419 decodenetnum(val, &row.addr)) 3420 comprende = TRUE; 3421 break; 3422 3423 case 'b': 3424 if (1 == sscanf(tag, bcast_fmt, &ui) && 3425 ('\0' == *val || 3426 decodenetnum(val, &row.bcast))) 3427 comprende = TRUE; 3428 break; 3429 3430 case 'e': 3431 if (1 == sscanf(tag, en_fmt, &ui) && 3432 1 == sscanf(val, "%d", &row.enabled)) 3433 comprende = TRUE; 3434 break; 3435 3436 case 'f': 3437 if (1 == sscanf(tag, flags_fmt, &ui) && 3438 1 == sscanf(val, "0x%x", &row.flags)) 3439 comprende = TRUE; 3440 break; 3441 3442 case 'm': 3443 if (1 == sscanf(tag, mc_fmt, &ui) && 3444 1 == sscanf(val, "%u", &row.mcast_count)) 3445 comprende = TRUE; 3446 break; 3447 3448 case 'n': 3449 if (1 == sscanf(tag, name_fmt, &ui)) { 3450 /* strip quotes */ 3451 len = strlen(val); 3452 if (len >= 2 && 3453 len - 2 < sizeof(row.name)) { 3454 len -= 2; 3455 memcpy(row.name, val + 1, len); 3456 row.name[len] = '\0'; 3457 comprende = TRUE; 3458 } 3459 } 3460 break; 3461 3462 case 'p': 3463 if (1 == sscanf(tag, pc_fmt, &ui) && 3464 1 == sscanf(val, "%u", &row.peer_count)) 3465 comprende = TRUE; 3466 break; 3467 3468 case 'r': 3469 if (1 == sscanf(tag, rx_fmt, &ui) && 3470 1 == sscanf(val, "%u", &row.received)) 3471 comprende = TRUE; 3472 break; 3473 3474 case 't': 3475 if (1 == sscanf(tag, tl_fmt, &ui) && 3476 1 == sscanf(val, "%u", &row.ttl)) 3477 comprende = TRUE; 3478 else if (1 == sscanf(tag, tx_fmt, &ui) && 3479 1 == sscanf(val, "%u", &row.sent)) 3480 comprende = TRUE; 3481 else if (1 == sscanf(tag, txerr_fmt, &ui) && 3482 1 == sscanf(val, "%u", &row.send_errors)) 3483 comprende = TRUE; 3484 break; 3485 3486 case 'u': 3487 if (1 == sscanf(tag, up_fmt, &ui) && 3488 1 == sscanf(val, "%u", &row.uptime)) 3489 comprende = TRUE; 3490 break; 3491 } 3492 3493 if (comprende) { 3494 /* error out if rows out of order */ 3495 validate_ifnum(fp, ui, &fields, &row); 3496 /* if the row is complete, print it */ 3497 another_ifstats_field(&fields, &row, fp); 3498 } 3499 } 3500 if (fields != IFSTATS_FIELDS) 3501 fprintf(fp, "Warning: incomplete row with %d (of %d) fields\n", 3502 fields, IFSTATS_FIELDS); 3503 3504 fflush(fp); 3505 } 3506 3507 3508 /* 3509 * validate_reslist_idx - helper for reslist() 3510 * 3511 * Ensures rows are received in order and complete. 3512 */ 3513 static void 3514 validate_reslist_idx( 3515 FILE * fp, 3516 u_int idx, 3517 int * pfields, 3518 reslist_row * prow 3519 ) 3520 { 3521 if (prow->idx == idx) 3522 return; 3523 if (prow->idx + 1 == idx) { 3524 if (*pfields < RESLIST_FIELDS) 3525 fprintf(fp, "Warning: incomplete row with %d (of %d) fields", 3526 *pfields, RESLIST_FIELDS); 3527 *pfields = 0; 3528 prow->idx = idx; 3529 return; 3530 } 3531 fprintf(stderr, 3532 "received reslist index %u, have %d of %d fields for index %u, aborting.\n", 3533 idx, *pfields, RESLIST_FIELDS, prow->idx); 3534 exit(1); 3535 } 3536 3537 3538 /* 3539 * another_reslist_field - helper for reslist() 3540 * 3541 * If all fields for the row have been received, print it. 3542 */ 3543 static void 3544 another_reslist_field( 3545 int * pfields, 3546 reslist_row * prow, 3547 FILE * fp 3548 ) 3549 { 3550 char addrmaskstr[128]; 3551 int prefix; /* subnet mask as prefix bits count */ 3552 u_int idx; 3553 3554 (*pfields)++; 3555 /* we understand 4 tags */ 3556 if (RESLIST_FIELDS > *pfields) 3557 return; 3558 3559 prefix = sockaddr_masktoprefixlen(&prow->mask); 3560 if (prefix >= 0) 3561 snprintf(addrmaskstr, sizeof(addrmaskstr), "%s/%d", 3562 stoa(&prow->addr), prefix); 3563 else 3564 snprintf(addrmaskstr, sizeof(addrmaskstr), "%s %s", 3565 stoa(&prow->addr), stoa(&prow->mask)); 3566 3567 /* 3568 " hits addr/prefix or addr mask\n" 3569 " restrictions\n" 3570 "==============================================================================\n"); 3571 */ 3572 fprintf(fp, 3573 "%10lu %s\n" 3574 " %s\n", 3575 prow->hits, addrmaskstr, prow->flagstr); 3576 idx = prow->idx; 3577 ZERO(*prow); 3578 prow->idx = idx; 3579 } 3580 3581 3582 /* 3583 * reslist - ntpq -c reslist modeled on ntpdc -c reslist. 3584 */ 3585 static void 3586 reslist( 3587 struct parse * pcmd, 3588 FILE * fp 3589 ) 3590 { 3591 const char addr_fmtu[] = "addr.%u"; 3592 const char mask_fmtu[] = "mask.%u"; 3593 const char hits_fmt[] = "hits.%u"; 3594 const char flags_fmt[] = "flags.%u"; 3595 const char qdata[] = "addr_restrictions"; 3596 const int qdata_chars = COUNTOF(qdata) - 1; 3597 const char * datap; 3598 int qres; 3599 size_t dsize; 3600 u_short rstatus; 3601 char * tag; 3602 char * val; 3603 int fields; 3604 u_int ui; 3605 reslist_row row; 3606 int comprende; 3607 size_t len; 3608 3609 qres = doquery(CTL_OP_READ_ORDLIST_A, 0, TRUE, qdata_chars, 3610 qdata, &rstatus, &dsize, &datap); 3611 if (qres) /* message already displayed */ 3612 return; 3613 3614 fprintf(fp, 3615 " hits addr/prefix or addr mask\n" 3616 " restrictions\n" 3617 "==============================================================================\n"); 3618 /* '=' x 78 */ 3619 3620 ZERO(row); 3621 fields = 0; 3622 ui = 0; 3623 while (nextvar(&dsize, &datap, &tag, &val)) { 3624 INSIST(tag && val); 3625 if (debug > 1) 3626 fprintf(stderr, "nextvar gave: %s = %s\n", tag, val); 3627 comprende = FALSE; 3628 switch(tag[0]) { 3629 3630 case 'a': 3631 if (1 == sscanf(tag, addr_fmtu, &ui) && 3632 decodenetnum(val, &row.addr)) 3633 comprende = TRUE; 3634 break; 3635 3636 case 'f': 3637 if (1 == sscanf(tag, flags_fmt, &ui)) { 3638 if (NULL == val) { 3639 row.flagstr[0] = '\0'; 3640 comprende = TRUE; 3641 } else if ((len = strlen(val)) < sizeof(row.flagstr)) { 3642 memcpy(row.flagstr, val, len); 3643 row.flagstr[len] = '\0'; 3644 comprende = TRUE; 3645 } else { 3646 /* no flags, and still !comprende */ 3647 row.flagstr[0] = '\0'; 3648 } 3649 } 3650 break; 3651 3652 case 'h': 3653 if (1 == sscanf(tag, hits_fmt, &ui) && 3654 1 == sscanf(val, "%lu", &row.hits)) 3655 comprende = TRUE; 3656 break; 3657 3658 case 'm': 3659 if (1 == sscanf(tag, mask_fmtu, &ui) && 3660 decodenetnum(val, &row.mask)) 3661 comprende = TRUE; 3662 break; 3663 } 3664 3665 if (comprende) { 3666 /* error out if rows out of order */ 3667 validate_reslist_idx(fp, ui, &fields, &row); 3668 /* if the row is complete, print it */ 3669 another_reslist_field(&fields, &row, fp); 3670 } 3671 } 3672 if (fields != RESLIST_FIELDS) 3673 fprintf(fp, "Warning: incomplete row with %d (of %d) fields", 3674 fields, RESLIST_FIELDS); 3675 3676 fflush(fp); 3677 } 3678 3679 3680 /* 3681 * collect_display_vdc 3682 */ 3683 static void 3684 collect_display_vdc( 3685 associd_t as, 3686 vdc * table, 3687 int decodestatus, 3688 FILE * fp 3689 ) 3690 { 3691 static const char * const suf[2] = { "adr", "port" }; 3692 static const char * const leapbits[4] = { "00", "01", 3693 "10", "11" }; 3694 struct varlist vl[MAXLIST]; 3695 char tagbuf[32]; 3696 vdc *pvdc; 3697 u_short rstatus; 3698 size_t rsize; 3699 const char *rdata; 3700 int qres; 3701 char *tag; 3702 char *val; 3703 u_int n; 3704 size_t len; 3705 int match; 3706 u_long ul; 3707 int vtype; 3708 3709 ZERO(vl); 3710 for (pvdc = table; pvdc->tag != NULL; pvdc++) { 3711 ZERO(pvdc->v); 3712 if (NTP_ADD != pvdc->type) { 3713 doaddvlist(vl, pvdc->tag); 3714 } else { 3715 for (n = 0; n < COUNTOF(suf); n++) { 3716 snprintf(tagbuf, sizeof(tagbuf), "%s%s", 3717 pvdc->tag, suf[n]); 3718 doaddvlist(vl, tagbuf); 3719 } 3720 } 3721 } 3722 qres = doquerylist(vl, CTL_OP_READVAR, as, 0, &rstatus, &rsize, 3723 &rdata); 3724 doclearvlist(vl); 3725 if (qres) 3726 return; /* error msg already displayed */ 3727 3728 /* 3729 * iterate over the response variables filling vdc_table with 3730 * the retrieved values. 3731 */ 3732 while (nextvar(&rsize, &rdata, &tag, &val)) { 3733 INSIST(tag && val); 3734 n = 0; 3735 for (pvdc = table; pvdc->tag != NULL; pvdc++) { 3736 len = strlen(pvdc->tag); 3737 if (strncmp(tag, pvdc->tag, len)) 3738 continue; 3739 if (NTP_ADD != pvdc->type) { 3740 if ('\0' != tag[len]) 3741 continue; 3742 break; 3743 } 3744 match = FALSE; 3745 for (n = 0; n < COUNTOF(suf); n++) { 3746 if (strcmp(tag + len, suf[n])) 3747 continue; 3748 match = TRUE; 3749 break; 3750 } 3751 if (match) 3752 break; 3753 } 3754 if (NULL == pvdc->tag) 3755 continue; 3756 switch (pvdc->type) { 3757 3758 case NTP_STR: 3759 /* strip surrounding double quotes */ 3760 if ('"' == val[0]) { 3761 len = strlen(val); 3762 if (len > 0 && '"' == val[len - 1]) { 3763 val[len - 1] = '\0'; 3764 val++; 3765 } 3766 } 3767 /* fallthru */ 3768 case NTP_MODE: /* fallthru */ 3769 case NTP_2BIT: 3770 pvdc->v.str = estrdup(val); 3771 break; 3772 3773 case NTP_LFP: 3774 decodets(val, &pvdc->v.lfp); 3775 break; 3776 3777 case NTP_ADP: 3778 if (!decodenetnum(val, &pvdc->v.sau)) 3779 fprintf(stderr, "malformed %s=%s\n", 3780 pvdc->tag, val); 3781 break; 3782 3783 case NTP_ADD: 3784 if (0 == n) { /* adr */ 3785 if (!decodenetnum(val, &pvdc->v.sau)) 3786 fprintf(stderr, 3787 "malformed %s=%s\n", 3788 pvdc->tag, val); 3789 } else { /* port */ 3790 if (atouint(val, &ul)) 3791 SET_PORT(&pvdc->v.sau, 3792 (u_short)ul); 3793 } 3794 break; 3795 } 3796 } 3797 3798 /* and display */ 3799 if (decodestatus) { 3800 vtype = (0 == as) 3801 ? TYPE_SYS 3802 : TYPE_PEER; 3803 fprintf(fp, "associd=%u status=%04x %s,\n", as, rstatus, 3804 statustoa(vtype, rstatus)); 3805 } 3806 3807 for (pvdc = table; pvdc->tag != NULL; pvdc++) { 3808 switch (pvdc->type) { 3809 3810 case NTP_STR: 3811 if (pvdc->v.str != NULL) { 3812 fprintf(fp, "%s %s\n", pvdc->display, 3813 pvdc->v.str); 3814 free(pvdc->v.str); 3815 pvdc->v.str = NULL; 3816 } 3817 break; 3818 3819 case NTP_ADD: /* fallthru */ 3820 case NTP_ADP: 3821 fprintf(fp, "%s %s\n", pvdc->display, 3822 nntohostp(&pvdc->v.sau)); 3823 break; 3824 3825 case NTP_LFP: 3826 fprintf(fp, "%s %s\n", pvdc->display, 3827 prettydate(&pvdc->v.lfp)); 3828 break; 3829 3830 case NTP_MODE: 3831 atouint(pvdc->v.str, &ul); 3832 fprintf(fp, "%s %s\n", pvdc->display, 3833 modetoa((int)ul)); 3834 break; 3835 3836 case NTP_2BIT: 3837 atouint(pvdc->v.str, &ul); 3838 fprintf(fp, "%s %s\n", pvdc->display, 3839 leapbits[ul & 0x3]); 3840 break; 3841 3842 default: 3843 fprintf(stderr, "unexpected vdc type %d for %s\n", 3844 pvdc->type, pvdc->tag); 3845 break; 3846 } 3847 } 3848 } 3849 3850 3851 /* 3852 * sysstats - implements ntpq -c sysstats modeled on ntpdc -c sysstats 3853 */ 3854 static void 3855 sysstats( 3856 struct parse *pcmd, 3857 FILE *fp 3858 ) 3859 { 3860 static vdc sysstats_vdc[] = { 3861 VDC_INIT("ss_uptime", "uptime: ", NTP_STR), 3862 VDC_INIT("ss_reset", "sysstats reset: ", NTP_STR), 3863 VDC_INIT("ss_received", "packets received: ", NTP_STR), 3864 VDC_INIT("ss_thisver", "current version: ", NTP_STR), 3865 VDC_INIT("ss_oldver", "older version: ", NTP_STR), 3866 VDC_INIT("ss_badformat", "bad length or format: ", NTP_STR), 3867 VDC_INIT("ss_badauth", "authentication failed:", NTP_STR), 3868 VDC_INIT("ss_declined", "declined: ", NTP_STR), 3869 VDC_INIT("ss_restricted", "restricted: ", NTP_STR), 3870 VDC_INIT("ss_limited", "rate limited: ", NTP_STR), 3871 VDC_INIT("ss_kodsent", "KoD responses: ", NTP_STR), 3872 VDC_INIT("ss_processed", "processed for time: ", NTP_STR), 3873 #if 0 3874 VDC_INIT("ss_lamport", "Lamport violations: ", NTP_STR), 3875 VDC_INIT("ss_tsrounding", "bad timestamp rounding:", NTP_STR), 3876 #endif 3877 VDC_INIT(NULL, NULL, 0) 3878 }; 3879 3880 collect_display_vdc(0, sysstats_vdc, FALSE, fp); 3881 } 3882 3883 3884 /* 3885 * sysinfo - modeled on ntpdc's sysinfo 3886 */ 3887 static void 3888 sysinfo( 3889 struct parse *pcmd, 3890 FILE *fp 3891 ) 3892 { 3893 static vdc sysinfo_vdc[] = { 3894 VDC_INIT("peeradr", "system peer: ", NTP_ADP), 3895 VDC_INIT("peermode", "system peer mode: ", NTP_MODE), 3896 VDC_INIT("leap", "leap indicator: ", NTP_2BIT), 3897 VDC_INIT("stratum", "stratum: ", NTP_STR), 3898 VDC_INIT("precision", "log2 precision: ", NTP_STR), 3899 VDC_INIT("rootdelay", "root delay: ", NTP_STR), 3900 VDC_INIT("rootdisp", "root dispersion: ", NTP_STR), 3901 VDC_INIT("refid", "reference ID: ", NTP_STR), 3902 VDC_INIT("reftime", "reference time: ", NTP_LFP), 3903 VDC_INIT("sys_jitter", "system jitter: ", NTP_STR), 3904 VDC_INIT("clk_jitter", "clock jitter: ", NTP_STR), 3905 VDC_INIT("clk_wander", "clock wander: ", NTP_STR), 3906 VDC_INIT("bcastdelay", "broadcast delay: ", NTP_STR), 3907 VDC_INIT("authdelay", "symm. auth. delay:", NTP_STR), 3908 VDC_INIT(NULL, NULL, 0) 3909 }; 3910 3911 collect_display_vdc(0, sysinfo_vdc, TRUE, fp); 3912 } 3913 3914 3915 /* 3916 * kerninfo - modeled on ntpdc's kerninfo 3917 */ 3918 static void 3919 kerninfo( 3920 struct parse *pcmd, 3921 FILE *fp 3922 ) 3923 { 3924 static vdc kerninfo_vdc[] = { 3925 VDC_INIT("koffset", "pll offset: ", NTP_STR), 3926 VDC_INIT("kfreq", "pll frequency: ", NTP_STR), 3927 VDC_INIT("kmaxerr", "maximum error: ", NTP_STR), 3928 VDC_INIT("kesterr", "estimated error: ", NTP_STR), 3929 VDC_INIT("kstflags", "kernel status: ", NTP_STR), 3930 VDC_INIT("ktimeconst", "pll time constant: ", NTP_STR), 3931 VDC_INIT("kprecis", "precision: ", NTP_STR), 3932 VDC_INIT("kfreqtol", "frequency tolerance: ", NTP_STR), 3933 VDC_INIT("kppsfreq", "pps frequency: ", NTP_STR), 3934 VDC_INIT("kppsstab", "pps stability: ", NTP_STR), 3935 VDC_INIT("kppsjitter", "pps jitter: ", NTP_STR), 3936 VDC_INIT("kppscalibdur", "calibration interval ", NTP_STR), 3937 VDC_INIT("kppscalibs", "calibration cycles: ", NTP_STR), 3938 VDC_INIT("kppsjitexc", "jitter exceeded: ", NTP_STR), 3939 VDC_INIT("kppsstbexc", "stability exceeded: ", NTP_STR), 3940 VDC_INIT("kppscaliberrs", "calibration errors: ", NTP_STR), 3941 VDC_INIT(NULL, NULL, 0) 3942 }; 3943 3944 collect_display_vdc(0, kerninfo_vdc, TRUE, fp); 3945 } 3946 3947 3948 /* 3949 * monstats - implements ntpq -c monstats 3950 */ 3951 static void 3952 monstats( 3953 struct parse *pcmd, 3954 FILE *fp 3955 ) 3956 { 3957 static vdc monstats_vdc[] = { 3958 VDC_INIT("mru_enabled", "enabled: ", NTP_STR), 3959 VDC_INIT("mru_depth", "addresses: ", NTP_STR), 3960 VDC_INIT("mru_deepest", "peak addresses: ", NTP_STR), 3961 VDC_INIT("mru_maxdepth", "maximum addresses: ", NTP_STR), 3962 VDC_INIT("mru_mindepth", "reclaim above count:", NTP_STR), 3963 VDC_INIT("mru_maxage", "reclaim older than: ", NTP_STR), 3964 VDC_INIT("mru_mem", "kilobytes: ", NTP_STR), 3965 VDC_INIT("mru_maxmem", "maximum kilobytes: ", NTP_STR), 3966 VDC_INIT(NULL, NULL, 0) 3967 }; 3968 3969 collect_display_vdc(0, monstats_vdc, FALSE, fp); 3970 } 3971 3972 3973 /* 3974 * iostats - ntpq -c iostats - network input and output counters 3975 */ 3976 static void 3977 iostats( 3978 struct parse *pcmd, 3979 FILE *fp 3980 ) 3981 { 3982 static vdc iostats_vdc[] = { 3983 VDC_INIT("iostats_reset", "time since reset: ", NTP_STR), 3984 VDC_INIT("total_rbuf", "receive buffers: ", NTP_STR), 3985 VDC_INIT("free_rbuf", "free receive buffers: ", NTP_STR), 3986 VDC_INIT("used_rbuf", "used receive buffers: ", NTP_STR), 3987 VDC_INIT("rbuf_lowater", "low water refills: ", NTP_STR), 3988 VDC_INIT("io_dropped", "dropped packets: ", NTP_STR), 3989 VDC_INIT("io_ignored", "ignored packets: ", NTP_STR), 3990 VDC_INIT("io_received", "received packets: ", NTP_STR), 3991 VDC_INIT("io_sent", "packets sent: ", NTP_STR), 3992 VDC_INIT("io_sendfailed", "packet send failures: ", NTP_STR), 3993 VDC_INIT("io_wakeups", "input wakeups: ", NTP_STR), 3994 VDC_INIT("io_goodwakeups", "useful input wakeups: ", NTP_STR), 3995 VDC_INIT(NULL, NULL, 0) 3996 }; 3997 3998 collect_display_vdc(0, iostats_vdc, FALSE, fp); 3999 } 4000 4001 4002 /* 4003 * timerstats - ntpq -c timerstats - interval timer counters 4004 */ 4005 static void 4006 timerstats( 4007 struct parse *pcmd, 4008 FILE *fp 4009 ) 4010 { 4011 static vdc timerstats_vdc[] = { 4012 VDC_INIT("timerstats_reset", "time since reset: ", NTP_STR), 4013 VDC_INIT("timer_overruns", "timer overruns: ", NTP_STR), 4014 VDC_INIT("timer_xmts", "calls to transmit: ", NTP_STR), 4015 VDC_INIT(NULL, NULL, 0) 4016 }; 4017 4018 collect_display_vdc(0, timerstats_vdc, FALSE, fp); 4019 } 4020 4021 4022 /* 4023 * authinfo - implements ntpq -c authinfo 4024 */ 4025 static void 4026 authinfo( 4027 struct parse *pcmd, 4028 FILE *fp 4029 ) 4030 { 4031 static vdc authinfo_vdc[] = { 4032 VDC_INIT("authreset", "time since reset:", NTP_STR), 4033 VDC_INIT("authkeys", "stored keys: ", NTP_STR), 4034 VDC_INIT("authfreek", "free keys: ", NTP_STR), 4035 VDC_INIT("authklookups", "key lookups: ", NTP_STR), 4036 VDC_INIT("authknotfound", "keys not found: ", NTP_STR), 4037 VDC_INIT("authkuncached", "uncached keys: ", NTP_STR), 4038 VDC_INIT("authkexpired", "expired keys: ", NTP_STR), 4039 VDC_INIT("authencrypts", "encryptions: ", NTP_STR), 4040 VDC_INIT("authdecrypts", "decryptions: ", NTP_STR), 4041 VDC_INIT(NULL, NULL, 0) 4042 }; 4043 4044 collect_display_vdc(0, authinfo_vdc, FALSE, fp); 4045 } 4046 4047 4048 /* 4049 * pstats - show statistics for a peer 4050 */ 4051 static void 4052 pstats( 4053 struct parse *pcmd, 4054 FILE *fp 4055 ) 4056 { 4057 static vdc pstats_vdc[] = { 4058 VDC_INIT("src", "remote host: ", NTP_ADD), 4059 VDC_INIT("dst", "local address: ", NTP_ADD), 4060 VDC_INIT("timerec", "time last received: ", NTP_STR), 4061 VDC_INIT("timer", "time until next send:", NTP_STR), 4062 VDC_INIT("timereach", "reachability change: ", NTP_STR), 4063 VDC_INIT("sent", "packets sent: ", NTP_STR), 4064 VDC_INIT("received", "packets received: ", NTP_STR), 4065 VDC_INIT("badauth", "bad authentication: ", NTP_STR), 4066 VDC_INIT("bogusorg", "bogus origin: ", NTP_STR), 4067 VDC_INIT("oldpkt", "duplicate: ", NTP_STR), 4068 VDC_INIT("seldisp", "bad dispersion: ", NTP_STR), 4069 VDC_INIT("selbroken", "bad reference time: ", NTP_STR), 4070 VDC_INIT("candidate", "candidate order: ", NTP_STR), 4071 VDC_INIT(NULL, NULL, 0) 4072 }; 4073 associd_t associd; 4074 4075 associd = checkassocid(pcmd->argval[0].uval); 4076 if (0 == associd) 4077 return; 4078 4079 collect_display_vdc(associd, pstats_vdc, TRUE, fp); 4080 } 4081
Indexes created Sun Mar 01 05:31:48 UTC 2026