1/* 2 * ntpdc_ops.c - subroutines which are called to perform operations by 3 * ntpdc 4 */ 5 6#ifdef HAVE_CONFIG_H 7# include <config.h> 8#endif 9 10#include <stdio.h> 11#include <stddef.h> 12 13#include "ntpdc.h" 14#include "ntp_net.h" 15#include "ntp_control.h" 16#include "ntp_refclock.h" 17#include "ntp_stdlib.h" 18 19#include <ctype.h> 20#ifdef HAVE_SYS_TIMEX_H 21# include <sys/timex.h> 22#endif 23#if !defined(__bsdi__) && !defined(apollo) 24#ifdef HAVE_NETINET_IN_H 25#include <netinet/in.h> 26#endif 27#endif 28 29#include <arpa/inet.h> 30 31/* 32 * utility functions 33 */ 34static int checkitems (int, FILE *); 35static int checkitemsize (int, int); 36static int check1item (int, FILE *); 37 38/* 39 * Declarations for command handlers in here 40 */ 41static void peerlist (struct parse *, FILE *); 42static void peers (struct parse *, FILE *); 43static void doconfig (struct parse *pcmd, FILE *fp, int mode, int refc); 44static void dmpeers (struct parse *, FILE *); 45static void dopeers (struct parse *, FILE *, int); 46static void printpeer (struct info_peer *, FILE *); 47static void showpeer (struct parse *, FILE *); 48static void peerstats (struct parse *, FILE *); 49static void loopinfo (struct parse *, FILE *); 50static void sysinfo (struct parse *, FILE *); 51static void sysstats (struct parse *, FILE *); 52static void iostats (struct parse *, FILE *); 53static void memstats (struct parse *, FILE *); 54static void timerstats (struct parse *, FILE *); 55static void addpeer (struct parse *, FILE *); 56static void addserver (struct parse *, FILE *); 57static void addrefclock (struct parse *, FILE *); 58static void broadcast (struct parse *, FILE *); 59static void doconfig (struct parse *, FILE *, int, int); 60static void unconfig (struct parse *, FILE *); 61static void set (struct parse *, FILE *); 62static void sys_clear (struct parse *, FILE *); 63static void doset (struct parse *, FILE *, int); 64static void reslist (struct parse *, FILE *); 65static void new_restrict (struct parse *, FILE *); 66static void unrestrict (struct parse *, FILE *); 67static void delrestrict (struct parse *, FILE *); 68static void do_restrict (struct parse *, FILE *, int); 69static void monlist (struct parse *, FILE *); 70static void reset (struct parse *, FILE *); 71static void preset (struct parse *, FILE *); 72static void readkeys (struct parse *, FILE *); 73static void trustkey (struct parse *, FILE *); 74static void untrustkey (struct parse *, FILE *); 75static void do_trustkey (struct parse *, FILE *, int); 76static void authinfo (struct parse *, FILE *); 77static void traps (struct parse *, FILE *); 78static void addtrap (struct parse *, FILE *); 79static void clrtrap (struct parse *, FILE *); 80static void do_addclr_trap (struct parse *, FILE *, int); 81static void requestkey (struct parse *, FILE *); 82static void controlkey (struct parse *, FILE *); 83static void do_changekey (struct parse *, FILE *, int); 84static void ctlstats (struct parse *, FILE *); 85static void clockstat (struct parse *, FILE *); 86static void fudge (struct parse *, FILE *); 87static void clkbug (struct parse *, FILE *); 88static void kerninfo (struct parse *, FILE *); 89static void get_if_stats (struct parse *, FILE *); 90static void do_if_reload (struct parse *, FILE *); 91 92/* 93 * Commands we understand. Ntpdc imports this. 94 */ 95struct xcmd opcmds[] = { 96 { "listpeers", peerlist, { OPT|IP_VERSION, NO, NO, NO }, 97 { "-4|-6", "", "", "" }, 98 "display list of peers the server knows about [IP Version]" }, 99 { "peers", peers, { OPT|IP_VERSION, NO, NO, NO }, 100 { "-4|-6", "", "", "" }, 101 "display peer summary information [IP Version]" }, 102 { "dmpeers", dmpeers, { OPT|IP_VERSION, NO, NO, NO }, 103 { "-4|-6", "", "", "" }, 104 "display peer summary info the way Dave Mills likes it (IP Version)" }, 105 { "showpeer", showpeer, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD}, 106 { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" }, 107 "display detailed information for one or more peers" }, 108 { "pstats", peerstats, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD }, 109 { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" }, 110 "display statistical information for one or more peers" }, 111 { "loopinfo", loopinfo, { OPT|NTP_STR, NO, NO, NO }, 112 { "oneline|multiline", "", "", "" }, 113 "display loop filter information" }, 114 { "sysinfo", sysinfo, { NO, NO, NO, NO }, 115 { "", "", "", "" }, 116 "display local server information" }, 117 { "sysstats", sysstats, { NO, NO, NO, NO }, 118 { "", "", "", "" }, 119 "display local server statistics" }, 120 { "memstats", memstats, { NO, NO, NO, NO }, 121 { "", "", "", "" }, 122 "display peer memory usage statistics" }, 123 { "iostats", iostats, { NO, NO, NO, NO }, 124 { "", "", "", "" }, 125 "display I/O subsystem statistics" }, 126 { "timerstats", timerstats, { NO, NO, NO, NO }, 127 { "", "", "", "" }, 128 "display event timer subsystem statistics" }, 129 { "addpeer", addpeer, { NTP_ADD, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR }, 130 { "addr", "keyid", "version", "minpoll#|prefer|burst|iburst|'minpoll N'|'maxpoll N'|'keyid N'|'version N' ..." }, 131 "configure a new peer association" }, 132 { "addserver", addserver, { NTP_ADD, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR }, 133 { "addr", "keyid", "version", "minpoll#|prefer|burst|iburst|'minpoll N'|'maxpoll N'|'keyid N'|'version N' ..." }, 134 "configure a new server" }, 135 { "addrefclock",addrefclock, { NTP_ADD, OPT|NTP_UINT, OPT|NTP_STR, OPT|NTP_STR }, 136 { "addr", "mode", "minpoll|prefer", "minpoll|prefer" }, 137 "configure a new server" }, 138 { "broadcast", broadcast, { NTP_ADD, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR }, 139 { "addr", "keyid", "version", "minpoll" }, 140 "configure broadcasting time service" }, 141 { "unconfig", unconfig, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD }, 142 { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" }, 143 "unconfigure existing peer assocations" }, 144 { "enable", set, { NTP_STR, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR }, 145 { "auth|bclient|monitor|pll|kernel|stats", "...", "...", "..." }, 146 "set a system flag (auth, bclient, monitor, pll, kernel, stats)" }, 147 { "disable", sys_clear, { NTP_STR, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR }, 148 { "auth|bclient|monitor|pll|kernel|stats", "...", "...", "..." }, 149 "clear a system flag (auth, bclient, monitor, pll, kernel, stats)" }, 150 { "reslist", reslist, {OPT|IP_VERSION, NO, NO, NO }, 151 { "-4|-6", "", "", "" }, 152 "display the server's restrict list" }, 153 { "restrict", new_restrict, { NTP_ADD, NTP_ADD, NTP_STR, OPT|NTP_STR }, 154 { "address", "mask", 155 "ntpport|ignore|noserve|notrust|noquery|nomodify|nopeer|version|kod", 156 "..." }, 157 "create restrict entry/add flags to entry" }, 158 { "unrestrict", unrestrict, { NTP_ADD, NTP_ADD, NTP_STR, OPT|NTP_STR }, 159 { "address", "mask", 160 "ntpport|ignore|noserve|notrust|noquery|nomodify|nopeer|version|kod", 161 "..." }, 162 "remove flags from a restrict entry" }, 163 { "delrestrict", delrestrict, { NTP_ADD, NTP_ADD, OPT|NTP_STR, NO }, 164 { "address", "mask", "ntpport", "" }, 165 "delete a restrict entry" }, 166 { "monlist", monlist, { OPT|NTP_INT, NO, NO, NO }, 167 { "version", "", "", "" }, 168 "display data the server's monitor routines have collected" }, 169 { "reset", reset, { NTP_STR, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR }, 170 { "io|sys|mem|timer|auth|allpeers", "...", "...", "..." }, 171 "reset various subsystem statistics counters" }, 172 { "preset", preset, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD }, 173 { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" }, 174 "reset stat counters associated with particular peer(s)" }, 175 { "readkeys", readkeys, { NO, NO, NO, NO }, 176 { "", "", "", "" }, 177 "request a reread of the keys file and re-init of system keys" }, 178 { "trustedkey", trustkey, { NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT }, 179 { "keyid", "keyid", "keyid", "keyid" }, 180 "add one or more key ID's to the trusted list" }, 181 { "untrustedkey", untrustkey, { NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT }, 182 { "keyid", "keyid", "keyid", "keyid" }, 183 "remove one or more key ID's from the trusted list" }, 184 { "authinfo", authinfo, { NO, NO, NO, NO }, 185 { "", "", "", "" }, 186 "display the state of the authentication code" }, 187 { "traps", traps, { NO, NO, NO, NO }, 188 { "", "", "", "" }, 189 "display the traps set in the server" }, 190 { "addtrap", addtrap, { NTP_ADD, OPT|NTP_UINT, OPT|NTP_ADD, NO }, 191 { "address", "port", "interface", "" }, 192 "configure a trap in the server" }, 193 { "clrtrap", clrtrap, { NTP_ADD, OPT|NTP_UINT, OPT|NTP_ADD, NO }, 194 { "address", "port", "interface", "" }, 195 "remove a trap (configured or otherwise) from the server" }, 196 { "requestkey", requestkey, { NTP_UINT, NO, NO, NO }, 197 { "keyid", "", "", "" }, 198 "change the keyid the server uses to authenticate requests" }, 199 { "controlkey", controlkey, { NTP_UINT, NO, NO, NO }, 200 { "keyid", "", "", "" }, 201 "change the keyid the server uses to authenticate control messages" }, 202 { "ctlstats", ctlstats, { NO, NO, NO, NO }, 203 { "", "", "", "" }, 204 "display packet count statistics from the control module" }, 205 { "clockstat", clockstat, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD }, 206 { "address", "address", "address", "address" }, 207 "display clock status information" }, 208 { "fudge", fudge, { NTP_ADD, NTP_STR, NTP_STR, NO }, 209 { "address", "time1|time2|val1|val2|flags", "value", "" }, 210 "set/change one of a clock's fudge factors" }, 211 { "clkbug", clkbug, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD }, 212 { "address", "address", "address", "address" }, 213 "display clock debugging information" }, 214 { "kerninfo", kerninfo, { NO, NO, NO, NO }, 215 { "", "", "", "" }, 216 "display the kernel pll/pps variables" }, 217 { "ifstats", get_if_stats, { NO, NO, NO, NO }, 218 { "", "", "", "" }, 219 "list interface statistics" }, 220 { "ifreload", do_if_reload, { NO, NO, NO, NO }, 221 { "", "", "", "" }, 222 "reload interface configuration" }, 223 { 0, 0, { NO, NO, NO, NO }, 224 { "", "", "", "" }, "" } 225}; 226 227/* 228 * For quick string comparisons 229 */ 230#define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0) 231 232/* 233 * SET_SS_LEN_IF_PRESENT - used by SET_ADDR, SET_ADDRS macros 234 */ 235 236#ifdef ISC_PLATFORM_HAVESALEN 237#define SET_SS_LEN_IF_PRESENT(psau) \ 238 do { \ 239 (psau)->sas.ss_len = SOCKLEN(psau); \ 240 } while (0) 241#else 242#define SET_SS_LEN_IF_PRESENT(psau) do { } while (0) 243#endif 244 245/* 246 * SET_ADDR - setup address for v4/v6 as needed 247 */ 248#define SET_ADDR(address, v6flag, v4addr, v6addr) \ 249do { \ 250 memset(&(address), 0, sizeof(address)); \ 251 if (v6flag) { \ 252 AF(&(address)) = AF_INET6; \ 253 SOCK_ADDR6(&(address)) = (v6addr); \ 254 } else { \ 255 AF(&(address)) = AF_INET; \ 256 NSRCADR(&(address)) = (v4addr); \ 257 } \ 258 SET_SS_LEN_IF_PRESENT(&(address)); \ 259} while (0) 260 261 262/* 263 * SET_ADDRS - setup source and destination addresses for 264 * v4/v6 as needed 265 */ 266#define SET_ADDRS(a1, a2, info, a1prefix, a2prefix) \ 267do { \ 268 memset(&(a1), 0, sizeof(a1)); \ 269 memset(&(a2), 0, sizeof(a2)); \ 270 if ((info)->v6_flag) { \ 271 AF(&(a1)) = AF_INET6; \ 272 AF(&(a2)) = AF_INET6; \ 273 SOCK_ADDR6(&(a1)) = (info)->a1prefix##6; \ 274 SOCK_ADDR6(&(a2)) = (info)->a2prefix##6; \ 275 } else { \ 276 AF(&(a1)) = AF_INET; \ 277 AF(&(a2)) = AF_INET; \ 278 NSRCADR(&(a1)) = (info)->a1prefix; \ 279 NSRCADR(&(a2)) = (info)->a2prefix; \ 280 } \ 281 SET_SS_LEN_IF_PRESENT(&(a1)); \ 282 SET_SS_LEN_IF_PRESENT(&(a2)); \ 283} while (0) 284 285 286/* 287 * SET_ADDRS - setup source and destination addresses for 288 * v4/v6 as needed 289 */ 290#if 0 291#define SET_ADDR_MASK(address, addrmask, info) \ 292do { \ 293 memset(&(address), 0, sizeof(address)); \ 294 memset(&(mask), 0, sizeof(mask)); \ 295 if ((info)->v6_flag) { \ 296 AF(&(address)) = AF_INET6; \ 297 AF(&(addrmask)) = AF_INET6; \ 298 SOCK_ADDR6(&(address)) = (info)->addr6; \ 299 SOCK_ADDR6(&(addrmask)) = (info)->mask6; \ 300 } else { \ 301 AF(&(address)) = AF_INET; \ 302 AF(&(addrmask)) = AF_INET; \ 303 NSRCADR(&(address)) = (info)->addr; \ 304 NSRCADR(&(addrmask)) = (info)->mask; \ 305 } \ 306 SET_SS_LEN_IF_PRESENT(&(address)); \ 307 SET_SS_LEN_IF_PRESENT(&(addrmask)); \ 308} while (0) 309#endif 310 311/* 312 * checkitems - utility to print a message if no items were returned 313 */ 314static int 315checkitems( 316 int items, 317 FILE *fp 318 ) 319{ 320 if (items == 0) { 321 (void) fprintf(fp, "No data returned in response to query\n"); 322 return 0; 323 } 324 return 1; 325} 326 327 328/* 329 * checkitemsize - utility to print a message if the item size is wrong 330 */ 331static int 332checkitemsize( 333 int itemsize, 334 int expected 335 ) 336{ 337 if (itemsize != expected) { 338 (void) fprintf(stderr, 339 "***Incorrect item size returned by remote host (%d should be %d)\n", 340 itemsize, expected); 341 return 0; 342 } 343 return 1; 344} 345 346 347/* 348 * check1item - check to make sure we have exactly one item 349 */ 350static int 351check1item( 352 int items, 353 FILE *fp 354 ) 355{ 356 if (items == 0) { 357 (void) fprintf(fp, "No data returned in response to query\n"); 358 return 0; 359 } 360 if (items > 1) { 361 (void) fprintf(fp, "Expected one item in response, got %d\n", 362 items); 363 return 0; 364 } 365 return 1; 366} 367 368 369/* 370 * peerlist - get a short list of peers 371 */ 372/*ARGSUSED*/ 373static void 374peerlist( 375 struct parse *pcmd, 376 FILE *fp 377 ) 378{ 379 struct info_peer_list *plist; 380 sockaddr_u paddr; 381 int items; 382 int itemsize; 383 int res; 384 385again: 386 res = doquery(impl_ver, REQ_PEER_LIST, 0, 0, 0, (char *)NULL, &items, 387 &itemsize, (void *)&plist, 0, 388 sizeof(struct info_peer_list)); 389 390 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 391 impl_ver = IMPL_XNTPD_OLD; 392 goto again; 393 } 394 395 if (res != 0) 396 return; 397 398 if (!checkitems(items, fp)) 399 return; 400 401 if (!checkitemsize(itemsize, sizeof(struct info_peer_list)) && 402 !checkitemsize(itemsize, v4sizeof(struct info_peer_list))) 403 return; 404 405 while (items > 0) { 406 SET_ADDR(paddr, plist->v6_flag, plist->addr, plist->addr6); 407 if ((pcmd->nargs == 0) || 408 ((pcmd->argval->ival == 6) && (plist->v6_flag != 0)) || 409 ((pcmd->argval->ival == 4) && (plist->v6_flag == 0))) 410 (void) fprintf(fp, "%-9s %s\n", 411 modetoa(plist->hmode), 412 nntohost(&paddr)); 413 plist++; 414 items--; 415 } 416} 417 418 419/* 420 * peers - show peer summary 421 */ 422static void 423peers( 424 struct parse *pcmd, 425 FILE *fp 426 ) 427{ 428 dopeers(pcmd, fp, 0); 429} 430 431/* 432 * dmpeers - show peer summary, Dave Mills style 433 */ 434static void 435dmpeers( 436 struct parse *pcmd, 437 FILE *fp 438 ) 439{ 440 dopeers(pcmd, fp, 1); 441} 442 443 444/* 445 * peers - show peer summary 446 */ 447/*ARGSUSED*/ 448static void 449dopeers( 450 struct parse *pcmd, 451 FILE *fp, 452 int dmstyle 453 ) 454{ 455 struct info_peer_summary *plist; 456 sockaddr_u dstadr; 457 sockaddr_u srcadr; 458 int items; 459 int itemsize; 460 int ntp_poll; 461 int res; 462 int c; 463 l_fp tempts; 464 465again: 466 res = doquery(impl_ver, REQ_PEER_LIST_SUM, 0, 0, 0, (char *)NULL, 467 &items, &itemsize, (void *)&plist, 0, 468 sizeof(struct info_peer_summary)); 469 470 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 471 impl_ver = IMPL_XNTPD_OLD; 472 goto again; 473 } 474 475 if (res != 0) 476 return; 477 478 if (!checkitems(items, fp)) 479 return; 480 481 if (!checkitemsize(itemsize, sizeof(struct info_peer_summary)) && 482 !checkitemsize(itemsize, v4sizeof(struct info_peer_summary))) 483 return; 484 485 (void) fprintf(fp, 486 " remote local st poll reach delay offset disp\n"); 487 (void) fprintf(fp, 488 "=======================================================================\n"); 489 while (items > 0) { 490 if (!dmstyle) { 491 if (plist->flags & INFO_FLAG_SYSPEER) 492 c = '*'; 493 else if (plist->hmode == MODE_ACTIVE) 494 c = '+'; 495 else if (plist->hmode == MODE_PASSIVE) 496 c = '-'; 497 else if (plist->hmode == MODE_CLIENT) 498 c = '='; 499 else if (plist->hmode == MODE_BROADCAST) 500 c = '^'; 501 else if (plist->hmode == MODE_BCLIENT) 502 c = '~'; 503 else 504 c = ' '; 505 } else { 506 if (plist->flags & INFO_FLAG_SYSPEER) 507 c = '*'; 508 else if (plist->flags & INFO_FLAG_SHORTLIST) 509 c = '+'; 510 else if (plist->flags & INFO_FLAG_SEL_CANDIDATE) 511 c = '.'; 512 else 513 c = ' '; 514 } 515 NTOHL_FP(&(plist->offset), &tempts); 516 ntp_poll = 1<<max(min3(plist->ppoll, plist->hpoll, NTP_MAXPOLL), 517 NTP_MINPOLL); 518 SET_ADDRS(dstadr, srcadr, plist, dstadr, srcadr); 519 if ((pcmd->nargs == 0) || 520 ((pcmd->argval->ival == 6) && (plist->v6_flag != 0)) || 521 ((pcmd->argval->ival == 4) && (plist->v6_flag == 0))) 522 (void) fprintf(fp, 523 "%c%-15.15s %-15.15s %2d %4d %3o %7.7s %9.9s %7.7s\n", 524 c, nntohost(&srcadr), stoa(&dstadr), 525 plist->stratum, ntp_poll, plist->reach, 526 fptoa(NTOHS_FP(plist->delay), 5), 527 lfptoa(&tempts, 6), 528 ufptoa(NTOHS_FP(plist->dispersion), 5)); 529 plist++; 530 items--; 531 } 532} 533 534/* Convert a refid & stratum (in host order) to a string */ 535static char* 536refid_string( 537 u_int32 refid, 538 int stratum 539 ) 540{ 541 if (stratum <= 1) { 542 static char junk[5]; 543 junk[4] = 0; 544 memmove(junk, (char *)&refid, 4); 545 return junk; 546 } 547 548 return numtoa(refid); 549} 550 551static void 552print_pflag( 553 FILE *fp, 554 u_int32 flags 555 ) 556{ 557 const char *str; 558 559 if (flags == 0) { 560 (void) fprintf(fp, " none\n"); 561 } else { 562 str = ""; 563 if (flags & INFO_FLAG_SYSPEER) { 564 (void) fprintf(fp, " system_peer"); 565 str = ","; 566 } 567 if (flags & INFO_FLAG_CONFIG) { 568 (void) fprintf(fp, "%s config", str); 569 str = ","; 570 } 571 if (flags & INFO_FLAG_REFCLOCK) { 572 (void) fprintf(fp, "%s refclock", str); 573 str = ","; 574 } 575 if (flags & INFO_FLAG_AUTHENABLE) { 576 (void) fprintf(fp, "%s auth", str); 577 str = ","; 578 } 579 if (flags & INFO_FLAG_BCLIENT) { 580 (void) fprintf(fp, "%s bclient", str); 581 str = ","; 582 } 583 if (flags & INFO_FLAG_PREFER) { 584 (void) fprintf(fp, "%s prefer", str); 585 str = ","; 586 } 587 if (flags & INFO_FLAG_IBURST) { 588 (void) fprintf(fp, "%s iburst", str); 589 str = ","; 590 } 591 if (flags & INFO_FLAG_BURST) { 592 (void) fprintf(fp, "%s burst", str); 593 } 594 (void) fprintf(fp, "\n"); 595 } 596} 597/* 598 * printpeer - print detail information for a peer 599 */ 600static void 601printpeer( 602 register struct info_peer *pp, 603 FILE *fp 604 ) 605{ 606 register int i; 607 l_fp tempts; 608 sockaddr_u srcadr, dstadr; 609 610 SET_ADDRS(dstadr, srcadr, pp, dstadr, srcadr); 611 612 (void) fprintf(fp, "remote %s, local %s\n", 613 stoa(&srcadr), stoa(&dstadr)); 614 (void) fprintf(fp, "hmode %s, pmode %s, stratum %d, precision %d\n", 615 modetoa(pp->hmode), modetoa(pp->pmode), 616 pp->stratum, pp->precision); 617 618 (void) fprintf(fp, 619 "leap %c%c, refid [%s], rootdistance %s, rootdispersion %s\n", 620 pp->leap & 0x2 ? '1' : '0', 621 pp->leap & 0x1 ? '1' : '0', 622 refid_string(pp->refid, pp->stratum), fptoa(NTOHS_FP(pp->rootdelay), 5), 623 ufptoa(NTOHS_FP(pp->rootdispersion), 5)); 624 625 (void) fprintf(fp, 626 "ppoll %d, hpoll %d, keyid %lu, version %d, association %u\n", 627 pp->ppoll, pp->hpoll, (u_long)pp->keyid, pp->version, ntohs(pp->associd)); 628 629 (void) fprintf(fp, 630 "reach %03o, unreach %d, flash 0x%04x, ", 631 pp->reach, pp->unreach, pp->flash2); 632 633 (void) fprintf(fp, "boffset %s, ttl/mode %d\n", 634 fptoa(NTOHS_FP(pp->estbdelay), 5), pp->ttl); 635 636 (void) fprintf(fp, "timer %lds, flags", (long)ntohl(pp->timer)); 637 print_pflag(fp, pp->flags); 638 639 NTOHL_FP(&pp->reftime, &tempts); 640 (void) fprintf(fp, "reference time: %s\n", 641 prettydate(&tempts)); 642 NTOHL_FP(&pp->org, &tempts); 643 (void) fprintf(fp, "originate timestamp: %s\n", 644 prettydate(&tempts)); 645 NTOHL_FP(&pp->rec, &tempts); 646 (void) fprintf(fp, "receive timestamp: %s\n", 647 prettydate(&tempts)); 648 NTOHL_FP(&pp->xmt, &tempts); 649 (void) fprintf(fp, "transmit timestamp: %s\n", 650 prettydate(&tempts)); 651 652 (void) fprintf(fp, "filter delay: "); 653 for (i = 0; i < NTP_SHIFT; i++) { 654 (void) fprintf(fp, " %-8.8s", 655 fptoa(NTOHS_FP(pp->filtdelay[i]), 5)); 656 if (i == (NTP_SHIFT>>1)-1) 657 (void) fprintf(fp, "\n "); 658 } 659 (void) fprintf(fp, "\n"); 660 661 (void) fprintf(fp, "filter offset:"); 662 for (i = 0; i < NTP_SHIFT; i++) { 663 NTOHL_FP(&pp->filtoffset[i], &tempts); 664 (void) fprintf(fp, " %-8.8s", lfptoa(&tempts, 6)); 665 if (i == (NTP_SHIFT>>1)-1) 666 (void) fprintf(fp, "\n "); 667 } 668 (void) fprintf(fp, "\n"); 669 670 (void) fprintf(fp, "filter order: "); 671 for (i = 0; i < NTP_SHIFT; i++) { 672 (void) fprintf(fp, " %-8d", pp->order[i]); 673 if (i == (NTP_SHIFT>>1)-1) 674 (void) fprintf(fp, "\n "); 675 } 676 (void) fprintf(fp, "\n"); 677 678 679 NTOHL_FP(&pp->offset, &tempts); 680 (void) fprintf(fp, 681 "offset %s, delay %s, error bound %s, filter error %s\n", 682 lfptoa(&tempts, 6), fptoa(NTOHS_FP(pp->delay), 5), 683 ufptoa(NTOHS_FP(pp->dispersion), 5), 684 ufptoa(NTOHS_FP(pp->selectdisp), 5)); 685} 686 687 688/* 689 * showpeer - show detailed information for a peer 690 */ 691static void 692showpeer( 693 struct parse *pcmd, 694 FILE *fp 695 ) 696{ 697 struct info_peer *pp; 698 /* 4 is the maximum number of peers which will fit in a packet */ 699 struct info_peer_list *pl, plist[min(MAXARGS, 4)]; 700 int qitemlim; 701 int qitems; 702 int items; 703 int itemsize; 704 int res; 705 int sendsize; 706 707again: 708 if (impl_ver == IMPL_XNTPD) 709 sendsize = sizeof(struct info_peer_list); 710 else 711 sendsize = v4sizeof(struct info_peer_list); 712 713 qitemlim = min(pcmd->nargs, COUNTOF(plist)); 714 for (qitems = 0, pl = plist; qitems < qitemlim; qitems++) { 715 if (IS_IPV4(&pcmd->argval[qitems].netnum)) { 716 pl->addr = NSRCADR(&pcmd->argval[qitems].netnum); 717 if (impl_ver == IMPL_XNTPD) 718 pl->v6_flag = 0; 719 } else { 720 if (impl_ver == IMPL_XNTPD_OLD) { 721 fprintf(stderr, 722 "***Server doesn't understand IPv6 addresses\n"); 723 return; 724 } 725 pl->addr6 = SOCK_ADDR6(&pcmd->argval[qitems].netnum); 726 pl->v6_flag = 1; 727 } 728 pl->port = (u_short)s_port; 729 pl->hmode = pl->flags = 0; 730 pl = (struct info_peer_list *)((char *)pl + sendsize); 731 } 732 733 res = doquery(impl_ver, REQ_PEER_INFO, 0, qitems, 734 sendsize, (char *)plist, &items, 735 &itemsize, (void *)&pp, 0, sizeof(struct info_peer)); 736 737 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 738 impl_ver = IMPL_XNTPD_OLD; 739 goto again; 740 } 741 742 if (res != 0) 743 return; 744 745 if (!checkitems(items, fp)) 746 return; 747 748 if (!checkitemsize(itemsize, sizeof(struct info_peer)) && 749 !checkitemsize(itemsize, v4sizeof(struct info_peer))) 750 return; 751 752 while (items-- > 0) { 753 printpeer(pp, fp); 754 if (items > 0) 755 (void) fprintf(fp, "\n"); 756 pp++; 757 } 758} 759 760 761/* 762 * peerstats - return statistics for a peer 763 */ 764static void 765peerstats( 766 struct parse *pcmd, 767 FILE *fp 768 ) 769{ 770 struct info_peer_stats *pp; 771 /* 4 is the maximum number of peers which will fit in a packet */ 772 struct info_peer_list *pl, plist[min(MAXARGS, 4)]; 773 sockaddr_u src, dst; 774 int qitemlim; 775 int qitems; 776 int items; 777 int itemsize; 778 int res; 779 int sendsize; 780 781again: 782 if (impl_ver == IMPL_XNTPD) 783 sendsize = sizeof(struct info_peer_list); 784 else 785 sendsize = v4sizeof(struct info_peer_list); 786 787 memset(plist, 0, sizeof(plist)); 788 789 qitemlim = min(pcmd->nargs, COUNTOF(plist)); 790 for (qitems = 0, pl = plist; qitems < qitemlim; qitems++) { 791 if (IS_IPV4(&pcmd->argval[qitems].netnum)) { 792 pl->addr = NSRCADR(&pcmd->argval[qitems].netnum); 793 if (impl_ver == IMPL_XNTPD) 794 pl->v6_flag = 0; 795 } else { 796 if (impl_ver == IMPL_XNTPD_OLD) { 797 fprintf(stderr, 798 "***Server doesn't understand IPv6 addresses\n"); 799 return; 800 } 801 pl->addr6 = SOCK_ADDR6(&pcmd->argval[qitems].netnum); 802 pl->v6_flag = 1; 803 } 804 pl->port = (u_short)s_port; 805 pl->hmode = plist[qitems].flags = 0; 806 pl = (struct info_peer_list *)((char *)pl + sendsize); 807 } 808 809 res = doquery(impl_ver, REQ_PEER_STATS, 0, qitems, 810 sendsize, (char *)plist, &items, 811 &itemsize, (void *)&pp, 0, 812 sizeof(struct info_peer_stats)); 813 814 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 815 impl_ver = IMPL_XNTPD_OLD; 816 goto again; 817 } 818 819 if (res != 0) 820 return; 821 822 if (!checkitems(items, fp)) 823 return; 824 825 if (!checkitemsize(itemsize, sizeof(struct info_peer_stats)) && 826 !checkitemsize(itemsize, v4sizeof(struct info_peer_stats))) 827 return; 828 829 while (items-- > 0) { 830 ZERO_SOCK(&dst); 831 ZERO_SOCK(&src); 832 if (pp->v6_flag != 0) { 833 AF(&dst) = AF_INET6; 834 AF(&src) = AF_INET6; 835 SOCK_ADDR6(&dst) = pp->dstadr6; 836 SOCK_ADDR6(&src) = pp->srcadr6; 837 } else { 838 AF(&dst) = AF_INET; 839 AF(&src) = AF_INET; 840 NSRCADR(&dst) = pp->dstadr; 841 NSRCADR(&src) = pp->srcadr; 842 } 843#ifdef ISC_PLATFORM_HAVESALEN 844 src.sas.ss_len = SOCKLEN(&src); 845 dst.sas.ss_len = SOCKLEN(&dst); 846#endif 847 (void) fprintf(fp, "remote host: %s\n", 848 nntohost(&src)); 849 (void) fprintf(fp, "local interface: %s\n", 850 stoa(&dst)); 851 (void) fprintf(fp, "time last received: %lds\n", 852 (long)ntohl(pp->timereceived)); 853 (void) fprintf(fp, "time until next send: %lds\n", 854 (long)ntohl(pp->timetosend)); 855 (void) fprintf(fp, "reachability change: %lds\n", 856 (long)ntohl(pp->timereachable)); 857 (void) fprintf(fp, "packets sent: %ld\n", 858 (long)ntohl(pp->sent)); 859 (void) fprintf(fp, "packets received: %ld\n", 860 (long)ntohl(pp->processed)); 861 (void) fprintf(fp, "bad authentication: %ld\n", 862 (long)ntohl(pp->badauth)); 863 (void) fprintf(fp, "bogus origin: %ld\n", 864 (long)ntohl(pp->bogusorg)); 865 (void) fprintf(fp, "duplicate: %ld\n", 866 (long)ntohl(pp->oldpkt)); 867 (void) fprintf(fp, "bad dispersion: %ld\n", 868 (long)ntohl(pp->seldisp)); 869 (void) fprintf(fp, "bad reference time: %ld\n", 870 (long)ntohl(pp->selbroken)); 871 (void) fprintf(fp, "candidate order: %d\n", 872 (int)pp->candidate); 873 if (items > 0) 874 (void) fprintf(fp, "\n"); 875 (void) fprintf(fp, "flags: "); 876 print_pflag(fp, ntohs(pp->flags)); 877 pp++; 878 } 879} 880 881 882/* 883 * loopinfo - show loop filter information 884 */ 885static void 886loopinfo( 887 struct parse *pcmd, 888 FILE *fp 889 ) 890{ 891 struct info_loop *il; 892 int items; 893 int itemsize; 894 int oneline = 0; 895 int res; 896 l_fp tempts; 897 898 if (pcmd->nargs > 0) { 899 if (STREQ(pcmd->argval[0].string, "oneline")) 900 oneline = 1; 901 else if (STREQ(pcmd->argval[0].string, "multiline")) 902 oneline = 0; 903 else { 904 (void) fprintf(stderr, "How many lines?\n"); 905 return; 906 } 907 } 908 909again: 910 res = doquery(impl_ver, REQ_LOOP_INFO, 0, 0, 0, (char *)NULL, 911 &items, &itemsize, (void *)&il, 0, 912 sizeof(struct info_loop)); 913 914 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 915 impl_ver = IMPL_XNTPD_OLD; 916 goto again; 917 } 918 919 if (res != 0) 920 return; 921 922 if (!check1item(items, fp)) 923 return; 924 925 if (!checkitemsize(itemsize, sizeof(struct info_loop))) 926 return; 927 928 if (oneline) { 929 l_fp temp2ts; 930 931 NTOHL_FP(&il->last_offset, &tempts); 932 NTOHL_FP(&il->drift_comp, &temp2ts); 933 934 (void) fprintf(fp, 935 "offset %s, frequency %s, time_const %ld, watchdog %ld\n", 936 lfptoa(&tempts, 6), 937 lfptoa(&temp2ts, 3), 938 (long)(int32)ntohl((u_long)il->compliance), 939 (u_long)ntohl((u_long)il->watchdog_timer)); 940 } else { 941 NTOHL_FP(&il->last_offset, &tempts); 942 (void) fprintf(fp, "offset: %s s\n", 943 lfptoa(&tempts, 6)); 944 NTOHL_FP(&il->drift_comp, &tempts); 945 (void) fprintf(fp, "frequency: %s ppm\n", 946 lfptoa(&tempts, 3)); 947 (void) fprintf(fp, "poll adjust: %ld\n", 948 (long)(int32)ntohl(il->compliance)); 949 (void) fprintf(fp, "watchdog timer: %ld s\n", 950 (u_long)ntohl(il->watchdog_timer)); 951 } 952} 953 954 955/* 956 * sysinfo - show current system state 957 */ 958/*ARGSUSED*/ 959static void 960sysinfo( 961 struct parse *pcmd, 962 FILE *fp 963 ) 964{ 965 struct info_sys *is; 966 sockaddr_u peeraddr; 967 int items; 968 int itemsize; 969 int res; 970 l_fp tempts; 971 972again: 973 res = doquery(impl_ver, REQ_SYS_INFO, 0, 0, 0, (char *)NULL, 974 &items, &itemsize, (void *)&is, 0, 975 sizeof(struct info_sys)); 976 977 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 978 impl_ver = IMPL_XNTPD_OLD; 979 goto again; 980 } 981 982 if (res != 0) 983 return; 984 985 if (!check1item(items, fp)) 986 return; 987 988 if (!checkitemsize(itemsize, sizeof(struct info_sys)) && 989 !checkitemsize(itemsize, v4sizeof(struct info_sys))) 990 return; 991 992 SET_ADDR(peeraddr, is->v6_flag, is->peer, is->peer6); 993 994 (void) fprintf(fp, "system peer: %s\n", nntohost(&peeraddr)); 995 (void) fprintf(fp, "system peer mode: %s\n", modetoa(is->peer_mode)); 996 (void) fprintf(fp, "leap indicator: %c%c\n", 997 is->leap & 0x2 ? '1' : '0', 998 is->leap & 0x1 ? '1' : '0'); 999 (void) fprintf(fp, "stratum: %d\n", (int)is->stratum); 1000 (void) fprintf(fp, "precision: %d\n", (int)is->precision); 1001 (void) fprintf(fp, "root distance: %s s\n", 1002 fptoa(NTOHS_FP(is->rootdelay), 5)); 1003 (void) fprintf(fp, "root dispersion: %s s\n", 1004 ufptoa(NTOHS_FP(is->rootdispersion), 5)); 1005 (void) fprintf(fp, "reference ID: [%s]\n", 1006 refid_string(is->refid, is->stratum)); 1007 NTOHL_FP(&is->reftime, &tempts); 1008 (void) fprintf(fp, "reference time: %s\n", prettydate(&tempts)); 1009 1010 (void) fprintf(fp, "system flags: "); 1011 if ((is->flags & (INFO_FLAG_BCLIENT | INFO_FLAG_AUTHENABLE | 1012 INFO_FLAG_NTP | INFO_FLAG_KERNEL| INFO_FLAG_CAL | 1013 INFO_FLAG_PPS_SYNC | INFO_FLAG_MONITOR | INFO_FLAG_FILEGEN)) == 0) { 1014 (void) fprintf(fp, "none\n"); 1015 } else { 1016 if (is->flags & INFO_FLAG_BCLIENT) 1017 (void) fprintf(fp, "bclient "); 1018 if (is->flags & INFO_FLAG_AUTHENTICATE) 1019 (void) fprintf(fp, "auth "); 1020 if (is->flags & INFO_FLAG_MONITOR) 1021 (void) fprintf(fp, "monitor "); 1022 if (is->flags & INFO_FLAG_NTP) 1023 (void) fprintf(fp, "ntp "); 1024 if (is->flags & INFO_FLAG_KERNEL) 1025 (void) fprintf(fp, "kernel "); 1026 if (is->flags & INFO_FLAG_FILEGEN) 1027 (void) fprintf(fp, "stats "); 1028 if (is->flags & INFO_FLAG_CAL) 1029 (void) fprintf(fp, "calibrate "); 1030 if (is->flags & INFO_FLAG_PPS_SYNC) 1031 (void) fprintf(fp, "pps "); 1032 (void) fprintf(fp, "\n"); 1033 } 1034 (void) fprintf(fp, "jitter: %s s\n", 1035 fptoa(ntohl(is->frequency), 6)); 1036 (void) fprintf(fp, "stability: %s ppm\n", 1037 ufptoa(ntohl(is->stability), 3)); 1038 (void) fprintf(fp, "broadcastdelay: %s s\n", 1039 fptoa(NTOHS_FP(is->bdelay), 6)); 1040 NTOHL_FP(&is->authdelay, &tempts); 1041 (void) fprintf(fp, "authdelay: %s s\n", lfptoa(&tempts, 6)); 1042} 1043 1044 1045/* 1046 * sysstats - print system statistics 1047 */ 1048/*ARGSUSED*/ 1049static void 1050sysstats( 1051 struct parse *pcmd, 1052 FILE *fp 1053 ) 1054{ 1055 struct info_sys_stats *ss; 1056 int items; 1057 int itemsize; 1058 int res; 1059 1060again: 1061 res = doquery(impl_ver, REQ_SYS_STATS, 0, 0, 0, (char *)NULL, 1062 &items, &itemsize, (void *)&ss, 0, 1063 sizeof(struct info_sys_stats)); 1064 1065 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 1066 impl_ver = IMPL_XNTPD_OLD; 1067 goto again; 1068 } 1069 1070 if (res != 0) 1071 return; 1072 1073 if (!check1item(items, fp)) 1074 return; 1075 1076 if (itemsize != sizeof(struct info_sys_stats) && 1077 itemsize != sizeof(struct old_info_sys_stats)) { 1078 /* issue warning according to new structure size */ 1079 checkitemsize(itemsize, sizeof(struct info_sys_stats)); 1080 return; 1081 } 1082 fprintf(fp, "time since restart: %ld\n", 1083 (u_long)ntohl(ss->timeup)); 1084 fprintf(fp, "time since reset: %ld\n", 1085 (u_long)ntohl(ss->timereset)); 1086 fprintf(fp, "packets received: %ld\n", 1087 (u_long)ntohl(ss->received)); 1088 fprintf(fp, "packets processed: %ld\n", 1089 (u_long)ntohl(ss->processed)); 1090 fprintf(fp, "current version: %ld\n", 1091 (u_long)ntohl(ss->newversionpkt)); 1092 fprintf(fp, "previous version: %ld\n", 1093 (u_long)ntohl(ss->oldversionpkt)); 1094 fprintf(fp, "declined: %ld\n", 1095 (u_long)ntohl(ss->unknownversion)); 1096 fprintf(fp, "access denied: %ld\n", 1097 (u_long)ntohl(ss->denied)); 1098 fprintf(fp, "bad length or format: %ld\n", 1099 (u_long)ntohl(ss->badlength)); 1100 fprintf(fp, "bad authentication: %ld\n", 1101 (u_long)ntohl(ss->badauth)); 1102 if (itemsize != sizeof(struct info_sys_stats)) 1103 return; 1104 1105 fprintf(fp, "rate exceeded: %ld\n", 1106 (u_long)ntohl(ss->limitrejected)); 1107} 1108 1109 1110 1111/* 1112 * iostats - print I/O statistics 1113 */ 1114/*ARGSUSED*/ 1115static void 1116iostats( 1117 struct parse *pcmd, 1118 FILE *fp 1119 ) 1120{ 1121 struct info_io_stats *io; 1122 int items; 1123 int itemsize; 1124 int res; 1125 1126again: 1127 res = doquery(impl_ver, REQ_IO_STATS, 0, 0, 0, (char *)NULL, 1128 &items, &itemsize, (void *)&io, 0, 1129 sizeof(struct info_io_stats)); 1130 1131 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 1132 impl_ver = IMPL_XNTPD_OLD; 1133 goto again; 1134 } 1135 1136 if (res != 0) 1137 return; 1138 1139 if (!check1item(items, fp)) 1140 return; 1141 1142 if (!checkitemsize(itemsize, sizeof(struct info_io_stats))) 1143 return; 1144 1145 (void) fprintf(fp, "time since reset: %ld\n", 1146 (u_long)ntohl(io->timereset)); 1147 (void) fprintf(fp, "receive buffers: %d\n", 1148 ntohs(io->totalrecvbufs)); 1149 (void) fprintf(fp, "free receive buffers: %d\n", 1150 ntohs(io->freerecvbufs)); 1151 (void) fprintf(fp, "used receive buffers: %d\n", 1152 ntohs(io->fullrecvbufs)); 1153 (void) fprintf(fp, "low water refills: %d\n", 1154 ntohs(io->lowwater)); 1155 (void) fprintf(fp, "dropped packets: %ld\n", 1156 (u_long)ntohl(io->dropped)); 1157 (void) fprintf(fp, "ignored packets: %ld\n", 1158 (u_long)ntohl(io->ignored)); 1159 (void) fprintf(fp, "received packets: %ld\n", 1160 (u_long)ntohl(io->received)); 1161 (void) fprintf(fp, "packets sent: %ld\n", 1162 (u_long)ntohl(io->sent)); 1163 (void) fprintf(fp, "packets not sent: %ld\n", 1164 (u_long)ntohl(io->notsent)); 1165 (void) fprintf(fp, "interrupts handled: %ld\n", 1166 (u_long)ntohl(io->interrupts)); 1167 (void) fprintf(fp, "received by int: %ld\n", 1168 (u_long)ntohl(io->int_received)); 1169} 1170 1171 1172/* 1173 * memstats - print peer memory statistics 1174 */ 1175/*ARGSUSED*/ 1176static void 1177memstats( 1178 struct parse *pcmd, 1179 FILE *fp 1180 ) 1181{ 1182 struct info_mem_stats *mem; 1183 int i; 1184 int items; 1185 int itemsize; 1186 int res; 1187 1188again: 1189 res = doquery(impl_ver, REQ_MEM_STATS, 0, 0, 0, (char *)NULL, 1190 &items, &itemsize, (void *)&mem, 0, 1191 sizeof(struct info_mem_stats)); 1192 1193 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 1194 impl_ver = IMPL_XNTPD_OLD; 1195 goto again; 1196 } 1197 1198 if (res != 0) 1199 return; 1200 1201 if (!check1item(items, fp)) 1202 return; 1203 1204 if (!checkitemsize(itemsize, sizeof(struct info_mem_stats))) 1205 return; 1206 1207 (void) fprintf(fp, "time since reset: %ld\n", 1208 (u_long)ntohl(mem->timereset)); 1209 (void) fprintf(fp, "total peer memory: %d\n", 1210 ntohs(mem->totalpeermem)); 1211 (void) fprintf(fp, "free peer memory: %d\n", 1212 ntohs(mem->freepeermem)); 1213 (void) fprintf(fp, "calls to findpeer: %ld\n", 1214 (u_long)ntohl(mem->findpeer_calls)); 1215 (void) fprintf(fp, "new peer allocations: %ld\n", 1216 (u_long)ntohl(mem->allocations)); 1217 (void) fprintf(fp, "peer demobilizations: %ld\n", 1218 (u_long)ntohl(mem->demobilizations)); 1219 1220 (void) fprintf(fp, "hash table counts: "); 1221 for (i = 0; i < NTP_HASH_SIZE; i++) { 1222 (void) fprintf(fp, "%4d", (int)mem->hashcount[i]); 1223 if ((i % 8) == 7 && i != (NTP_HASH_SIZE-1)) { 1224 (void) fprintf(fp, "\n "); 1225 } 1226 } 1227 (void) fprintf(fp, "\n"); 1228} 1229 1230 1231 1232/* 1233 * timerstats - print timer statistics 1234 */ 1235/*ARGSUSED*/ 1236static void 1237timerstats( 1238 struct parse *pcmd, 1239 FILE *fp 1240 ) 1241{ 1242 struct info_timer_stats *tim; 1243 int items; 1244 int itemsize; 1245 int res; 1246 1247again: 1248 res = doquery(impl_ver, REQ_TIMER_STATS, 0, 0, 0, (char *)NULL, 1249 &items, &itemsize, (void *)&tim, 0, 1250 sizeof(struct info_timer_stats)); 1251 1252 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 1253 impl_ver = IMPL_XNTPD_OLD; 1254 goto again; 1255 } 1256 1257 if (res != 0) 1258 return; 1259 1260 if (!check1item(items, fp)) 1261 return; 1262 1263 if (!checkitemsize(itemsize, sizeof(struct info_timer_stats))) 1264 return; 1265 1266 (void) fprintf(fp, "time since reset: %ld\n", 1267 (u_long)ntohl(tim->timereset)); 1268 (void) fprintf(fp, "alarms handled: %ld\n", 1269 (u_long)ntohl(tim->alarms)); 1270 (void) fprintf(fp, "alarm overruns: %ld\n", 1271 (u_long)ntohl(tim->overflows)); 1272 (void) fprintf(fp, "calls to transmit: %ld\n", 1273 (u_long)ntohl(tim->xmtcalls)); 1274} 1275 1276 1277/* 1278 * addpeer - configure an active mode association 1279 */ 1280static void 1281addpeer( 1282 struct parse *pcmd, 1283 FILE *fp 1284 ) 1285{ 1286 doconfig(pcmd, fp, MODE_ACTIVE, 0); 1287} 1288 1289 1290/* 1291 * addserver - configure a client mode association 1292 */ 1293static void 1294addserver( 1295 struct parse *pcmd, 1296 FILE *fp 1297 ) 1298{ 1299 doconfig(pcmd, fp, MODE_CLIENT, 0); 1300} 1301 1302/* 1303 * addrefclock - configure a reference clock association 1304 */ 1305static void 1306addrefclock( 1307 struct parse *pcmd, 1308 FILE *fp 1309 ) 1310{ 1311 doconfig(pcmd, fp, MODE_CLIENT, 1); 1312} 1313 1314/* 1315 * broadcast - configure a broadcast mode association 1316 */ 1317static void 1318broadcast( 1319 struct parse *pcmd, 1320 FILE *fp 1321 ) 1322{ 1323 doconfig(pcmd, fp, MODE_BROADCAST, 0); 1324} 1325 1326 1327/* 1328 * config - configure a new peer association 1329 */ 1330static void 1331doconfig( 1332 struct parse *pcmd, 1333 FILE *fp, 1334 int mode, 1335 int refc 1336 ) 1337{ 1338 struct conf_peer cpeer; 1339 int items; 1340 int itemsize; 1341 char *dummy; 1342 u_long keyid; 1343 u_int version; 1344 u_char minpoll; 1345 u_char maxpoll; 1346 u_int flags; 1347 u_char cmode; 1348 int res; 1349 int sendsize; 1350 int numtyp; 1351 1352again: 1353 keyid = 0; 1354 version = 3; 1355 flags = 0; 1356 res = 0; 1357 cmode = 0; 1358 minpoll = NTP_MINDPOLL; 1359 maxpoll = NTP_MAXDPOLL; 1360 numtyp = 1; 1361 if (refc) 1362 numtyp = 5; 1363 1364 if (impl_ver == IMPL_XNTPD) 1365 sendsize = sizeof(struct conf_peer); 1366 else 1367 sendsize = v4sizeof(struct conf_peer); 1368 1369 items = 1; 1370 while (pcmd->nargs > items) { 1371 if (STREQ(pcmd->argval[items].string, "prefer")) 1372 flags |= CONF_FLAG_PREFER; 1373 else if (STREQ(pcmd->argval[items].string, "burst")) 1374 flags |= CONF_FLAG_BURST; 1375 else if (STREQ(pcmd->argval[items].string, "iburst")) 1376 flags |= CONF_FLAG_IBURST; 1377 else if (!refc && STREQ(pcmd->argval[items].string, "keyid")) 1378 numtyp = 1; 1379 else if (!refc && STREQ(pcmd->argval[items].string, "version")) 1380 numtyp = 2; 1381 else if (STREQ(pcmd->argval[items].string, "minpoll")) 1382 numtyp = 3; 1383 else if (STREQ(pcmd->argval[items].string, "maxpoll")) 1384 numtyp = 4; 1385 else { 1386 long val; 1387 if (!atoint(pcmd->argval[items].string, &val)) 1388 numtyp = 0; 1389 switch (numtyp) { 1390 case 1: 1391 keyid = val; 1392 numtyp = 2; 1393 break; 1394 1395 case 2: 1396 version = (u_int) val; 1397 numtyp = 0; 1398 break; 1399 1400 case 3: 1401 minpoll = (u_char)val; 1402 numtyp = 0; 1403 break; 1404 1405 case 4: 1406 maxpoll = (u_char)val; 1407 numtyp = 0; 1408 break; 1409 1410 case 5: 1411 cmode = (u_char)val; 1412 numtyp = 0; 1413 break; 1414 1415 default: 1416 (void) fprintf(fp, "*** '%s' not understood\n", 1417 pcmd->argval[items].string); 1418 res++; 1419 numtyp = 0; 1420 } 1421 if (val < 0) { 1422 (void) fprintf(stderr, 1423 "***Value '%s' should be unsigned\n", 1424 pcmd->argval[items].string); 1425 res++; 1426 } 1427 } 1428 items++; 1429 } 1430 if (keyid > 0) 1431 flags |= CONF_FLAG_AUTHENABLE; 1432 if (version > NTP_VERSION || 1433 version < NTP_OLDVERSION) { 1434 (void)fprintf(fp, "***invalid version number: %u\n", 1435 version); 1436 res++; 1437 } 1438 if (minpoll < NTP_MINPOLL || minpoll > NTP_MAXPOLL || 1439 maxpoll < NTP_MINPOLL || maxpoll > NTP_MAXPOLL || 1440 minpoll > maxpoll) { 1441 (void) fprintf(fp, "***min/max-poll must be within %d..%d\n", 1442 NTP_MINPOLL, NTP_MAXPOLL); 1443 res++; 1444 } 1445 1446 if (res) 1447 return; 1448 1449 memset(&cpeer, 0, sizeof(cpeer)); 1450 1451 if (IS_IPV4(&pcmd->argval[0].netnum)) { 1452 cpeer.peeraddr = NSRCADR(&pcmd->argval[0].netnum); 1453 if (impl_ver == IMPL_XNTPD) 1454 cpeer.v6_flag = 0; 1455 } else { 1456 if (impl_ver == IMPL_XNTPD_OLD) { 1457 fprintf(stderr, 1458 "***Server doesn't understand IPv6 addresses\n"); 1459 return; 1460 } 1461 cpeer.peeraddr6 = SOCK_ADDR6(&pcmd->argval[0].netnum); 1462 cpeer.v6_flag = 1; 1463 } 1464 cpeer.hmode = (u_char) mode; 1465 cpeer.keyid = keyid; 1466 cpeer.version = (u_char) version; 1467 cpeer.minpoll = minpoll; 1468 cpeer.maxpoll = maxpoll; 1469 cpeer.flags = (u_char)flags; 1470 cpeer.ttl = cmode; 1471 1472 res = doquery(impl_ver, REQ_CONFIG, 1, 1, 1473 sendsize, (char *)&cpeer, &items, 1474 &itemsize, &dummy, 0, sizeof(struct conf_peer)); 1475 1476 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 1477 impl_ver = IMPL_XNTPD_OLD; 1478 goto again; 1479 } 1480 1481 if (res == INFO_ERR_FMT) { 1482 (void) fprintf(fp, 1483 "***Retrying command with old conf_peer size\n"); 1484 res = doquery(impl_ver, REQ_CONFIG, 1, 1, 1485 sizeof(struct old_conf_peer), (char *)&cpeer, 1486 &items, &itemsize, &dummy, 0, 1487 sizeof(struct conf_peer)); 1488 } 1489 if (res == 0) 1490 (void) fprintf(fp, "done!\n"); 1491 return; 1492} 1493 1494 1495/* 1496 * unconfig - unconfigure some associations 1497 */ 1498static void 1499unconfig( 1500 struct parse *pcmd, 1501 FILE *fp 1502 ) 1503{ 1504 /* 8 is the maximum number of peers which will fit in a packet */ 1505 struct conf_unpeer *pl, plist[min(MAXARGS, 8)]; 1506 int qitemlim; 1507 int qitems; 1508 int items; 1509 int itemsize; 1510 char *dummy; 1511 int res; 1512 int sendsize; 1513 1514again: 1515 if (impl_ver == IMPL_XNTPD) 1516 sendsize = sizeof(struct conf_unpeer); 1517 else 1518 sendsize = v4sizeof(struct conf_unpeer); 1519 1520 qitemlim = min(pcmd->nargs, COUNTOF(plist)); 1521 for (qitems = 0, pl = plist; qitems < qitemlim; qitems++) { 1522 if (IS_IPV4(&pcmd->argval[0].netnum)) { 1523 pl->peeraddr = NSRCADR(&pcmd->argval[qitems].netnum); 1524 if (impl_ver == IMPL_XNTPD) 1525 pl->v6_flag = 0; 1526 } else { 1527 if (impl_ver == IMPL_XNTPD_OLD) { 1528 fprintf(stderr, 1529 "***Server doesn't understand IPv6 addresses\n"); 1530 return; 1531 } 1532 pl->peeraddr6 = 1533 SOCK_ADDR6(&pcmd->argval[qitems].netnum); 1534 pl->v6_flag = 1; 1535 } 1536 pl = (struct conf_unpeer *)((char *)pl + sendsize); 1537 } 1538 1539 res = doquery(impl_ver, REQ_UNCONFIG, 1, qitems, 1540 sendsize, (char *)plist, &items, 1541 &itemsize, &dummy, 0, sizeof(struct conf_unpeer)); 1542 1543 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 1544 impl_ver = IMPL_XNTPD_OLD; 1545 goto again; 1546 } 1547 1548 if (res == 0) 1549 (void) fprintf(fp, "done!\n"); 1550} 1551 1552 1553/* 1554 * set - set some system flags 1555 */ 1556static void 1557set( 1558 struct parse *pcmd, 1559 FILE *fp 1560 ) 1561{ 1562 doset(pcmd, fp, REQ_SET_SYS_FLAG); 1563} 1564 1565 1566/* 1567 * clear - clear some system flags 1568 */ 1569static void 1570sys_clear( 1571 struct parse *pcmd, 1572 FILE *fp 1573 ) 1574{ 1575 doset(pcmd, fp, REQ_CLR_SYS_FLAG); 1576} 1577 1578 1579/* 1580 * doset - set/clear system flags 1581 */ 1582static void 1583doset( 1584 struct parse *pcmd, 1585 FILE *fp, 1586 int req 1587 ) 1588{ 1589 struct conf_sys_flags sys; 1590 int items; 1591 int itemsize; 1592 char *dummy; 1593 int res; 1594 1595 sys.flags = 0; 1596 res = 0; 1597 for (items = 0; items < pcmd->nargs; items++) { 1598 if (STREQ(pcmd->argval[items].string, "auth")) 1599 sys.flags |= SYS_FLAG_AUTH; 1600 else if (STREQ(pcmd->argval[items].string, "bclient")) 1601 sys.flags |= SYS_FLAG_BCLIENT; 1602 else if (STREQ(pcmd->argval[items].string, "calibrate")) 1603 sys.flags |= SYS_FLAG_CAL; 1604 else if (STREQ(pcmd->argval[items].string, "kernel")) 1605 sys.flags |= SYS_FLAG_KERNEL; 1606 else if (STREQ(pcmd->argval[items].string, "monitor")) 1607 sys.flags |= SYS_FLAG_MONITOR; 1608 else if (STREQ(pcmd->argval[items].string, "ntp")) 1609 sys.flags |= SYS_FLAG_NTP; 1610 else if (STREQ(pcmd->argval[items].string, "pps")) 1611 sys.flags |= SYS_FLAG_PPS; 1612 else if (STREQ(pcmd->argval[items].string, "stats")) 1613 sys.flags |= SYS_FLAG_FILEGEN; 1614 else { 1615 (void) fprintf(fp, "Unknown flag %s\n", 1616 pcmd->argval[items].string); 1617 res = 1; 1618 } 1619 } 1620 1621 sys.flags = htonl(sys.flags); 1622 if (res || sys.flags == 0) 1623 return; 1624 1625again: 1626 res = doquery(impl_ver, req, 1, 1, 1627 sizeof(struct conf_sys_flags), (char *)&sys, &items, 1628 &itemsize, &dummy, 0, sizeof(struct conf_sys_flags)); 1629 1630 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 1631 impl_ver = IMPL_XNTPD_OLD; 1632 goto again; 1633 } 1634 1635 if (res == 0) 1636 (void) fprintf(fp, "done!\n"); 1637} 1638 1639 1640/* 1641 * data for printing/interrpreting the restrict flags 1642 */ 1643struct resflags { 1644 const char *str; 1645 int bit; 1646}; 1647 1648/* XXX: HMS: we apparently don't report set bits we do not recognize. */ 1649 1650static struct resflags resflagsV2[] = { 1651 { "ignore", 0x001 }, 1652 { "noserve", 0x002 }, 1653 { "notrust", 0x004 }, 1654 { "noquery", 0x008 }, 1655 { "nomodify", 0x010 }, 1656 { "nopeer", 0x020 }, 1657 { "notrap", 0x040 }, 1658 { "lptrap", 0x080 }, 1659 { "limited", 0x100 }, 1660 { "", 0 } 1661}; 1662 1663static struct resflags resflagsV3[] = { 1664 { "ignore", RES_IGNORE }, 1665 { "noserve", RES_DONTSERVE }, 1666 { "notrust", RES_DONTTRUST }, 1667 { "noquery", RES_NOQUERY }, 1668 { "nomodify", RES_NOMODIFY }, 1669 { "nopeer", RES_NOPEER }, 1670 { "notrap", RES_NOTRAP }, 1671 { "lptrap", RES_LPTRAP }, 1672 { "limited", RES_LIMITED }, 1673 { "version", RES_VERSION }, 1674 { "kod", RES_KOD }, 1675 { "timeout", RES_TIMEOUT }, 1676 1677 { "", 0 } 1678}; 1679 1680static struct resflags resmflags[] = { 1681 { "ntpport", RESM_NTPONLY }, 1682 { "interface", RESM_INTERFACE }, 1683 { "", 0 } 1684}; 1685 1686 1687/* 1688 * reslist - obtain and print the server's restrict list 1689 */ 1690/*ARGSUSED*/ 1691static void 1692reslist( 1693 struct parse *pcmd, 1694 FILE *fp 1695 ) 1696{ 1697 struct info_restrict *rl; 1698 sockaddr_u resaddr; 1699 sockaddr_u maskaddr; 1700 int items; 1701 int itemsize; 1702 int res; 1703 int skip; 1704 char *addr; 1705 char *mask; 1706 struct resflags *rf; 1707 u_int32 count; 1708 u_short flags; 1709 u_short mflags; 1710 char flagstr[300]; 1711 static const char *comma = ", "; 1712 1713again: 1714 res = doquery(impl_ver, REQ_GET_RESTRICT, 0, 0, 0, (char *)NULL, 1715 &items, &itemsize, (void *)&rl, 0, 1716 sizeof(struct info_restrict)); 1717 1718 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 1719 impl_ver = IMPL_XNTPD_OLD; 1720 goto again; 1721 } 1722 1723 if (res != 0) 1724 return; 1725 1726 if (!checkitems(items, fp)) 1727 return; 1728 1729 if (!checkitemsize(itemsize, sizeof(struct info_restrict)) && 1730 !checkitemsize(itemsize, v4sizeof(struct info_restrict))) 1731 return; 1732 1733 (void) fprintf(fp, 1734 " address mask count flags\n"); 1735 (void) fprintf(fp, 1736 "=====================================================================\n"); 1737 1738 while (items > 0) { 1739 SET_ADDRS(resaddr, maskaddr, rl, addr, mask); 1740 if (rl->v6_flag != 0) { 1741 addr = nntohost(&resaddr); 1742 } else { 1743 if ((rl->mask == (u_int32)0xffffffff)) 1744 addr = nntohost(&resaddr); 1745 else 1746 addr = stoa(&resaddr); 1747 } 1748 mask = stoa(&maskaddr); 1749 skip = 1; 1750 if ((pcmd->nargs == 0) || 1751 ((pcmd->argval->ival == 6) && (rl->v6_flag != 0)) || 1752 ((pcmd->argval->ival == 4) && (rl->v6_flag == 0))) 1753 skip = 0; 1754 count = ntohl(rl->count); 1755 flags = ntohs(rl->flags); 1756 mflags = ntohs(rl->mflags); 1757 flagstr[0] = '\0'; 1758 1759 res = 1; 1760 rf = &resmflags[0]; 1761 while (rf->bit != 0) { 1762 if (mflags & rf->bit) { 1763 if (!res) 1764 (void) strcat(flagstr, comma); 1765 res = 0; 1766 (void) strcat(flagstr, rf->str); 1767 } 1768 rf++; 1769 } 1770 1771 rf = (impl_ver == IMPL_XNTPD_OLD) 1772 ? &resflagsV2[0] 1773 : &resflagsV3[0] 1774 ; 1775 while (rf->bit != 0) { 1776 if (flags & rf->bit) { 1777 if (!res) 1778 (void) strcat(flagstr, comma); 1779 res = 0; 1780 (void) strcat(flagstr, rf->str); 1781 } 1782 rf++; 1783 } 1784 1785 if (flagstr[0] == '\0') 1786 (void) strcpy(flagstr, "none"); 1787 1788 if (!skip) 1789 (void) fprintf(fp, "%-15.15s %-15.15s %9ld %s\n", 1790 addr, mask, (u_long)count, flagstr); 1791 rl++; 1792 items--; 1793 } 1794} 1795 1796 1797 1798/* 1799 * new_restrict - create/add a set of restrictions 1800 */ 1801static void 1802new_restrict( 1803 struct parse *pcmd, 1804 FILE *fp 1805 ) 1806{ 1807 do_restrict(pcmd, fp, REQ_RESADDFLAGS); 1808} 1809 1810 1811/* 1812 * unrestrict - remove restriction flags from existing entry 1813 */ 1814static void 1815unrestrict( 1816 struct parse *pcmd, 1817 FILE *fp 1818 ) 1819{ 1820 do_restrict(pcmd, fp, REQ_RESSUBFLAGS); 1821} 1822 1823 1824/* 1825 * delrestrict - delete an existing restriction 1826 */ 1827static void 1828delrestrict( 1829 struct parse *pcmd, 1830 FILE *fp 1831 ) 1832{ 1833 do_restrict(pcmd, fp, REQ_UNRESTRICT); 1834} 1835 1836 1837/* 1838 * do_restrict - decode commandline restrictions and make the request 1839 */ 1840static void 1841do_restrict( 1842 struct parse *pcmd, 1843 FILE *fp, 1844 int req_code 1845 ) 1846{ 1847 struct conf_restrict cres; 1848 int items; 1849 int itemsize; 1850 char *dummy; 1851 u_int32 num; 1852 u_long bit; 1853 int i; 1854 int res; 1855 int err; 1856 int sendsize; 1857 1858 /* Initialize cres */ 1859 cres.addr = 0; 1860 cres.mask = 0; 1861 cres.flags = 0; 1862 cres.mflags = 0; 1863 cres.v6_flag = 0; 1864 1865again: 1866 if (impl_ver == IMPL_XNTPD) 1867 sendsize = sizeof(struct conf_restrict); 1868 else 1869 sendsize = v4sizeof(struct conf_restrict); 1870 1871 if (IS_IPV4(&pcmd->argval[0].netnum)) { 1872 cres.addr = NSRCADR(&pcmd->argval[0].netnum); 1873 cres.mask = NSRCADR(&pcmd->argval[1].netnum); 1874 if (impl_ver == IMPL_XNTPD) 1875 cres.v6_flag = 0; 1876 } else { 1877 if (impl_ver == IMPL_XNTPD_OLD) { 1878 fprintf(stderr, 1879 "***Server doesn't understand IPv6 addresses\n"); 1880 return; 1881 } 1882 cres.addr6 = SOCK_ADDR6(&pcmd->argval[0].netnum); 1883 cres.v6_flag = 1; 1884 } 1885 cres.flags = 0; 1886 cres.mflags = 0; 1887 err = 0; 1888 for (res = 2; res < pcmd->nargs; res++) { 1889 if (STREQ(pcmd->argval[res].string, "ntpport")) { 1890 cres.mflags |= RESM_NTPONLY; 1891 } else { 1892 for (i = 0; resflagsV3[i].bit != 0; i++) { 1893 if (STREQ(pcmd->argval[res].string, 1894 resflagsV3[i].str)) 1895 break; 1896 } 1897 if (resflagsV3[i].bit != 0) { 1898 cres.flags |= resflagsV3[i].bit; 1899 if (req_code == REQ_UNRESTRICT) { 1900 (void) fprintf(fp, 1901 "Flag %s inappropriate\n", 1902 resflagsV3[i].str); 1903 err++; 1904 } 1905 } else { 1906 (void) fprintf(fp, "Unknown flag %s\n", 1907 pcmd->argval[res].string); 1908 err++; 1909 } 1910 } 1911 } 1912 cres.flags = htons(cres.flags); 1913 cres.mflags = htons(cres.mflags); 1914 1915 /* 1916 * Make sure mask for default address is zero. Otherwise, 1917 * make sure mask bits are contiguous. 1918 */ 1919 if (IS_IPV4(&pcmd->argval[0].netnum)) { 1920 if (cres.addr == 0) { 1921 cres.mask = 0; 1922 } else { 1923 num = ntohl(cres.mask); 1924 for (bit = 0x80000000; bit != 0; bit >>= 1) 1925 if ((num & bit) == 0) 1926 break; 1927 for ( ; bit != 0; bit >>= 1) 1928 if ((num & bit) != 0) 1929 break; 1930 if (bit != 0) { 1931 (void) fprintf(fp, "Invalid mask %s\n", 1932 numtoa(cres.mask)); 1933 err++; 1934 } 1935 } 1936 } else { 1937 /* XXX IPv6 sanity checking stuff */ 1938 } 1939 1940 if (err) 1941 return; 1942 1943 res = doquery(impl_ver, req_code, 1, 1, 1944 sendsize, (char *)&cres, &items, 1945 &itemsize, &dummy, 0, sizeof(struct conf_restrict)); 1946 1947 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 1948 impl_ver = IMPL_XNTPD_OLD; 1949 goto again; 1950 } 1951 1952 if (res == 0) 1953 (void) fprintf(fp, "done!\n"); 1954 return; 1955} 1956 1957 1958/* 1959 * monlist - obtain and print the server's monitor data 1960 */ 1961/*ARGSUSED*/ 1962static void 1963monlist( 1964 struct parse *pcmd, 1965 FILE *fp 1966 ) 1967{ 1968 char *struct_star; 1969 sockaddr_u addr; 1970 sockaddr_u dstadr; 1971 int items; 1972 int itemsize; 1973 int res; 1974 int version = -1; 1975 1976 if (pcmd->nargs > 0) { 1977 version = pcmd->argval[0].ival; 1978 } 1979 1980again: 1981 res = doquery(impl_ver, 1982 (version == 1 || version == -1) ? REQ_MON_GETLIST_1 : 1983 REQ_MON_GETLIST, 0, 0, 0, (char *)NULL, 1984 &items, &itemsize, &struct_star, 1985 (version < 0) ? (1 << INFO_ERR_REQ) : 0, 1986 sizeof(struct info_monitor_1)); 1987 1988 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 1989 impl_ver = IMPL_XNTPD_OLD; 1990 goto again; 1991 } 1992 1993 if (res == INFO_ERR_REQ && version < 0) 1994 res = doquery(impl_ver, REQ_MON_GETLIST, 0, 0, 0, (char *)NULL, 1995 &items, &itemsize, &struct_star, 0, 1996 sizeof(struct info_monitor)); 1997 1998 if (res != 0) 1999 return; 2000 2001 if (!checkitems(items, fp)) 2002 return; 2003 2004 if (itemsize == sizeof(struct info_monitor_1) || 2005 itemsize == v4sizeof(struct info_monitor_1)) { 2006 struct info_monitor_1 *ml = (struct info_monitor_1 *) struct_star; 2007 2008 (void) fprintf(fp, 2009 "remote address port local address count m ver rstr avgint lstint\n"); 2010 (void) fprintf(fp, 2011 "===============================================================================\n"); 2012 while (items > 0) { 2013 SET_ADDRS(dstadr, addr, ml, daddr, addr); 2014 if ((pcmd->nargs == 0) || 2015 ((pcmd->argval->ival == 6) && (ml->v6_flag != 0)) || 2016 ((pcmd->argval->ival == 4) && (ml->v6_flag == 0))) 2017 (void) fprintf(fp, 2018 "%-22.22s %5d %-15s %8ld %1d %1d %6lx %6lu %7lu\n", 2019 nntohost(&addr), 2020 ntohs(ml->port), 2021 stoa(&dstadr), 2022 (u_long)ntohl(ml->count), 2023 ml->mode, 2024 ml->version, 2025 (u_long)ntohl(ml->restr), 2026 (u_long)ntohl(ml->lasttime), 2027 (u_long)ntohl(ml->firsttime)); 2028 ml++; 2029 items--; 2030 } 2031 } else if (itemsize == sizeof(struct info_monitor) || 2032 itemsize == v4sizeof(struct info_monitor)) { 2033 struct info_monitor *ml = (struct info_monitor *) struct_star; 2034 2035 (void) fprintf(fp, 2036 " address port count mode ver rstr avgint lstint\n"); 2037 (void) fprintf(fp, 2038 "===============================================================================\n"); 2039 while (items > 0) { 2040 SET_ADDR(dstadr, ml->v6_flag, ml->addr, ml->addr6); 2041 if ((pcmd->nargs == 0) || 2042 ((pcmd->argval->ival == 6) && (ml->v6_flag != 0)) || 2043 ((pcmd->argval->ival == 4) && (ml->v6_flag == 0))) 2044 (void) fprintf(fp, 2045 "%-25.25s %5d %9ld %4d %2d %9lx %9lu %9lu\n", 2046 nntohost(&dstadr), 2047 ntohs(ml->port), 2048 (u_long)ntohl(ml->count), 2049 ml->mode, 2050 ml->version, 2051 (u_long)ntohl(ml->restr), 2052 (u_long)ntohl(ml->lasttime), 2053 (u_long)ntohl(ml->firsttime)); 2054 ml++; 2055 items--; 2056 } 2057 } else if (itemsize == sizeof(struct old_info_monitor)) { 2058 struct old_info_monitor *oml = (struct old_info_monitor *)struct_star; 2059 (void) fprintf(fp, 2060 " address port count mode version lasttime firsttime\n"); 2061 (void) fprintf(fp, 2062 "======================================================================\n"); 2063 while (items > 0) { 2064 SET_ADDR(dstadr, oml->v6_flag, oml->addr, oml->addr6); 2065 (void) fprintf(fp, "%-20.20s %5d %9ld %4d %3d %9lu %9lu\n", 2066 nntohost(&dstadr), 2067 ntohs(oml->port), 2068 (u_long)ntohl(oml->count), 2069 oml->mode, 2070 oml->version, 2071 (u_long)ntohl(oml->lasttime), 2072 (u_long)ntohl(oml->firsttime)); 2073 oml++; 2074 items--; 2075 } 2076 } else { 2077 /* issue warning according to new info_monitor size */ 2078 checkitemsize(itemsize, sizeof(struct info_monitor)); 2079 } 2080} 2081 2082 2083/* 2084 * Mapping between command line strings and stat reset flags 2085 */ 2086struct statreset { 2087 const char *str; 2088 int flag; 2089} sreset[] = { 2090 { "io", RESET_FLAG_IO }, 2091 { "sys", RESET_FLAG_SYS }, 2092 { "mem", RESET_FLAG_MEM }, 2093 { "timer", RESET_FLAG_TIMER }, 2094 { "auth", RESET_FLAG_AUTH }, 2095 { "allpeers", RESET_FLAG_ALLPEERS }, 2096 { "", 0 } 2097}; 2098 2099/* 2100 * reset - reset statistic counters 2101 */ 2102static void 2103reset( 2104 struct parse *pcmd, 2105 FILE *fp 2106 ) 2107{ 2108 struct reset_flags rflags; 2109 int items; 2110 int itemsize; 2111 char *dummy; 2112 int i; 2113 int res; 2114 int err; 2115 2116 err = 0; 2117 rflags.flags = 0; 2118 for (res = 0; res < pcmd->nargs; res++) { 2119 for (i = 0; sreset[i].flag != 0; i++) { 2120 if (STREQ(pcmd->argval[res].string, sreset[i].str)) 2121 break; 2122 } 2123 if (sreset[i].flag == 0) { 2124 (void) fprintf(fp, "Flag %s unknown\n", 2125 pcmd->argval[res].string); 2126 err++; 2127 } else { 2128 rflags.flags |= sreset[i].flag; 2129 } 2130 } 2131 rflags.flags = htonl(rflags.flags); 2132 2133 if (err) { 2134 (void) fprintf(fp, "Not done due to errors\n"); 2135 return; 2136 } 2137 2138again: 2139 res = doquery(impl_ver, REQ_RESET_STATS, 1, 1, 2140 sizeof(struct reset_flags), (char *)&rflags, &items, 2141 &itemsize, &dummy, 0, sizeof(struct reset_flags)); 2142 2143 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2144 impl_ver = IMPL_XNTPD_OLD; 2145 goto again; 2146 } 2147 2148 if (res == 0) 2149 (void) fprintf(fp, "done!\n"); 2150 return; 2151} 2152 2153 2154 2155/* 2156 * preset - reset stat counters for particular peers 2157 */ 2158static void 2159preset( 2160 struct parse *pcmd, 2161 FILE *fp 2162 ) 2163{ 2164 /* 8 is the maximum number of peers which will fit in a packet */ 2165 struct conf_unpeer *pl, plist[min(MAXARGS, 8)]; 2166 int qitemlim; 2167 int qitems; 2168 int items; 2169 int itemsize; 2170 char *dummy; 2171 int res; 2172 int sendsize; 2173 2174again: 2175 if (impl_ver == IMPL_XNTPD) 2176 sendsize = sizeof(struct conf_unpeer); 2177 else 2178 sendsize = v4sizeof(struct conf_unpeer); 2179 2180 qitemlim = min(pcmd->nargs, COUNTOF(plist)); 2181 for (qitems = 0, pl = plist; qitems < qitemlim; qitems++) { 2182 if (IS_IPV4(&pcmd->argval[qitems].netnum)) { 2183 pl->peeraddr = NSRCADR(&pcmd->argval[qitems].netnum); 2184 if (impl_ver == IMPL_XNTPD) 2185 pl->v6_flag = 0; 2186 } else { 2187 if (impl_ver == IMPL_XNTPD_OLD) { 2188 fprintf(stderr, 2189 "***Server doesn't understand IPv6 addresses\n"); 2190 return; 2191 } 2192 pl->peeraddr6 = 2193 SOCK_ADDR6(&pcmd->argval[qitems].netnum); 2194 pl->v6_flag = 1; 2195 } 2196 pl = (struct conf_unpeer *)((char *)pl + sendsize); 2197 } 2198 2199 res = doquery(impl_ver, REQ_RESET_PEER, 1, qitems, 2200 sendsize, (char *)plist, &items, 2201 &itemsize, &dummy, 0, sizeof(struct conf_unpeer)); 2202 2203 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2204 impl_ver = IMPL_XNTPD_OLD; 2205 goto again; 2206 } 2207 2208 if (res == 0) 2209 (void) fprintf(fp, "done!\n"); 2210} 2211 2212 2213/* 2214 * readkeys - request the server to reread the keys file 2215 */ 2216/*ARGSUSED*/ 2217static void 2218readkeys( 2219 struct parse *pcmd, 2220 FILE *fp 2221 ) 2222{ 2223 int items; 2224 int itemsize; 2225 char *dummy; 2226 int res; 2227 2228again: 2229 res = doquery(impl_ver, REQ_REREAD_KEYS, 1, 0, 0, (char *)0, 2230 &items, &itemsize, &dummy, 0, sizeof(dummy)); 2231 2232 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2233 impl_ver = IMPL_XNTPD_OLD; 2234 goto again; 2235 } 2236 2237 if (res == 0) 2238 (void) fprintf(fp, "done!\n"); 2239 return; 2240} 2241 2242 2243/* 2244 * trustkey - add some keys to the trusted key list 2245 */ 2246static void 2247trustkey( 2248 struct parse *pcmd, 2249 FILE *fp 2250 ) 2251{ 2252 do_trustkey(pcmd, fp, REQ_TRUSTKEY); 2253} 2254 2255 2256/* 2257 * untrustkey - remove some keys from the trusted key list 2258 */ 2259static void 2260untrustkey( 2261 struct parse *pcmd, 2262 FILE *fp 2263 ) 2264{ 2265 do_trustkey(pcmd, fp, REQ_UNTRUSTKEY); 2266} 2267 2268 2269/* 2270 * do_trustkey - do grunge work of adding/deleting keys 2271 */ 2272static void 2273do_trustkey( 2274 struct parse *pcmd, 2275 FILE *fp, 2276 int req 2277 ) 2278{ 2279 u_long keyids[MAXARGS]; 2280 int i; 2281 int items; 2282 int itemsize; 2283 char *dummy; 2284 int ritems; 2285 int res; 2286 2287 ritems = 0; 2288 for (i = 0; i < pcmd->nargs; i++) { 2289 keyids[ritems++] = pcmd->argval[i].uval; 2290 } 2291 2292again: 2293 res = doquery(impl_ver, req, 1, ritems, sizeof(u_long), 2294 (char *)keyids, &items, &itemsize, &dummy, 0, 2295 sizeof(dummy)); 2296 2297 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2298 impl_ver = IMPL_XNTPD_OLD; 2299 goto again; 2300 } 2301 2302 if (res == 0) 2303 (void) fprintf(fp, "done!\n"); 2304 return; 2305} 2306 2307 2308 2309/* 2310 * authinfo - obtain and print info about authentication 2311 */ 2312/*ARGSUSED*/ 2313static void 2314authinfo( 2315 struct parse *pcmd, 2316 FILE *fp 2317 ) 2318{ 2319 struct info_auth *ia; 2320 int items; 2321 int itemsize; 2322 int res; 2323 2324again: 2325 res = doquery(impl_ver, REQ_AUTHINFO, 0, 0, 0, (char *)NULL, 2326 &items, &itemsize, (void *)&ia, 0, 2327 sizeof(struct info_auth)); 2328 2329 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2330 impl_ver = IMPL_XNTPD_OLD; 2331 goto again; 2332 } 2333 2334 if (res != 0) 2335 return; 2336 2337 if (!check1item(items, fp)) 2338 return; 2339 2340 if (!checkitemsize(itemsize, sizeof(struct info_auth))) 2341 return; 2342 2343 (void) fprintf(fp, "time since reset: %ld\n", 2344 (u_long)ntohl(ia->timereset)); 2345 (void) fprintf(fp, "stored keys: %ld\n", 2346 (u_long)ntohl(ia->numkeys)); 2347 (void) fprintf(fp, "free keys: %ld\n", 2348 (u_long)ntohl(ia->numfreekeys)); 2349 (void) fprintf(fp, "key lookups: %ld\n", 2350 (u_long)ntohl(ia->keylookups)); 2351 (void) fprintf(fp, "keys not found: %ld\n", 2352 (u_long)ntohl(ia->keynotfound)); 2353 (void) fprintf(fp, "uncached keys: %ld\n", 2354 (u_long)ntohl(ia->keyuncached)); 2355 (void) fprintf(fp, "encryptions: %ld\n", 2356 (u_long)ntohl(ia->encryptions)); 2357 (void) fprintf(fp, "decryptions: %ld\n", 2358 (u_long)ntohl(ia->decryptions)); 2359 (void) fprintf(fp, "expired keys: %ld\n", 2360 (u_long)ntohl(ia->expired)); 2361} 2362 2363 2364 2365/* 2366 * traps - obtain and print a list of traps 2367 */ 2368/*ARGSUSED*/ 2369static void 2370traps( 2371 struct parse *pcmd, 2372 FILE *fp 2373 ) 2374{ 2375 int i; 2376 struct info_trap *it; 2377 sockaddr_u trap_addr, local_addr; 2378 int items; 2379 int itemsize; 2380 int res; 2381 2382again: 2383 res = doquery(impl_ver, REQ_TRAPS, 0, 0, 0, (char *)NULL, 2384 &items, &itemsize, (void *)&it, 0, 2385 sizeof(struct info_trap)); 2386 2387 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2388 impl_ver = IMPL_XNTPD_OLD; 2389 goto again; 2390 } 2391 2392 if (res != 0) 2393 return; 2394 2395 if (!checkitems(items, fp)) 2396 return; 2397 2398 if (!checkitemsize(itemsize, sizeof(struct info_trap)) && 2399 !checkitemsize(itemsize, v4sizeof(struct info_trap))) 2400 return; 2401 2402 for (i = 0; i < items; i++ ) { 2403 if (i != 0) 2404 (void) fprintf(fp, "\n"); 2405 SET_ADDRS(trap_addr, local_addr, it, trap_address, local_address); 2406 (void) fprintf(fp, "address %s, port %d\n", 2407 stoa(&trap_addr), 2408 ntohs(it->trap_port)); 2409 (void) fprintf(fp, "interface: %s, ", 2410 (it->local_address == 0) 2411 ? "wildcard" 2412 : stoa(&local_addr)); 2413 if (ntohl(it->flags) & TRAP_CONFIGURED) 2414 (void) fprintf(fp, "configured\n"); 2415 else if (ntohl(it->flags) & TRAP_NONPRIO) 2416 (void) fprintf(fp, "low priority\n"); 2417 else 2418 (void) fprintf(fp, "normal priority\n"); 2419 2420 (void) fprintf(fp, "set for %ld secs, last set %ld secs ago\n", 2421 (long)ntohl(it->origtime), 2422 (long)ntohl(it->settime)); 2423 (void) fprintf(fp, "sequence %d, number of resets %ld\n", 2424 ntohs(it->sequence), 2425 (long)ntohl(it->resets)); 2426 } 2427} 2428 2429 2430/* 2431 * addtrap - configure a trap 2432 */ 2433static void 2434addtrap( 2435 struct parse *pcmd, 2436 FILE *fp 2437 ) 2438{ 2439 do_addclr_trap(pcmd, fp, REQ_ADD_TRAP); 2440} 2441 2442 2443/* 2444 * clrtrap - clear a trap from the server 2445 */ 2446static void 2447clrtrap( 2448 struct parse *pcmd, 2449 FILE *fp 2450 ) 2451{ 2452 do_addclr_trap(pcmd, fp, REQ_CLR_TRAP); 2453} 2454 2455 2456/* 2457 * do_addclr_trap - do grunge work of adding/deleting traps 2458 */ 2459static void 2460do_addclr_trap( 2461 struct parse *pcmd, 2462 FILE *fp, 2463 int req 2464 ) 2465{ 2466 struct conf_trap ctrap; 2467 int items; 2468 int itemsize; 2469 char *dummy; 2470 int res; 2471 int sendsize; 2472 2473again: 2474 if (impl_ver == IMPL_XNTPD) 2475 sendsize = sizeof(struct conf_trap); 2476 else 2477 sendsize = v4sizeof(struct conf_trap); 2478 2479 if (IS_IPV4(&pcmd->argval[0].netnum)) { 2480 ctrap.trap_address = NSRCADR(&pcmd->argval[0].netnum); 2481 if (impl_ver == IMPL_XNTPD) 2482 ctrap.v6_flag = 0; 2483 } else { 2484 if (impl_ver == IMPL_XNTPD_OLD) { 2485 fprintf(stderr, 2486 "***Server doesn't understand IPv6 addresses\n"); 2487 return; 2488 } 2489 ctrap.trap_address6 = SOCK_ADDR6(&pcmd->argval[0].netnum); 2490 ctrap.v6_flag = 1; 2491 } 2492 ctrap.local_address = 0; 2493 ctrap.trap_port = htons(TRAPPORT); 2494 ctrap.unused = 0; 2495 2496 if (pcmd->nargs > 1) { 2497 ctrap.trap_port = htons((u_short)pcmd->argval[1].uval); 2498 if (pcmd->nargs > 2) { 2499 if (AF(&pcmd->argval[2].netnum) != 2500 AF(&pcmd->argval[0].netnum)) { 2501 fprintf(stderr, 2502 "***Cannot mix IPv4 and IPv6 addresses\n"); 2503 return; 2504 } 2505 if (IS_IPV4(&pcmd->argval[2].netnum)) 2506 ctrap.local_address = NSRCADR(&pcmd->argval[2].netnum); 2507 else 2508 ctrap.local_address6 = SOCK_ADDR6(&pcmd->argval[2].netnum); 2509 } 2510 } 2511 2512 res = doquery(impl_ver, req, 1, 1, sendsize, 2513 (char *)&ctrap, &items, &itemsize, &dummy, 0, 2514 sizeof(struct conf_trap)); 2515 2516 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2517 impl_ver = IMPL_XNTPD_OLD; 2518 goto again; 2519 } 2520 2521 if (res == 0) 2522 (void) fprintf(fp, "done!\n"); 2523 return; 2524} 2525 2526 2527 2528/* 2529 * requestkey - change the server's request key (a dangerous request) 2530 */ 2531static void 2532requestkey( 2533 struct parse *pcmd, 2534 FILE *fp 2535 ) 2536{ 2537 do_changekey(pcmd, fp, REQ_REQUEST_KEY); 2538} 2539 2540 2541/* 2542 * controlkey - change the server's control key 2543 */ 2544static void 2545controlkey( 2546 struct parse *pcmd, 2547 FILE *fp 2548 ) 2549{ 2550 do_changekey(pcmd, fp, REQ_CONTROL_KEY); 2551} 2552 2553 2554 2555/* 2556 * do_changekey - do grunge work of changing keys 2557 */ 2558static void 2559do_changekey( 2560 struct parse *pcmd, 2561 FILE *fp, 2562 int req 2563 ) 2564{ 2565 u_long key; 2566 int items; 2567 int itemsize; 2568 char *dummy; 2569 int res; 2570 2571 2572 key = htonl((u_int32)pcmd->argval[0].uval); 2573 2574again: 2575 res = doquery(impl_ver, req, 1, 1, sizeof(u_int32), 2576 (char *)&key, &items, &itemsize, &dummy, 0, 2577 sizeof(dummy)); 2578 2579 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2580 impl_ver = IMPL_XNTPD_OLD; 2581 goto again; 2582 } 2583 2584 if (res == 0) 2585 (void) fprintf(fp, "done!\n"); 2586 return; 2587} 2588 2589 2590 2591/* 2592 * ctlstats - obtain and print info about authentication 2593 */ 2594/*ARGSUSED*/ 2595static void 2596ctlstats( 2597 struct parse *pcmd, 2598 FILE *fp 2599 ) 2600{ 2601 struct info_control *ic; 2602 int items; 2603 int itemsize; 2604 int res; 2605 2606again: 2607 res = doquery(impl_ver, REQ_GET_CTLSTATS, 0, 0, 0, (char *)NULL, 2608 &items, &itemsize, (void *)&ic, 0, 2609 sizeof(struct info_control)); 2610 2611 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2612 impl_ver = IMPL_XNTPD_OLD; 2613 goto again; 2614 } 2615 2616 if (res != 0) 2617 return; 2618 2619 if (!check1item(items, fp)) 2620 return; 2621 2622 if (!checkitemsize(itemsize, sizeof(struct info_control))) 2623 return; 2624 2625 (void) fprintf(fp, "time since reset: %ld\n", 2626 (u_long)ntohl(ic->ctltimereset)); 2627 (void) fprintf(fp, "requests received: %ld\n", 2628 (u_long)ntohl(ic->numctlreq)); 2629 (void) fprintf(fp, "responses sent: %ld\n", 2630 (u_long)ntohl(ic->numctlresponses)); 2631 (void) fprintf(fp, "fragments sent: %ld\n", 2632 (u_long)ntohl(ic->numctlfrags)); 2633 (void) fprintf(fp, "async messages sent: %ld\n", 2634 (u_long)ntohl(ic->numasyncmsgs)); 2635 (void) fprintf(fp, "error msgs sent: %ld\n", 2636 (u_long)ntohl(ic->numctlerrors)); 2637 (void) fprintf(fp, "total bad pkts: %ld\n", 2638 (u_long)ntohl(ic->numctlbadpkts)); 2639 (void) fprintf(fp, "packet too short: %ld\n", 2640 (u_long)ntohl(ic->numctltooshort)); 2641 (void) fprintf(fp, "response on input: %ld\n", 2642 (u_long)ntohl(ic->numctlinputresp)); 2643 (void) fprintf(fp, "fragment on input: %ld\n", 2644 (u_long)ntohl(ic->numctlinputfrag)); 2645 (void) fprintf(fp, "error set on input: %ld\n", 2646 (u_long)ntohl(ic->numctlinputerr)); 2647 (void) fprintf(fp, "bad offset on input: %ld\n", 2648 (u_long)ntohl(ic->numctlbadoffset)); 2649 (void) fprintf(fp, "bad version packets: %ld\n", 2650 (u_long)ntohl(ic->numctlbadversion)); 2651 (void) fprintf(fp, "data in pkt too short: %ld\n", 2652 (u_long)ntohl(ic->numctldatatooshort)); 2653 (void) fprintf(fp, "unknown op codes: %ld\n", 2654 (u_long)ntohl(ic->numctlbadop)); 2655} 2656 2657 2658/* 2659 * clockstat - get and print clock status information 2660 */ 2661static void 2662clockstat( 2663 struct parse *pcmd, 2664 FILE *fp 2665 ) 2666{ 2667 struct info_clock *cl; 2668 /* 8 is the maximum number of clocks which will fit in a packet */ 2669 u_long clist[min(MAXARGS, 8)]; 2670 int qitemlim; 2671 int qitems; 2672 int items; 2673 int itemsize; 2674 int res; 2675 l_fp ts; 2676 struct clktype *clk; 2677 2678 qitemlim = min(pcmd->nargs, COUNTOF(clist)); 2679 for (qitems = 0; qitems < qitemlim; qitems++) 2680 clist[qitems] = NSRCADR(&pcmd->argval[qitems].netnum); 2681 2682again: 2683 res = doquery(impl_ver, REQ_GET_CLOCKINFO, 0, qitems, 2684 sizeof(u_int32), (char *)clist, &items, 2685 &itemsize, (void *)&cl, 0, sizeof(struct info_clock)); 2686 2687 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2688 impl_ver = IMPL_XNTPD_OLD; 2689 goto again; 2690 } 2691 2692 if (res != 0) 2693 return; 2694 2695 if (!checkitems(items, fp)) 2696 return; 2697 2698 if (!checkitemsize(itemsize, sizeof(struct info_clock))) 2699 return; 2700 2701 while (items-- > 0) { 2702 (void) fprintf(fp, "clock address: %s\n", 2703 numtoa(cl->clockadr)); 2704 for (clk = clktypes; clk->code >= 0; clk++) 2705 if (clk->code == cl->type) 2706 break; 2707 if (clk->code >= 0) 2708 (void) fprintf(fp, "clock type: %s\n", 2709 clk->clocktype); 2710 else 2711 (void) fprintf(fp, "clock type: unknown type (%d)\n", 2712 cl->type); 2713 (void) fprintf(fp, "last event: %d\n", 2714 cl->lastevent); 2715 (void) fprintf(fp, "current status: %d\n", 2716 cl->currentstatus); 2717 (void) fprintf(fp, "number of polls: %lu\n", 2718 (u_long)ntohl(cl->polls)); 2719 (void) fprintf(fp, "no response to poll: %lu\n", 2720 (u_long)ntohl(cl->noresponse)); 2721 (void) fprintf(fp, "bad format responses: %lu\n", 2722 (u_long)ntohl(cl->badformat)); 2723 (void) fprintf(fp, "bad data responses: %lu\n", 2724 (u_long)ntohl(cl->baddata)); 2725 (void) fprintf(fp, "running time: %lu\n", 2726 (u_long)ntohl(cl->timestarted)); 2727 NTOHL_FP(&cl->fudgetime1, &ts); 2728 (void) fprintf(fp, "fudge time 1: %s\n", 2729 lfptoa(&ts, 6)); 2730 NTOHL_FP(&cl->fudgetime2, &ts); 2731 (void) fprintf(fp, "fudge time 2: %s\n", 2732 lfptoa(&ts, 6)); 2733 (void) fprintf(fp, "stratum: %ld\n", 2734 (u_long)ntohl(cl->fudgeval1)); 2735 (void) fprintf(fp, "reference ID: %s\n", 2736 refid_string(ntohl(cl->fudgeval2), 0)); 2737 (void) fprintf(fp, "fudge flags: 0x%x\n", 2738 cl->flags); 2739 2740 if (items > 0) 2741 (void) fprintf(fp, "\n"); 2742 cl++; 2743 } 2744} 2745 2746 2747/* 2748 * fudge - set clock fudge factors 2749 */ 2750static void 2751fudge( 2752 struct parse *pcmd, 2753 FILE *fp 2754 ) 2755{ 2756 struct conf_fudge fudgedata; 2757 int items; 2758 int itemsize; 2759 char *dummy; 2760 l_fp ts; 2761 int res; 2762 long val; 2763 u_long u_val; 2764 int err; 2765 2766 2767 err = 0; 2768 memset((char *)&fudgedata, 0, sizeof fudgedata); 2769 fudgedata.clockadr = NSRCADR(&pcmd->argval[0].netnum); 2770 2771 if (STREQ(pcmd->argval[1].string, "time1")) { 2772 fudgedata.which = htonl(FUDGE_TIME1); 2773 if (!atolfp(pcmd->argval[2].string, &ts)) 2774 err = 1; 2775 else 2776 NTOHL_FP(&ts, &fudgedata.fudgetime); 2777 } else if (STREQ(pcmd->argval[1].string, "time2")) { 2778 fudgedata.which = htonl(FUDGE_TIME2); 2779 if (!atolfp(pcmd->argval[2].string, &ts)) 2780 err = 1; 2781 else 2782 NTOHL_FP(&ts, &fudgedata.fudgetime); 2783 } else if (STREQ(pcmd->argval[1].string, "val1")) { 2784 fudgedata.which = htonl(FUDGE_VAL1); 2785 if (!atoint(pcmd->argval[2].string, &val)) 2786 err = 1; 2787 else 2788 fudgedata.fudgeval_flags = htonl(val); 2789 } else if (STREQ(pcmd->argval[1].string, "val2")) { 2790 fudgedata.which = htonl(FUDGE_VAL2); 2791 if (!atoint(pcmd->argval[2].string, &val)) 2792 err = 1; 2793 else 2794 fudgedata.fudgeval_flags = htonl((u_int32)val); 2795 } else if (STREQ(pcmd->argval[1].string, "flags")) { 2796 fudgedata.which = htonl(FUDGE_FLAGS); 2797 if (!hextoint(pcmd->argval[2].string, &u_val)) 2798 err = 1; 2799 else 2800 fudgedata.fudgeval_flags = htonl((u_int32)(u_val & 0xf)); 2801 } else { 2802 (void) fprintf(stderr, "What fudge is %s?\n", 2803 pcmd->argval[1].string); 2804 return; 2805 } 2806 2807 if (err) { 2808 (void) fprintf(stderr, "Unknown fudge parameter %s\n", 2809 pcmd->argval[2].string); 2810 return; 2811 } 2812 2813again: 2814 res = doquery(impl_ver, REQ_SET_CLKFUDGE, 1, 1, 2815 sizeof(struct conf_fudge), (char *)&fudgedata, &items, 2816 &itemsize, &dummy, 0, sizeof(dummy)); 2817 2818 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2819 impl_ver = IMPL_XNTPD_OLD; 2820 goto again; 2821 } 2822 2823 if (res == 0) 2824 (void) fprintf(fp, "done!\n"); 2825 return; 2826} 2827 2828/* 2829 * clkbug - get and print clock debugging information 2830 */ 2831static void 2832clkbug( 2833 struct parse *pcmd, 2834 FILE *fp 2835 ) 2836{ 2837 register int i; 2838 register int n; 2839 register u_int32 s; 2840 struct info_clkbug *cl; 2841 /* 8 is the maximum number of clocks which will fit in a packet */ 2842 u_long clist[min(MAXARGS, 8)]; 2843 u_int32 ltemp; 2844 int qitemlim; 2845 int qitems; 2846 int items; 2847 int itemsize; 2848 int res; 2849 int needsp; 2850 l_fp ts; 2851 2852 qitemlim = min(pcmd->nargs, COUNTOF(clist)); 2853 for (qitems = 0; qitems < qitemlim; qitems++) 2854 clist[qitems] = NSRCADR(&pcmd->argval[qitems].netnum); 2855 2856again: 2857 res = doquery(impl_ver, REQ_GET_CLKBUGINFO, 0, qitems, 2858 sizeof(u_int32), (char *)clist, &items, 2859 &itemsize, (void *)&cl, 0, sizeof(struct info_clkbug)); 2860 2861 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2862 impl_ver = IMPL_XNTPD_OLD; 2863 goto again; 2864 } 2865 2866 if (res != 0) 2867 return; 2868 2869 if (!checkitems(items, fp)) 2870 return; 2871 2872 if (!checkitemsize(itemsize, sizeof(struct info_clkbug))) 2873 return; 2874 2875 while (items-- > 0) { 2876 (void) fprintf(fp, "clock address: %s\n", 2877 numtoa(cl->clockadr)); 2878 n = (int)cl->nvalues; 2879 (void) fprintf(fp, "values: %d", n); 2880 s = ntohs(cl->svalues); 2881 if (n > NUMCBUGVALUES) 2882 n = NUMCBUGVALUES; 2883 for (i = 0; i < n; i++) { 2884 ltemp = ntohl(cl->values[i]); 2885 ltemp &= 0xffffffff; /* HMS: This does nothing now */ 2886 if ((i & 0x3) == 0) 2887 (void) fprintf(fp, "\n"); 2888 if (s & (1 << i)) 2889 (void) fprintf(fp, "%12ld", (u_long)ltemp); 2890 else 2891 (void) fprintf(fp, "%12lu", (u_long)ltemp); 2892 } 2893 (void) fprintf(fp, "\n"); 2894 2895 n = (int)cl->ntimes; 2896 (void) fprintf(fp, "times: %d", n); 2897 s = ntohl(cl->stimes); 2898 if (n > NUMCBUGTIMES) 2899 n = NUMCBUGTIMES; 2900 needsp = 0; 2901 for (i = 0; i < n; i++) { 2902 if ((i & 0x1) == 0) { 2903 (void) fprintf(fp, "\n"); 2904 } else { 2905 for (;needsp > 0; needsp--) 2906 putc(' ', fp); 2907 } 2908 NTOHL_FP(&cl->times[i], &ts); 2909 if (s & (1 << i)) { 2910 (void) fprintf(fp, "%17s", 2911 lfptoa(&ts, 6)); 2912 needsp = 22; 2913 } else { 2914 (void) fprintf(fp, "%37s", 2915 uglydate(&ts)); 2916 needsp = 2; 2917 } 2918 } 2919 (void) fprintf(fp, "\n"); 2920 if (items > 0) { 2921 cl++; 2922 (void) fprintf(fp, "\n"); 2923 } 2924 } 2925} 2926 2927 2928/* 2929 * kerninfo - display the kernel pll/pps variables 2930 */ 2931static void 2932kerninfo( 2933 struct parse *pcmd, 2934 FILE *fp 2935 ) 2936{ 2937 struct info_kernel *ik; 2938 int items; 2939 int itemsize; 2940 int res; 2941 unsigned status; 2942 double tscale = 1e-6; 2943 2944again: 2945 res = doquery(impl_ver, REQ_GET_KERNEL, 0, 0, 0, (char *)NULL, 2946 &items, &itemsize, (void *)&ik, 0, 2947 sizeof(struct info_kernel)); 2948 2949 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) { 2950 impl_ver = IMPL_XNTPD_OLD; 2951 goto again; 2952 } 2953 2954 if (res != 0) 2955 return; 2956 if (!check1item(items, fp)) 2957 return; 2958 if (!checkitemsize(itemsize, sizeof(struct info_kernel))) 2959 return; 2960 2961 status = ntohs(ik->status) & 0xffff; 2962 /* 2963 * pll variables. We know more than we should about the NANO bit. 2964 */ 2965#ifdef STA_NANO 2966 if (status & STA_NANO) 2967 tscale = 1e-9; 2968#endif 2969 (void)fprintf(fp, "pll offset: %g s\n", 2970 (int32)ntohl(ik->offset) * tscale); 2971 (void)fprintf(fp, "pll frequency: %s ppm\n", 2972 fptoa((s_fp)ntohl(ik->freq), 3)); 2973 (void)fprintf(fp, "maximum error: %g s\n", 2974 (u_long)ntohl(ik->maxerror) * 1e-6); 2975 (void)fprintf(fp, "estimated error: %g s\n", 2976 (u_long)ntohl(ik->esterror) * 1e-6); 2977 (void)fprintf(fp, "status: %04x ", status); 2978#ifdef STA_PLL 2979 if (status & STA_PLL) (void)fprintf(fp, " pll"); 2980#endif 2981#ifdef STA_PPSFREQ 2982 if (status & STA_PPSFREQ) (void)fprintf(fp, " ppsfreq"); 2983#endif 2984#ifdef STA_PPSTIME 2985 if (status & STA_PPSTIME) (void)fprintf(fp, " ppstime"); 2986#endif 2987#ifdef STA_FLL 2988 if (status & STA_FLL) (void)fprintf(fp, " fll"); 2989#endif 2990#ifdef STA_INS 2991 if (status & STA_INS) (void)fprintf(fp, " ins"); 2992#endif 2993#ifdef STA_DEL 2994 if (status & STA_DEL) (void)fprintf(fp, " del"); 2995#endif 2996#ifdef STA_UNSYNC 2997 if (status & STA_UNSYNC) (void)fprintf(fp, " unsync"); 2998#endif 2999#ifdef STA_FREQHOLD 3000 if (status & STA_FREQHOLD) (void)fprintf(fp, " freqhold"); 3001#endif 3002#ifdef STA_PPSSIGNAL 3003 if (status & STA_PPSSIGNAL) (void)fprintf(fp, " ppssignal"); 3004#endif 3005#ifdef STA_PPSJITTER 3006 if (status & STA_PPSJITTER) (void)fprintf(fp, " ppsjitter"); 3007#endif 3008#ifdef STA_PPSWANDER 3009 if (status & STA_PPSWANDER) (void)fprintf(fp, " ppswander"); 3010#endif 3011#ifdef STA_PPSERROR 3012 if (status & STA_PPSERROR) (void)fprintf(fp, " ppserror"); 3013#endif 3014#ifdef STA_CLOCKERR 3015 if (status & STA_CLOCKERR) (void)fprintf(fp, " clockerr"); 3016#endif 3017#ifdef STA_NANO 3018 if (status & STA_NANO) (void)fprintf(fp, " nano"); 3019#endif 3020#ifdef STA_MODE 3021 if (status & STA_MODE) (void)fprintf(fp, " mode=fll"); 3022#endif 3023#ifdef STA_CLK 3024 if (status & STA_CLK) (void)fprintf(fp, " src=B"); 3025#endif 3026 (void)fprintf(fp, "\n"); 3027 (void)fprintf(fp, "pll time constant: %ld\n", 3028 (u_long)ntohl(ik->constant)); 3029 (void)fprintf(fp, "precision: %g s\n", 3030 (u_long)ntohl(ik->precision) * tscale); 3031 (void)fprintf(fp, "frequency tolerance: %s ppm\n", 3032 fptoa((s_fp)ntohl(ik->tolerance), 0)); 3033 3034 /* 3035 * For backwards compatibility (ugh), we find the pps variables 3036 * only if the shift member is nonzero. 3037 */ 3038 if (!ik->shift) 3039 return; 3040 3041 /* 3042 * pps variables 3043 */ 3044 (void)fprintf(fp, "pps frequency: %s ppm\n", 3045 fptoa((s_fp)ntohl(ik->ppsfreq), 3)); 3046 (void)fprintf(fp, "pps stability: %s ppm\n", 3047 fptoa((s_fp)ntohl(ik->stabil), 3)); 3048 (void)fprintf(fp, "pps jitter: %g s\n", 3049 (u_long)ntohl(ik->jitter) * tscale); 3050 (void)fprintf(fp, "calibration interval: %d s\n", 3051 1 << ntohs(ik->shift)); 3052 (void)fprintf(fp, "calibration cycles: %ld\n", 3053 (u_long)ntohl(ik->calcnt)); 3054 (void)fprintf(fp, "jitter exceeded: %ld\n", 3055 (u_long)ntohl(ik->jitcnt)); 3056 (void)fprintf(fp, "stability exceeded: %ld\n", 3057 (u_long)ntohl(ik->stbcnt)); 3058 (void)fprintf(fp, "calibration errors: %ld\n", 3059 (u_long)ntohl(ik->errcnt)); 3060} 3061 3062#define IF_LIST_FMT "%2d %c %48s %c %c %12.12s %03x %3d %2d %5d %5d %5d %2d %3d %7d\n" 3063#define IF_LIST_FMT_STR "%2s %c %48s %c %c %12.12s %3s %3s %2s %5s %5s %5s %2s %3s %7s\n" 3064#define IF_LIST_AFMT_STR " %48s %c\n" 3065#define IF_LIST_LABELS "#", 'A', "Address/Mask/Broadcast", 'T', 'E', "IF name", "Flg", "TL", "#M", "recv", "sent", "drop", "S", "PC", "uptime" 3066#define IF_LIST_LINE "==================================================================================================================\n" 3067 3068static void 3069iflist( 3070 FILE *fp, 3071 struct info_if_stats *ifs, 3072 int items, 3073 int itemsize, 3074 int res 3075 ) 3076{ 3077 static char *actions = "?.+-"; 3078 sockaddr_u saddr; 3079 3080 if (res != 0) 3081 return; 3082 3083 if (!checkitems(items, fp)) 3084 return; 3085 3086 if (!checkitemsize(itemsize, sizeof(struct info_if_stats))) 3087 return; 3088 3089 fprintf(fp, IF_LIST_FMT_STR, IF_LIST_LABELS); 3090 fprintf(fp, IF_LIST_LINE); 3091 3092 while (items > 0) { 3093 SET_ADDR(saddr, ntohl(ifs->v6_flag), 3094 ifs->unaddr.addr.s_addr, ifs->unaddr.addr6); 3095 fprintf(fp, IF_LIST_FMT, 3096 ntohl(ifs->ifnum), 3097 actions[(ifs->action >= 1 && ifs->action < 4) ? ifs->action : 0], 3098 stoa((&saddr)), 'A', 3099 ifs->ignore_packets ? 'D' : 'E', 3100 ifs->name, 3101 ntohl(ifs->flags), 3102 ntohl(ifs->last_ttl), 3103 ntohl(ifs->num_mcast), 3104 ntohl(ifs->received), 3105 ntohl(ifs->sent), 3106 ntohl(ifs->notsent), 3107 ntohl(ifs->scopeid), 3108 ntohl(ifs->peercnt), 3109 ntohl(ifs->uptime)); 3110 3111 SET_ADDR(saddr, ntohl(ifs->v6_flag), 3112 ifs->unmask.addr.s_addr, ifs->unmask.addr6); 3113 fprintf(fp, IF_LIST_AFMT_STR, stoa(&saddr), 'M'); 3114 3115 if (!ntohl(ifs->v6_flag) && ntohl(ifs->flags) & (INT_BCASTOPEN)) { 3116 SET_ADDR(saddr, ntohl(ifs->v6_flag), 3117 ifs->unbcast.addr.s_addr, ifs->unbcast.addr6); 3118 fprintf(fp, IF_LIST_AFMT_STR, stoa(&saddr), 'B'); 3119 3120 } 3121 3122 ifs++; 3123 items--; 3124 } 3125} 3126 3127/*ARGSUSED*/ 3128static void 3129get_if_stats( 3130 struct parse *pcmd, 3131 FILE *fp 3132 ) 3133{ 3134 struct info_if_stats *ifs; 3135 int items; 3136 int itemsize; 3137 int res; 3138 3139 res = doquery(impl_ver, REQ_IF_STATS, 1, 0, 0, (char *)NULL, &items, 3140 &itemsize, (void *)&ifs, 0, 3141 sizeof(struct info_if_stats)); 3142 iflist(fp, ifs, items, itemsize, res); 3143} 3144 3145/*ARGSUSED*/ 3146static void 3147do_if_reload( 3148 struct parse *pcmd, 3149 FILE *fp 3150 ) 3151{ 3152 struct info_if_stats *ifs; 3153 int items; 3154 int itemsize; 3155 int res; 3156 3157 res = doquery(impl_ver, REQ_IF_RELOAD, 1, 0, 0, (char *)NULL, &items, 3158 &itemsize, (void *)&ifs, 0, 3159 sizeof(struct info_if_stats)); 3160 iflist(fp, ifs, items, itemsize, res); 3161} 3162