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