/contrib/ntp/ntpq/ntpq.c
C | 3293 lines | 2565 code | 297 blank | 431 comment | 550 complexity | 85cdcabf82d1b317a75154a79945a7bb MD5 | raw file
Large files files are truncated, but you can click here to view the full file
1/* 2 * ntpq - query an NTP server using mode 6 commands 3 */ 4 5#include <stdio.h> 6 7#include <ctype.h> 8#include <signal.h> 9#include <setjmp.h> 10#include <sys/types.h> 11#include <sys/time.h> 12 13#include "ntpq.h" 14#include "ntp_unixtime.h" 15#include "ntp_calendar.h" 16#include "ntp_io.h" 17#include "ntp_select.h" 18#include "ntp_stdlib.h" 19/* Don't include ISC's version of IPv6 variables and structures */ 20#define ISC_IPV6_H 1 21#include "isc/net.h" 22#include "isc/result.h" 23 24#include "ntpq-opts.h" 25 26#ifdef SYS_WINNT 27# include <Mswsock.h> 28# include <io.h> 29#else 30# define closesocket close 31#endif /* SYS_WINNT */ 32 33#if defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDIT) 34# include <readline/readline.h> 35# include <readline/history.h> 36#endif /* HAVE_LIBREADLINE || HAVE_LIBEDIT */ 37 38#ifdef SYS_VXWORKS 39 /* vxWorks needs mode flag -casey*/ 40# define open(name, flags) open(name, flags, 0777) 41# define SERVER_PORT_NUM 123 42#endif 43 44/* we use COMMAND as an autogen keyword */ 45#ifdef COMMAND 46# undef COMMAND 47#endif 48 49/* 50 * Because we potentially understand a lot of commands we will run 51 * interactive if connected to a terminal. 52 */ 53int interactive = 0; /* set to 1 when we should prompt */ 54const char *prompt = "ntpq> "; /* prompt to ask him about */ 55 56 57/* 58 * for get_systime() 59 */ 60s_char sys_precision; /* local clock precision (log2 s) */ 61 62/* 63 * Keyid used for authenticated requests. Obtained on the fly. 64 */ 65u_long info_auth_keyid = 0; 66 67/* 68 * Type of key md5 69 */ 70#define KEY_TYPE_MD5 4 71 72static int info_auth_keytype = KEY_TYPE_MD5; /* MD5 */ 73u_long current_time; /* needed by authkeys; not used */ 74 75/* 76 * Flag which indicates we should always send authenticated requests 77 */ 78int always_auth = 0; 79 80/* 81 * Flag which indicates raw mode output. 82 */ 83int rawmode = 0; 84 85/* 86 * Packet version number we use 87 */ 88u_char pktversion = NTP_OLDVERSION + 1; 89 90/* 91 * Don't jump if no set jmp. 92 */ 93volatile int jump = 0; 94 95/* 96 * Format values 97 */ 98#define PADDING 0 99#define TS 1 /* time stamp */ 100#define FL 2 /* l_fp type value */ 101#define FU 3 /* u_fp type value */ 102#define FS 4 /* s_fp type value */ 103#define UI 5 /* unsigned integer value */ 104#define SI 6 /* signed integer value */ 105#define HA 7 /* host address */ 106#define NA 8 /* network address */ 107#define ST 9 /* string value */ 108#define RF 10 /* refid (sometimes string, sometimes not) */ 109#define LP 11 /* leap (print in binary) */ 110#define OC 12 /* integer, print in octal */ 111#define MD 13 /* mode */ 112#define AR 14 /* array of times */ 113#define FX 15 /* test flags */ 114#define EOV 255 /* end of table */ 115 116 117/* 118 * System variable values. The array can be indexed by 119 * the variable index to find the textual name. 120 */ 121struct ctl_var sys_var[] = { 122 { 0, PADDING, "" }, /* 0 */ 123 { CS_LEAP, LP, "leap" }, /* 1 */ 124 { CS_STRATUM, UI, "stratum" }, /* 2 */ 125 { CS_PRECISION, SI, "precision" }, /* 3 */ 126 { CS_ROOTDELAY, FS, "rootdelay" }, /* 4 */ 127 { CS_ROOTDISPERSION, FU, "rootdispersion" }, /* 5 */ 128 { CS_REFID, RF, "refid" }, /* 6 */ 129 { CS_REFTIME, TS, "reftime" }, /* 7 */ 130 { CS_POLL, UI, "poll" }, /* 8 */ 131 { CS_PEERID, UI, "peer" }, /* 9 */ 132 { CS_STATE, UI, "state" }, /* 10 */ 133 { CS_OFFSET, FL, "offset" }, /* 11 */ 134 { CS_DRIFT, FS, "frequency" }, /* 12 */ 135 { CS_JITTER, FU, "jitter" }, /* 13 */ 136 { CS_CLOCK, TS, "clock" }, /* 14 */ 137 { CS_PROCESSOR, ST, "processor" }, /* 15 */ 138 { CS_SYSTEM, ST, "system" }, /* 16 */ 139 { CS_VERSION, ST, "version" }, /* 17 */ 140 { CS_STABIL, FS, "stability" }, /* 18 */ 141 { CS_VARLIST, ST, "sys_var_list" }, /* 19 */ 142 { 0, EOV, "" } 143}; 144 145 146/* 147 * Peer variable list 148 */ 149struct ctl_var peer_var[] = { 150 { 0, PADDING, "" }, /* 0 */ 151 { CP_CONFIG, UI, "config" }, /* 1 */ 152 { CP_AUTHENABLE, UI, "authenable" }, /* 2 */ 153 { CP_AUTHENTIC, UI, "authentic" }, /* 3 */ 154 { CP_SRCADR, HA, "srcadr" }, /* 4 */ 155 { CP_SRCPORT, UI, "srcport" }, /* 5 */ 156 { CP_DSTADR, NA, "dstadr" }, /* 6 */ 157 { CP_DSTPORT, UI, "dstport" }, /* 7 */ 158 { CP_LEAP, LP, "leap" }, /* 8 */ 159 { CP_HMODE, MD, "hmode" }, /* 9 */ 160 { CP_STRATUM, UI, "stratum" }, /* 10 */ 161 { CP_PPOLL, UI, "ppoll" }, /* 11 */ 162 { CP_HPOLL, UI, "hpoll" }, /* 12 */ 163 { CP_PRECISION, SI, "precision" }, /* 13 */ 164 { CP_ROOTDELAY, FS, "rootdelay" }, /* 14 */ 165 { CP_ROOTDISPERSION, FU, "rootdispersion" }, /* 15 */ 166 { CP_REFID, RF, "refid" }, /* 16 */ 167 { CP_REFTIME, TS, "reftime" }, /* 17 */ 168 { CP_ORG, TS, "org" }, /* 18 */ 169 { CP_REC, TS, "rec" }, /* 19 */ 170 { CP_XMT, TS, "xmt" }, /* 20 */ 171 { CP_REACH, OC, "reach" }, /* 21 */ 172 { CP_UNREACH, UI, "unreach" }, /* 22 */ 173 { CP_TIMER, UI, "timer" }, /* 23 */ 174 { CP_DELAY, FS, "delay" }, /* 24 */ 175 { CP_OFFSET, FL, "offset" }, /* 25 */ 176 { CP_JITTER, FU, "jitter" }, /* 26 */ 177 { CP_DISPERSION, FU, "dispersion" }, /* 27 */ 178 { CP_KEYID, UI, "keyid" }, /* 28 */ 179 { CP_FILTDELAY, AR, "filtdelay" }, /* 29 */ 180 { CP_FILTOFFSET, AR, "filtoffset" }, /* 30 */ 181 { CP_PMODE, ST, "pmode" }, /* 31 */ 182 { CP_RECEIVED, UI, "received" }, /* 32 */ 183 { CP_SENT, UI, "sent" }, /* 33 */ 184 { CP_FILTERROR, AR, "filtdisp" }, /* 34 */ 185 { CP_FLASH, FX, "flash" }, /* 35 */ 186 { CP_TTL, UI, "ttl" }, /* 36 */ 187 /* 188 * These are duplicate entries so that we can 189 * process deviant version of the ntp protocol. 190 */ 191 { CP_SRCADR, HA, "peeraddr" }, /* 4 */ 192 { CP_SRCPORT, UI, "peerport" }, /* 5 */ 193 { CP_PPOLL, UI, "peerpoll" }, /* 11 */ 194 { CP_HPOLL, UI, "hostpoll" }, /* 12 */ 195 { CP_FILTERROR, AR, "filterror" }, /* 34 */ 196 { 0, EOV, "" } 197}; 198 199 200/* 201 * Clock variable list 202 */ 203struct ctl_var clock_var[] = { 204 { 0, PADDING, "" }, /* 0 */ 205 { CC_TYPE, UI, "type" }, /* 1 */ 206 { CC_TIMECODE, ST, "timecode" }, /* 2 */ 207 { CC_POLL, UI, "poll" }, /* 3 */ 208 { CC_NOREPLY, UI, "noreply" }, /* 4 */ 209 { CC_BADFORMAT, UI, "badformat" }, /* 5 */ 210 { CC_BADDATA, UI, "baddata" }, /* 6 */ 211 { CC_FUDGETIME1, FL, "fudgetime1" }, /* 7 */ 212 { CC_FUDGETIME2, FL, "fudgetime2" }, /* 8 */ 213 { CC_FUDGEVAL1, UI, "stratum" }, /* 9 */ 214 { CC_FUDGEVAL2, RF, "refid" }, /* 10 */ 215 { CC_FLAGS, UI, "flags" }, /* 11 */ 216 { CC_DEVICE, ST, "device" }, /* 12 */ 217 { 0, EOV, "" } 218}; 219 220 221/* 222 * flasher bits 223 */ 224static const char *tstflagnames[] = { 225 "pkt_dup", /* TEST1 */ 226 "pkt_bogus", /* TEST2 */ 227 "pkt_proto", /* TEST3 */ 228 "pkt_denied", /* TEST4 */ 229 "pkt_auth", /* TEST5 */ 230 "pkt_synch", /* TEST6 */ 231 "pkt_dist", /* TEST7 */ 232 "pkt_autokey", /* TEST8 */ 233 "pkt_crypto", /* TEST9 */ 234 "peer_stratum", /* TEST10 */ 235 "peer_dist", /* TEST11 */ 236 "peer_loop", /* TEST12 */ 237 "peer_unfit" /* TEST13 */ 238}; 239 240 241int ntpqmain P((int, char **)); 242/* 243 * Built in command handler declarations 244 */ 245static int openhost P((const char *)); 246static int sendpkt P((char *, int)); 247static int getresponse P((int, int, u_short *, int *, char **, int)); 248static int sendrequest P((int, int, int, int, char *)); 249static char * tstflags P((u_long)); 250static void getcmds P((void)); 251static RETSIGTYPE abortcmd P((int)); 252static void docmd P((const char *)); 253static void tokenize P((const char *, char **, int *)); 254static int findcmd P((char *, struct xcmd *, struct xcmd *, struct xcmd **)); 255static int getarg P((char *, int, arg_v *)); 256static int rtdatetolfp P((char *, l_fp *)); 257static int decodearr P((char *, int *, l_fp *)); 258static void help P((struct parse *, FILE *)); 259#ifdef QSORT_USES_VOID_P 260static int helpsort P((const void *, const void *)); 261#else 262static int helpsort P((char **, char **)); 263#endif 264static void printusage P((struct xcmd *, FILE *)); 265static void timeout P((struct parse *, FILE *)); 266static void auth_delay P((struct parse *, FILE *)); 267static void host P((struct parse *, FILE *)); 268static void ntp_poll P((struct parse *, FILE *)); 269static void keyid P((struct parse *, FILE *)); 270static void keytype P((struct parse *, FILE *)); 271static void passwd P((struct parse *, FILE *)); 272static void hostnames P((struct parse *, FILE *)); 273static void setdebug P((struct parse *, FILE *)); 274static void quit P((struct parse *, FILE *)); 275static void version P((struct parse *, FILE *)); 276static void raw P((struct parse *, FILE *)); 277static void cooked P((struct parse *, FILE *)); 278static void authenticate P((struct parse *, FILE *)); 279static void ntpversion P((struct parse *, FILE *)); 280static void warning P((const char *, const char *, const char *)); 281static void error P((const char *, const char *, const char *)); 282static u_long getkeyid P((const char *)); 283static void atoascii P((int, char *, char *)); 284static void makeascii P((int, char *, FILE *)); 285static void rawprint P((int, int, char *, int, FILE *)); 286static void startoutput P((void)); 287static void output P((FILE *, char *, char *)); 288static void endoutput P((FILE *)); 289static void outputarr P((FILE *, char *, int, l_fp *)); 290static void cookedprint P((int, int, char *, int, FILE *)); 291#ifdef QSORT_USES_VOID_P 292static int assoccmp P((const void *, const void *)); 293#else 294static int assoccmp P((struct association *, struct association *)); 295#endif /* sgi || bsdi */ 296 297 298/* 299 * Built-in commands we understand 300 */ 301struct xcmd builtins[] = { 302 { "?", help, { OPT|NTP_STR, NO, NO, NO }, 303 { "command", "", "", "" }, 304 "tell the use and syntax of commands" }, 305 { "help", help, { OPT|NTP_STR, NO, NO, NO }, 306 { "command", "", "", "" }, 307 "tell the use and syntax of commands" }, 308 { "timeout", timeout, { OPT|NTP_UINT, NO, NO, NO }, 309 { "msec", "", "", "" }, 310 "set the primary receive time out" }, 311 { "delay", auth_delay, { OPT|NTP_INT, NO, NO, NO }, 312 { "msec", "", "", "" }, 313 "set the delay added to encryption time stamps" }, 314 { "host", host, { OPT|NTP_STR, OPT|NTP_STR, NO, NO }, 315 { "-4|-6", "hostname", "", "" }, 316 "specify the host whose NTP server we talk to" }, 317 { "poll", ntp_poll, { OPT|NTP_UINT, OPT|NTP_STR, NO, NO }, 318 { "n", "verbose", "", "" }, 319 "poll an NTP server in client mode `n' times" }, 320 { "passwd", passwd, { NO, NO, NO, NO }, 321 { "", "", "", "" }, 322 "specify a password to use for authenticated requests"}, 323 { "hostnames", hostnames, { OPT|NTP_STR, NO, NO, NO }, 324 { "yes|no", "", "", "" }, 325 "specify whether hostnames or net numbers are printed"}, 326 { "debug", setdebug, { OPT|NTP_STR, NO, NO, NO }, 327 { "no|more|less", "", "", "" }, 328 "set/change debugging level" }, 329 { "quit", quit, { NO, NO, NO, NO }, 330 { "", "", "", "" }, 331 "exit ntpq" }, 332 { "exit", quit, { NO, NO, NO, NO }, 333 { "", "", "", "" }, 334 "exit ntpq" }, 335 { "keyid", keyid, { OPT|NTP_UINT, NO, NO, NO }, 336 { "key#", "", "", "" }, 337 "set keyid to use for authenticated requests" }, 338 { "version", version, { NO, NO, NO, NO }, 339 { "", "", "", "" }, 340 "print version number" }, 341 { "raw", raw, { NO, NO, NO, NO }, 342 { "", "", "", "" }, 343 "do raw mode variable output" }, 344 { "cooked", cooked, { NO, NO, NO, NO }, 345 { "", "", "", "" }, 346 "do cooked mode variable output" }, 347 { "authenticate", authenticate, { OPT|NTP_STR, NO, NO, NO }, 348 { "yes|no", "", "", "" }, 349 "always authenticate requests to this server" }, 350 { "ntpversion", ntpversion, { OPT|NTP_UINT, NO, NO, NO }, 351 { "version number", "", "", "" }, 352 "set the NTP version number to use for requests" }, 353 { "keytype", keytype, { OPT|NTP_STR, NO, NO, NO }, 354 { "key type (md5|des)", "", "", "" }, 355 "set key type to use for authenticated requests (des|md5)" }, 356 { 0, 0, { NO, NO, NO, NO }, 357 { "", "", "", "" }, "" } 358}; 359 360 361/* 362 * Default values we use. 363 */ 364#define DEFTIMEOUT (5) /* 5 second time out */ 365#define DEFSTIMEOUT (2) /* 2 second time out after first */ 366#define DEFDELAY 0x51EB852 /* 20 milliseconds, l_fp fraction */ 367#define DEFHOST "localhost" /* default host name */ 368#define LENHOSTNAME 256 /* host name is 256 characters long */ 369#define MAXCMDS 100 /* maximum commands on cmd line */ 370#define MAXHOSTS 200 /* maximum hosts on cmd line */ 371#define MAXLINE 512 /* maximum line length */ 372#define MAXTOKENS (1+MAXARGS+2) /* maximum number of usable tokens */ 373#define MAXVARLEN 256 /* maximum length of a variable name */ 374#define MAXVALLEN 400 /* maximum length of a variable value */ 375#define MAXOUTLINE 72 /* maximum length of an output line */ 376#define SCREENWIDTH 76 /* nominal screen width in columns */ 377 378/* 379 * Some variables used and manipulated locally 380 */ 381struct timeval tvout = { DEFTIMEOUT, 0 }; /* time out for reads */ 382struct timeval tvsout = { DEFSTIMEOUT, 0 }; /* secondary time out */ 383l_fp delay_time; /* delay time */ 384char currenthost[LENHOSTNAME]; /* current host name */ 385struct sockaddr_in hostaddr = { 0 }; /* host address */ 386int showhostnames = 1; /* show host names by default */ 387 388int ai_fam_templ; /* address family */ 389int ai_fam_default; /* default address family */ 390SOCKET sockfd; /* fd socket is opened on */ 391int havehost = 0; /* set to 1 when host open */ 392int s_port = 0; 393struct servent *server_entry = NULL; /* server entry for ntp */ 394 395#ifdef SYS_WINNT 396DWORD NumberOfBytesWritten; 397 398HANDLE TimerThreadHandle = NULL; /* 1998/06/03 - Used in ntplib/machines.c */ 399void timer(void) { ; }; /* 1998/06/03 - Used in ntplib/machines.c */ 400 401#endif /* SYS_WINNT */ 402 403/* 404 * Sequence number used for requests. It is incremented before 405 * it is used. 406 */ 407u_short sequence; 408 409/* 410 * Holds data returned from queries. Declare buffer long to be sure of 411 * alignment. 412 */ 413#define MAXFRAGS 24 /* maximum number of fragments */ 414#define DATASIZE (MAXFRAGS*480) /* maximum amount of data */ 415long pktdata[DATASIZE/sizeof(long)]; 416 417/* 418 * Holds association data for use with the &n operator. 419 */ 420struct association assoc_cache[MAXASSOC]; 421int numassoc = 0; /* number of cached associations */ 422 423/* 424 * For commands typed on the command line (with the -c option) 425 */ 426int numcmds = 0; 427const char *ccmds[MAXCMDS]; 428#define ADDCMD(cp) if (numcmds < MAXCMDS) ccmds[numcmds++] = (cp) 429 430/* 431 * When multiple hosts are specified. 432 */ 433int numhosts = 0; 434const char *chosts[MAXHOSTS]; 435#define ADDHOST(cp) if (numhosts < MAXHOSTS) chosts[numhosts++] = (cp) 436 437/* 438 * Error codes for internal use 439 */ 440#define ERR_UNSPEC 256 441#define ERR_INCOMPLETE 257 442#define ERR_TIMEOUT 258 443#define ERR_TOOMUCH 259 444 445/* 446 * Macro definitions we use 447 */ 448#define ISSPACE(c) ((c) == ' ' || (c) == '\t') 449#define ISEOL(c) ((c) == '\n' || (c) == '\r' || (c) == '\0') 450#define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0) 451 452/* 453 * Jump buffer for longjumping back to the command level 454 */ 455jmp_buf interrupt_buf; 456 457/* 458 * Points at file being currently printed into 459 */ 460FILE *current_output; 461 462/* 463 * Command table imported from ntpdc_ops.c 464 */ 465extern struct xcmd opcmds[]; 466 467char *progname; 468volatile int debug; 469 470#ifdef NO_MAIN_ALLOWED 471CALL(ntpq,"ntpq",ntpqmain); 472 473void clear_globals(void) 474{ 475 extern int ntp_optind; 476 showhostnames = 0; /* don'tshow host names by default */ 477 ntp_optind = 0; 478 server_entry = NULL; /* server entry for ntp */ 479 havehost = 0; /* set to 1 when host open */ 480 numassoc = 0; /* number of cached associations */ 481 numcmds = 0; 482 numhosts = 0; 483} 484#endif 485 486/* 487 * main - parse arguments and handle options 488 */ 489#ifndef NO_MAIN_ALLOWED 490int 491main( 492 int argc, 493 char *argv[] 494 ) 495{ 496 return ntpqmain(argc, argv); 497} 498#endif 499 500int 501ntpqmain( 502 int argc, 503 char *argv[] 504 ) 505{ 506 extern int ntp_optind; 507 508#ifdef SYS_VXWORKS 509 clear_globals(); 510 taskPrioritySet(taskIdSelf(), 100 ); 511#endif 512 513 delay_time.l_ui = 0; 514 delay_time.l_uf = DEFDELAY; 515 516#ifdef SYS_WINNT 517 if (!Win32InitSockets()) 518 { 519 fprintf(stderr, "No useable winsock.dll:"); 520 exit(1); 521 } 522#endif /* SYS_WINNT */ 523 524 /* Check to see if we have IPv6. Otherwise force the -4 flag */ 525 if (isc_net_probeipv6() != ISC_R_SUCCESS) { 526 ai_fam_default = AF_INET; 527 } 528 529 progname = argv[0]; 530 531 { 532 int optct = optionProcess(&ntpqOptions, argc, argv); 533 argc -= optct; 534 argv += optct; 535 } 536 537 switch (WHICH_IDX_IPV4) { 538 case INDEX_OPT_IPV4: 539 ai_fam_templ = AF_INET; 540 break; 541 case INDEX_OPT_IPV6: 542 ai_fam_templ = AF_INET6; 543 break; 544 default: 545 ai_fam_templ = ai_fam_default; 546 break; 547 } 548 549 if (HAVE_OPT(COMMAND)) { 550 int cmdct = STACKCT_OPT( COMMAND ); 551 const char** cmds = STACKLST_OPT( COMMAND ); 552 553 while (cmdct-- > 0) { 554 ADDCMD(*cmds++); 555 } 556 } 557 558 debug = DESC(DEBUG_LEVEL).optOccCt; 559 560 if (HAVE_OPT(INTERACTIVE)) { 561 interactive = 1; 562 } 563 564 if (HAVE_OPT(NUMERIC)) { 565 showhostnames = 0; 566 } 567 568 if (HAVE_OPT(PEERS)) { 569 ADDCMD("peers"); 570 } 571 572#if 0 573 while ((c = ntp_getopt(argc, argv, "46c:dinp")) != EOF) 574 switch (c) { 575 case '4': 576 ai_fam_templ = AF_INET; 577 break; 578 case '6': 579 ai_fam_templ = AF_INET6; 580 break; 581 case 'c': 582 ADDCMD(ntp_optarg); 583 break; 584 case 'd': 585 ++debug; 586 break; 587 case 'i': 588 interactive = 1; 589 break; 590 case 'n': 591 showhostnames = 0; 592 break; 593 case 'p': 594 ADDCMD("peers"); 595 break; 596 default: 597 errflg++; 598 break; 599 } 600 if (errflg) { 601 (void) fprintf(stderr, 602 "usage: %s [-46dinp] [-c cmd] host ...\n", 603 progname); 604 exit(2); 605 } 606#endif 607 if (ntp_optind == argc) { 608 ADDHOST(DEFHOST); 609 } else { 610 for (; ntp_optind < argc; ntp_optind++) 611 ADDHOST(argv[ntp_optind]); 612 } 613 614 if (numcmds == 0 && interactive == 0 615 && isatty(fileno(stdin)) && isatty(fileno(stderr))) { 616 interactive = 1; 617 } 618 619#ifndef SYS_WINNT /* Under NT cannot handle SIGINT, WIN32 spawns a handler */ 620 if (interactive) 621 (void) signal_no_reset(SIGINT, abortcmd); 622#endif /* SYS_WINNT */ 623 624 if (numcmds == 0) { 625 (void) openhost(chosts[0]); 626 getcmds(); 627 } else { 628 int ihost; 629 int icmd; 630 631 for (ihost = 0; ihost < numhosts; ihost++) { 632 if (openhost(chosts[ihost])) 633 for (icmd = 0; icmd < numcmds; icmd++) 634 docmd(ccmds[icmd]); 635 } 636 } 637#ifdef SYS_WINNT 638 WSACleanup(); 639#endif /* SYS_WINNT */ 640 return 0; 641} 642 643 644/* 645 * openhost - open a socket to a host 646 */ 647static int 648openhost( 649 const char *hname 650 ) 651{ 652 char temphost[LENHOSTNAME]; 653 int a_info, i; 654 struct addrinfo hints, *ai = NULL; 655 register const char *cp; 656 char name[LENHOSTNAME]; 657 char service[5]; 658 659 /* 660 * We need to get by the [] if they were entered 661 */ 662 663 cp = hname; 664 665 if(*cp == '[') { 666 cp++; 667 for(i = 0; *cp != ']'; cp++, i++) 668 name[i] = *cp; 669 name[i] = '\0'; 670 hname = name; 671 } 672 673 /* 674 * First try to resolve it as an ip address and if that fails, 675 * do a fullblown (dns) lookup. That way we only use the dns 676 * when it is needed and work around some implementations that 677 * will return an "IPv4-mapped IPv6 address" address if you 678 * give it an IPv4 address to lookup. 679 */ 680 strcpy(service, "ntp"); 681 memset((char *)&hints, 0, sizeof(struct addrinfo)); 682 hints.ai_family = ai_fam_templ; 683 hints.ai_protocol = IPPROTO_UDP; 684 hints.ai_socktype = SOCK_DGRAM; 685 hints.ai_flags = AI_NUMERICHOST; 686 687 a_info = getaddrinfo(hname, service, &hints, &ai); 688 if (a_info == EAI_NONAME 689#ifdef EAI_NODATA 690 || a_info == EAI_NODATA 691#endif 692 ) { 693 hints.ai_flags = AI_CANONNAME; 694#ifdef AI_ADDRCONFIG 695 hints.ai_flags |= AI_ADDRCONFIG; 696#endif 697 a_info = getaddrinfo(hname, service, &hints, &ai); 698 } 699 /* Some older implementations don't like AI_ADDRCONFIG. */ 700 if (a_info == EAI_BADFLAGS) { 701 hints.ai_flags = AI_CANONNAME; 702 a_info = getaddrinfo(hname, service, &hints, &ai); 703 } 704 if (a_info != 0) { 705 (void) fprintf(stderr, "%s\n", gai_strerror(a_info)); 706 return 0; 707 } 708 709 if (ai->ai_canonname == NULL) { 710 strncpy(temphost, stoa((struct sockaddr_storage *)ai->ai_addr), 711 LENHOSTNAME); 712 temphost[LENHOSTNAME-1] = '\0'; 713 714 } else { 715 strncpy(temphost, ai->ai_canonname, LENHOSTNAME); 716 temphost[LENHOSTNAME-1] = '\0'; 717 } 718 719 if (debug > 2) 720 printf("Opening host %s\n", temphost); 721 722 if (havehost == 1) { 723 if (debug > 2) 724 printf("Closing old host %s\n", currenthost); 725 (void) closesocket(sockfd); 726 havehost = 0; 727 } 728 (void) strcpy(currenthost, temphost); 729 730 /* port maps to the same location in both families */ 731 s_port = ((struct sockaddr_in6 *)ai->ai_addr)->sin6_port; 732#ifdef SYS_VXWORKS 733 ((struct sockaddr_in6 *)&hostaddr)->sin6_port = htons(SERVER_PORT_NUM); 734 if (ai->ai_family == AF_INET) 735 *(struct sockaddr_in *)&hostaddr= 736 *((struct sockaddr_in *)ai->ai_addr); 737 else 738 *(struct sockaddr_in6 *)&hostaddr= 739 *((struct sockaddr_in6 *)ai->ai_addr); 740#endif /* SYS_VXWORKS */ 741 742#ifdef SYS_WINNT 743 { 744 int optionValue = SO_SYNCHRONOUS_NONALERT; 745 int err; 746 747 err = setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *)&optionValue, sizeof(optionValue)); 748 if (err != NO_ERROR) { 749 (void) fprintf(stderr, "cannot open nonoverlapped sockets\n"); 750 exit(1); 751 } 752 } 753#endif /* SYS_WINNT */ 754 755 sockfd = socket(ai->ai_family, SOCK_DGRAM, 0); 756 if (sockfd == INVALID_SOCKET) { 757 error("socket", "", ""); 758 } 759 760 761#ifdef NEED_RCVBUF_SLOP 762# ifdef SO_RCVBUF 763 { int rbufsize = DATASIZE + 2048; /* 2K for slop */ 764 if (setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, 765 &rbufsize, sizeof(int)) == -1) 766 error("setsockopt", "", ""); 767 } 768# endif 769#endif 770 771#ifdef SYS_VXWORKS 772 if (connect(sockfd, (struct sockaddr *)&hostaddr, 773 sizeof(hostaddr)) == -1) 774#else 775 if (connect(sockfd, (struct sockaddr *)ai->ai_addr, 776 ai->ai_addrlen) == -1) 777#endif /* SYS_VXWORKS */ 778 error("connect", "", ""); 779 if (a_info == 0) 780 freeaddrinfo(ai); 781 havehost = 1; 782 return 1; 783} 784 785 786/* XXX ELIMINATE sendpkt similar in ntpq.c, ntpdc.c, ntp_io.c, ntptrace.c */ 787/* 788 * sendpkt - send a packet to the remote host 789 */ 790static int 791sendpkt( 792 char *xdata, 793 int xdatalen 794 ) 795{ 796 if (debug >= 3) 797 printf("Sending %d octets\n", xdatalen); 798 799 800 if (send(sockfd, xdata, (size_t)xdatalen, 0) == -1) { 801 warning("write to %s failed", currenthost, ""); 802 return -1; 803 } 804 805 if (debug >= 4) { 806 int first = 8; 807 printf("Packet data:\n"); 808 while (xdatalen-- > 0) { 809 if (first-- == 0) { 810 printf("\n"); 811 first = 7; 812 } 813 printf(" %02x", *xdata++ & 0xff); 814 } 815 printf("\n"); 816 } 817 return 0; 818} 819 820 821 822/* 823 * getresponse - get a (series of) response packet(s) and return the data 824 */ 825static int 826getresponse( 827 int opcode, 828 int associd, 829 u_short *rstatus, 830 int *rsize, 831 char **rdata, 832 int timeo 833 ) 834{ 835 struct ntp_control rpkt; 836 struct timeval tvo; 837 u_short offsets[MAXFRAGS+1]; 838 u_short counts[MAXFRAGS+1]; 839 u_short offset; 840 u_short count; 841 int numfrags; 842 int seenlastfrag; 843 fd_set fds; 844 int n; 845 846 /* 847 * This is pretty tricky. We may get between 1 and MAXFRAG packets 848 * back in response to the request. We peel the data out of 849 * each packet and collect it in one long block. When the last 850 * packet in the sequence is received we'll know how much data we 851 * should have had. Note we use one long time out, should reconsider. 852 */ 853 *rsize = 0; 854 if (rstatus) 855 *rstatus = 0; 856 *rdata = (char *)pktdata; 857 858 numfrags = 0; 859 seenlastfrag = 0; 860 861 FD_ZERO(&fds); 862 863 again: 864 if (numfrags == 0) 865 tvo = tvout; 866 else 867 tvo = tvsout; 868 869 FD_SET(sockfd, &fds); 870 n = select(sockfd+1, &fds, (fd_set *)0, (fd_set *)0, &tvo); 871 872#if 0 873 if (debug >= 1) 874 printf("select() returns %d\n", n); 875#endif 876 877 if (n == -1) { 878 warning("select fails", "", ""); 879 return -1; 880 } 881 if (n == 0) { 882 /* 883 * Timed out. Return what we have 884 */ 885 if (numfrags == 0) { 886 if (timeo) 887 (void) fprintf(stderr, 888 "%s: timed out, nothing received\n", 889 currenthost); 890 return ERR_TIMEOUT; 891 } else { 892 if (timeo) 893 (void) fprintf(stderr, 894 "%s: timed out with incomplete data\n", 895 currenthost); 896 if (debug) { 897 printf("Received fragments:\n"); 898 for (n = 0; n < numfrags; n++) 899 printf("%4d %d\n", offsets[n], 900 counts[n]); 901 if (seenlastfrag) 902 printf("last fragment received\n"); 903 else 904 printf("last fragment not received\n"); 905 } 906 return ERR_INCOMPLETE; 907 } 908 } 909 910 n = recv(sockfd, (char *)&rpkt, sizeof(rpkt), 0); 911 if (n == -1) { 912 warning("read", "", ""); 913 return -1; 914 } 915 916 if (debug >= 4) { 917 int len = n, first = 8; 918 char *data = (char *)&rpkt; 919 920 printf("Packet data:\n"); 921 while (len-- > 0) { 922 if (first-- == 0) { 923 printf("\n"); 924 first = 7; 925 } 926 printf(" %02x", *data++ & 0xff); 927 } 928 printf("\n"); 929 } 930 931 /* 932 * Check for format errors. Bug proofing. 933 */ 934 if (n < CTL_HEADER_LEN) { 935 if (debug) 936 printf("Short (%d byte) packet received\n", n); 937 goto again; 938 } 939 if (PKT_VERSION(rpkt.li_vn_mode) > NTP_VERSION 940 || PKT_VERSION(rpkt.li_vn_mode) < NTP_OLDVERSION) { 941 if (debug) 942 printf("Packet received with version %d\n", 943 PKT_VERSION(rpkt.li_vn_mode)); 944 goto again; 945 } 946 if (PKT_MODE(rpkt.li_vn_mode) != MODE_CONTROL) { 947 if (debug) 948 printf("Packet received with mode %d\n", 949 PKT_MODE(rpkt.li_vn_mode)); 950 goto again; 951 } 952 if (!CTL_ISRESPONSE(rpkt.r_m_e_op)) { 953 if (debug) 954 printf("Received request packet, wanted response\n"); 955 goto again; 956 } 957 958 /* 959 * Check opcode and sequence number for a match. 960 * Could be old data getting to us. 961 */ 962 if (ntohs(rpkt.sequence) != sequence) { 963 if (debug) 964 printf( 965 "Received sequnce number %d, wanted %d\n", 966 ntohs(rpkt.sequence), sequence); 967 goto again; 968 } 969 if (CTL_OP(rpkt.r_m_e_op) != opcode) { 970 if (debug) 971 printf( 972 "Received opcode %d, wanted %d (sequence number okay)\n", 973 CTL_OP(rpkt.r_m_e_op), opcode); 974 goto again; 975 } 976 977 /* 978 * Check the error code. If non-zero, return it. 979 */ 980 if (CTL_ISERROR(rpkt.r_m_e_op)) { 981 int errcode; 982 983 errcode = (ntohs(rpkt.status) >> 8) & 0xff; 984 if (debug && CTL_ISMORE(rpkt.r_m_e_op)) { 985 printf("Error code %d received on not-final packet\n", 986 errcode); 987 } 988 if (errcode == CERR_UNSPEC) 989 return ERR_UNSPEC; 990 return errcode; 991 } 992 993 /* 994 * Check the association ID to make sure it matches what 995 * we sent. 996 */ 997 if (ntohs(rpkt.associd) != associd) { 998 if (debug) 999 printf("Association ID %d doesn't match expected %d\n", 1000 ntohs(rpkt.associd), associd); 1001 /* 1002 * Hack for silly fuzzballs which, at the time of writing, 1003 * return an assID of sys.peer when queried for system variables. 1004 */ 1005#ifdef notdef 1006 goto again; 1007#endif 1008 } 1009 1010 /* 1011 * Collect offset and count. Make sure they make sense. 1012 */ 1013 offset = ntohs(rpkt.offset); 1014 count = ntohs(rpkt.count); 1015 1016 if (debug >= 3) { 1017 int shouldbesize; 1018 u_long key; 1019 u_long *lpkt; 1020 int maclen; 1021 1022 /* 1023 * Usually we ignore authentication, but for debugging purposes 1024 * we watch it here. 1025 */ 1026 shouldbesize = CTL_HEADER_LEN + count; 1027 1028 /* round to 8 octet boundary */ 1029 shouldbesize = (shouldbesize + 7) & ~7; 1030 1031 if (n & 0x3) { 1032 printf("Packet not padded, size = %d\n", n); 1033 } if ((maclen = n - shouldbesize) >= MIN_MAC_LEN) { 1034 printf( 1035 "Packet shows signs of authentication (total %d, data %d, mac %d)\n", 1036 n, shouldbesize, maclen); 1037 lpkt = (u_long *)&rpkt; 1038 printf("%08lx %08lx %08lx %08lx %08lx %08lx\n", 1039 (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_long) - 3]), 1040 (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_long) - 2]), 1041 (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_long) - 1]), 1042 (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_long)]), 1043 (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_long) + 1]), 1044 (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_long) + 2])); 1045 key = ntohl(lpkt[(n - maclen) / sizeof(u_long)]); 1046 printf("Authenticated with keyid %lu\n", (u_long)key); 1047 if (key != 0 && key != info_auth_keyid) { 1048 printf("We don't know that key\n"); 1049 } else { 1050 if (authdecrypt(key, (u_int32 *)&rpkt, 1051 n - maclen, maclen)) { 1052 printf("Auth okay!\n"); 1053 } else { 1054 printf("Auth failed!\n"); 1055 } 1056 } 1057 } 1058 } 1059 1060 if (debug >= 2) 1061 printf("Got packet, size = %d\n", n); 1062 if (count > (u_short)(n-CTL_HEADER_LEN)) { 1063 if (debug) 1064 printf( 1065 "Received count of %d octets, data in packet is %d\n", 1066 count, n-CTL_HEADER_LEN); 1067 goto again; 1068 } 1069 if (count == 0 && CTL_ISMORE(rpkt.r_m_e_op)) { 1070 if (debug) 1071 printf("Received count of 0 in non-final fragment\n"); 1072 goto again; 1073 } 1074 if (offset + count > sizeof(pktdata)) { 1075 if (debug) 1076 printf("Offset %d, count %d, too big for buffer\n", 1077 offset, count); 1078 return ERR_TOOMUCH; 1079 } 1080 if (seenlastfrag && !CTL_ISMORE(rpkt.r_m_e_op)) { 1081 if (debug) 1082 printf("Received second last fragment packet\n"); 1083 goto again; 1084 } 1085 1086 /* 1087 * So far, so good. Record this fragment, making sure it doesn't 1088 * overlap anything. 1089 */ 1090 if (debug >= 2) 1091 printf("Packet okay\n");; 1092 1093 if (numfrags == MAXFRAGS) { 1094 if (debug) 1095 printf("Number of fragments exceeds maximum\n"); 1096 return ERR_TOOMUCH; 1097 } 1098 1099 for (n = 0; n < numfrags; n++) { 1100 if (offset == offsets[n]) 1101 goto again; /* duplicate */ 1102 if (offset < offsets[n]) 1103 break; 1104 } 1105 1106 if ((u_short)(n > 0 && offsets[n-1] + counts[n-1]) > offset) 1107 goto overlap; 1108 if (n < numfrags && (u_short)(offset + count) > offsets[n]) 1109 goto overlap; 1110 1111 { 1112 register int i; 1113 1114 for (i = numfrags; i > n; i--) { 1115 offsets[i] = offsets[i-1]; 1116 counts[i] = counts[i-1]; 1117 } 1118 } 1119 offsets[n] = offset; 1120 counts[n] = count; 1121 numfrags++; 1122 1123 /* 1124 * Got that stuffed in right. Figure out if this was the last. 1125 * Record status info out of the last packet. 1126 */ 1127 if (!CTL_ISMORE(rpkt.r_m_e_op)) { 1128 seenlastfrag = 1; 1129 if (rstatus != 0) 1130 *rstatus = ntohs(rpkt.status); 1131 } 1132 1133 /* 1134 * Copy the data into the data buffer. 1135 */ 1136 memmove((char *)pktdata + offset, (char *)rpkt.data, count); 1137 1138 /* 1139 * If we've seen the last fragment, look for holes in the sequence. 1140 * If there aren't any, we're done. 1141 */ 1142 if (seenlastfrag && offsets[0] == 0) { 1143 for (n = 1; n < numfrags; n++) { 1144 if (offsets[n-1] + counts[n-1] != offsets[n]) 1145 break; 1146 } 1147 if (n == numfrags) { 1148 *rsize = offsets[numfrags-1] + counts[numfrags-1]; 1149 return 0; 1150 } 1151 } 1152 goto again; 1153 1154 overlap: 1155 /* 1156 * Print debugging message about overlapping fragments 1157 */ 1158 if (debug) 1159 printf("Overlapping fragments returned in response\n"); 1160 goto again; 1161} 1162 1163 1164/* 1165 * sendrequest - format and send a request packet 1166 */ 1167static int 1168sendrequest( 1169 int opcode, 1170 int associd, 1171 int auth, 1172 int qsize, 1173 char *qdata 1174 ) 1175{ 1176 struct ntp_control qpkt; 1177 int pktsize; 1178 1179 /* 1180 * Check to make sure the data will fit in one packet 1181 */ 1182 if (qsize > CTL_MAX_DATA_LEN) { 1183 (void) fprintf(stderr, 1184 "***Internal error! qsize (%d) too large\n", 1185 qsize); 1186 return 1; 1187 } 1188 1189 /* 1190 * Fill in the packet 1191 */ 1192 qpkt.li_vn_mode = PKT_LI_VN_MODE(0, pktversion, MODE_CONTROL); 1193 qpkt.r_m_e_op = (u_char)(opcode & CTL_OP_MASK); 1194 qpkt.sequence = htons(sequence); 1195 qpkt.status = 0; 1196 qpkt.associd = htons((u_short)associd); 1197 qpkt.offset = 0; 1198 qpkt.count = htons((u_short)qsize); 1199 1200 /* 1201 * If we have data, copy it in and pad it out to a 64 1202 * bit boundary. 1203 */ 1204 if (qsize > 0) { 1205 memmove((char *)qpkt.data, qdata, (unsigned)qsize); 1206 pktsize = qsize + CTL_HEADER_LEN; 1207 while (pktsize & (sizeof(u_long) - 1)) { 1208 qpkt.data[qsize++] = 0; 1209 pktsize++; 1210 } 1211 } else { 1212 pktsize = CTL_HEADER_LEN; 1213 } 1214 1215 /* 1216 * If it isn't authenticated we can just send it. Otherwise 1217 * we're going to have to think about it a little. 1218 */ 1219 if (!auth && !always_auth) { 1220 return sendpkt((char *)&qpkt, pktsize); 1221 } else { 1222 const char *pass = "\0"; 1223 int maclen = 0; 1224 u_long my_keyid; 1225 1226 /* 1227 * Pad out packet to a multiple of 8 octets to be sure 1228 * receiver can handle it. 1229 */ 1230 while (pktsize & 7) { 1231 qpkt.data[qsize++] = 0; 1232 pktsize++; 1233 } 1234 1235 /* 1236 * Get the keyid and the password if we don't have one. 1237 */ 1238 if (info_auth_keyid == 0) { 1239 int u_keyid = getkeyid("Keyid: "); 1240 if (u_keyid == 0 || u_keyid > NTP_MAXKEY) { 1241 (void) fprintf(stderr, 1242 "Invalid key identifier\n"); 1243 return 1; 1244 } 1245 info_auth_keyid = u_keyid; 1246 } 1247 if (!authistrusted(info_auth_keyid)) { 1248 pass = getpass("MD5 Password: "); 1249 if (*pass == '\0') { 1250 (void) fprintf(stderr, 1251 "Invalid password\n"); 1252 return (1); 1253 } 1254 } 1255 authusekey(info_auth_keyid, info_auth_keytype, (const u_char *)pass); 1256 authtrust(info_auth_keyid, 1); 1257 1258 /* 1259 * Stick the keyid in the packet where 1260 * cp currently points. Cp should be aligned 1261 * properly. Then do the encryptions. 1262 */ 1263 my_keyid = htonl(info_auth_keyid); 1264 memcpy(&qpkt.data[qsize], &my_keyid, sizeof my_keyid); 1265 maclen = authencrypt(info_auth_keyid, (u_int32 *)&qpkt, 1266 pktsize); 1267 if (maclen == 0) { 1268 (void) fprintf(stderr, "Key not found\n"); 1269 return (1); 1270 } 1271 return sendpkt((char *)&qpkt, pktsize + maclen); 1272 } 1273 /*NOTREACHED*/ 1274} 1275 1276 1277/* 1278 * doquery - send a request and process the response 1279 */ 1280int 1281doquery( 1282 int opcode, 1283 int associd, 1284 int auth, 1285 int qsize, 1286 char *qdata, 1287 u_short *rstatus, 1288 int *rsize, 1289 char **rdata 1290 ) 1291{ 1292 int res; 1293 int done; 1294 1295 /* 1296 * Check to make sure host is open 1297 */ 1298 if (!havehost) { 1299 (void) fprintf(stderr, "***No host open, use `host' command\n"); 1300 return -1; 1301 } 1302 1303 done = 0; 1304 sequence++; 1305 1306 again: 1307 /* 1308 * send a request 1309 */ 1310 res = sendrequest(opcode, associd, auth, qsize, qdata); 1311 if (res != 0) 1312 return res; 1313 1314 /* 1315 * Get the response. If we got a standard error, print a message 1316 */ 1317 res = getresponse(opcode, associd, rstatus, rsize, rdata, done); 1318 1319 if (res > 0) { 1320 if (!done && (res == ERR_TIMEOUT || res == ERR_INCOMPLETE)) { 1321 if (res == ERR_INCOMPLETE) { 1322 /* 1323 * better bump the sequence so we don't 1324 * get confused about differing fragments. 1325 */ 1326 sequence++; 1327 } 1328 done = 1; 1329 goto again; 1330 } 1331 if (numhosts > 1) 1332 (void) fprintf(stderr, "server=%s ", currenthost); 1333 switch(res) { 1334 case CERR_BADFMT: 1335 (void) fprintf(stderr, 1336 "***Server reports a bad format request packet\n"); 1337 break; 1338 case CERR_PERMISSION: 1339 (void) fprintf(stderr, 1340 "***Server disallowed request (authentication?)\n"); 1341 break; 1342 case CERR_BADOP: 1343 (void) fprintf(stderr, 1344 "***Server reports a bad opcode in request\n"); 1345 break; 1346 case CERR_BADASSOC: 1347 (void) fprintf(stderr, 1348 "***Association ID %d unknown to server\n",associd); 1349 break; 1350 case CERR_UNKNOWNVAR: 1351 (void) fprintf(stderr, 1352 "***A request variable unknown to the server\n"); 1353 break; 1354 case CERR_BADVALUE: 1355 (void) fprintf(stderr, 1356 "***Server indicates a request variable was bad\n"); 1357 break; 1358 case ERR_UNSPEC: 1359 (void) fprintf(stderr, 1360 "***Server returned an unspecified error\n"); 1361 break; 1362 case ERR_TIMEOUT: 1363 (void) fprintf(stderr, "***Request timed out\n"); 1364 break; 1365 case ERR_INCOMPLETE: 1366 (void) fprintf(stderr, 1367 "***Response from server was incomplete\n"); 1368 break; 1369 case ERR_TOOMUCH: 1370 (void) fprintf(stderr, 1371 "***Buffer size exceeded for returned data\n"); 1372 break; 1373 default: 1374 (void) fprintf(stderr, 1375 "***Server returns unknown error code %d\n", res); 1376 break; 1377 } 1378 } 1379 return res; 1380} 1381 1382 1383/* 1384 * getcmds - read commands from the standard input and execute them 1385 */ 1386static void 1387getcmds(void) 1388{ 1389#if defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDIT) 1390 char *line; 1391 1392 for (;;) { 1393 if ((line = readline(interactive?prompt:"")) == NULL) return; 1394 if (*line) add_history(line); 1395 docmd(line); 1396 free(line); 1397 } 1398#else /* not (HAVE_LIBREADLINE || HAVE_LIBEDIT) */ 1399 char line[MAXLINE]; 1400 1401 for (;;) { 1402 if (interactive) { 1403#ifdef VMS /* work around a problem with mixing stdout & stderr */ 1404 fputs("",stdout); 1405#endif 1406 (void) fputs(prompt, stderr); 1407 (void) fflush(stderr); 1408 } 1409 1410 if (fgets(line, sizeof line, stdin) == NULL) 1411 return; 1412 1413 docmd(line); 1414 } 1415#endif /* not (HAVE_LIBREADLINE || HAVE_LIBEDIT) */ 1416} 1417 1418#ifndef SYS_WINNT /* Under NT cannot handle SIGINT, WIN32 spawns a handler */ 1419/* 1420 * abortcmd - catch interrupts and abort the current command 1421 */ 1422static RETSIGTYPE 1423abortcmd( 1424 int sig 1425 ) 1426{ 1427 if (current_output == stdout) 1428 (void) fflush(stdout); 1429 putc('\n', stderr); 1430 (void) fflush(stderr); 1431 if (jump) longjmp(interrupt_buf, 1); 1432} 1433#endif /* SYS_WINNT */ 1434 1435/* 1436 * docmd - decode the command line and execute a command 1437 */ 1438static void 1439docmd( 1440 const char *cmdline 1441 ) 1442{ 1443 char *tokens[1+MAXARGS+2]; 1444 struct parse pcmd; 1445 int ntok; 1446 static int i; 1447 struct xcmd *xcmd; 1448 1449 /* 1450 * Tokenize the command line. If nothing on it, return. 1451 */ 1452 tokenize(cmdline, tokens, &ntok); 1453 if (ntok == 0) 1454 return; 1455 1456 /* 1457 * Find the appropriate command description. 1458 */ 1459 i = findcmd(tokens[0], builtins, opcmds, &xcmd); 1460 if (i == 0) { 1461 (void) fprintf(stderr, "***Command `%s' unknown\n", 1462 tokens[0]); 1463 return; 1464 } else if (i >= 2) { 1465 (void) fprintf(stderr, "***Command `%s' ambiguous\n", 1466 tokens[0]); 1467 return; 1468 } 1469 1470 /* 1471 * Save the keyword, then walk through the arguments, interpreting 1472 * as we go. 1473 */ 1474 pcmd.keyword = tokens[0]; 1475 pcmd.nargs = 0; 1476 for (i = 0; i < MAXARGS && xcmd->arg[i] != NO; i++) { 1477 if ((i+1) >= ntok) { 1478 if (!(xcmd->arg[i] & OPT)) { 1479 printusage(xcmd, stderr); 1480 return; 1481 } 1482 break; 1483 } 1484 if ((xcmd->arg[i] & OPT) && (*tokens[i+1] == '>')) 1485 break; 1486 if (!getarg(tokens[i+1], (int)xcmd->arg[i], &pcmd.argval[i])) 1487 return; 1488 pcmd.nargs++; 1489 } 1490 1491 i++; 1492 if (i < ntok && *tokens[i] == '>') { 1493 char *fname; 1494 1495 if (*(tokens[i]+1) != '\0') 1496 fname = tokens[i]+1; 1497 else if ((i+1) < ntok) 1498 fname = tokens[i+1]; 1499 else { 1500 (void) fprintf(stderr, "***No file for redirect\n"); 1501 return; 1502 } 1503 1504 current_output = fopen(fname, "w"); 1505 if (current_output == NULL) { 1506 (void) fprintf(stderr, "***Error opening %s: ", fname); 1507 perror(""); 1508 return; 1509 } 1510 i = 1; /* flag we need a close */ 1511 } else { 1512 current_output = stdout; 1513 i = 0; /* flag no close */ 1514 } 1515 1516 if (interactive && setjmp(interrupt_buf)) { 1517 jump = 0; 1518 return; 1519 } else { 1520 jump++; 1521 (xcmd->handler)(&pcmd, current_output); 1522 jump = 0; /* HMS: 961106: was after fclose() */ 1523 if (i) (void) fclose(current_output); 1524 } 1525} 1526 1527 1528/* 1529 * tokenize - turn a command line into tokens 1530 */ 1531static void 1532tokenize( 1533 const char *line, 1534 char **tokens, 1535 int *ntok 1536 ) 1537{ 1538 register const char *cp; 1539 register char *sp; 1540 static char tspace[MAXLINE]; 1541 1542 sp = tspace; 1543 cp = line; 1544 for (*ntok = 0; *ntok < MAXTOKENS; (*ntok)++) { 1545 tokens[*ntok] = sp; 1546 while (ISSPACE(*cp)) 1547 cp++; 1548 if (ISEOL(*cp)) 1549 break; 1550 do { 1551 *sp++ = *cp++; 1552 } while (!ISSPACE(*cp) && !ISEOL(*cp)); 1553 1554 *sp++ = '\0'; 1555 } 1556} 1557 1558 1559 1560/* 1561 * findcmd - find a command in a command description table 1562 */ 1563static int 1564findcmd( 1565 register char *str, 1566 struct xcmd *clist1, 1567 struct xcmd *clist2, 1568 struct xcmd **cmd 1569 ) 1570{ 1571 register struct xcmd *cl; 1572 register int clen; 1573 int nmatch; 1574 struct xcmd *nearmatch = NULL; 1575 struct xcmd *clist; 1576 1577 clen = strlen(str); 1578 nmatch = 0; 1579 if (clist1 != 0) 1580 clist = clist1; 1581 else if (clist2 != 0) 1582 clist = clist2; 1583 else 1584 return 0; 1585 1586 again: 1587 for (cl = clist; cl->keyword != 0; cl++) { 1588 /* do a first character check, for efficiency */ 1589 if (*str != *(cl->keyword)) 1590 continue; 1591 if (strncmp(str, cl->keyword, (unsigned)clen) == 0) { 1592 /* 1593 * Could be extact match, could be approximate. 1594 * Is exact if the length of the keyword is the 1595 * same as the str. 1596 */ 1597 if (*((cl->keyword) + clen) == '\0') { 1598 *cmd = cl; 1599 return 1; 1600 } 1601 nmatch++; 1602 nearmatch = cl; 1603 } 1604 } 1605 1606 /* 1607 * See if there is more to do. If so, go again. Sorry about the 1608 * goto, too much looking at BSD sources... 1609 */ 1610 if (clist == clist1 && clist2 != 0) { 1611 clist = clist2; 1612 goto again; 1613 } 1614 1615 /* 1616 * If we got extactly 1 near match, use it, else return number 1617 * of matches. 1618 */ 1619 if (nmatch == 1) { 1620 *cmd = nearmatch; 1621 return 1; 1622 } 1623 return nmatch; 1624} 1625 1626 1627/* 1628 * getarg - interpret an argument token 1629 */ 1630static int 1631getarg( 1632 char *str, 1633 int code, 1634 arg_v *argp 1635 ) 1636{ 1637 int isneg; 1638 char *cp, *np; 1639 static const char *digits = "0123456789"; 1640 1641 switch (code & ~OPT) { 1642 case NTP_STR: 1643 argp->string = str; 1644 break; 1645 case NTP_ADD: 1646 if (!getnetnum(str, &(argp->netnum), (char *)0, 0)) { 1647 return 0; 1648 } 1649 break; 1650 case NTP_INT: 1651 case NTP_UINT: 1652 isneg = 0; 1653 np = str; 1654 if (*np == '&') { 1655 np++; 1656 isneg = atoi(np); 1657 if (isneg <= 0) { 1658 (void) fprintf(stderr, 1659 "***Association value `%s' invalid/undecodable\n", str); 1660 return 0; 1661 } 1662 if (isneg > numassoc) { 1663 if (numassoc == 0) { 1664 (void) fprintf(stderr, 1665 "***Association for `%s' unknown (max &%d)\n", 1666 str, numassoc); 1667 return 0; 1668 } else { 1669 isneg = numassoc; 1670 } 1671 } 1672 argp->uval = assoc_cache[isneg-1].assid; 1673 break; 1674 } 1675 1676 if (*np == '-') { 1677 np++; 1678 isneg = 1; 1679 } 1680 1681 argp->uval = 0; 1682 do { 1683 cp = strchr(digits, *np); 1684 if (cp == NULL) { 1685 (void) fprintf(stderr, 1686 "***Illegal integer value %s\n", str); 1687 return 0; 1688 } 1689 argp->uval *= 10; 1690 argp->uval += (cp - digits); 1691 } while (*(++np) != '\0'); 1692 1693 if (isneg) { 1694 if ((code & ~OPT) == NTP_UINT) { 1695 (void) fprintf(stderr, 1696 "***Value %s should be unsigned\n", str); 1697 return 0; 1698 } 1699 argp->ival = -argp->ival; 1700 } 1701 break; 1702 case IP_VERSION: 1703 if (!strcmp("-6", str)) 1704 argp->ival = 6 ; 1705 else if (!strcmp("-4", str)) 1706 argp->ival = 4 ; 1707 else { 1708 (void) fprintf(stderr, 1709 "***Version must be either 4 or 6\n"); 1710 return 0; 1711 } 1712 break; 1713 } 1714 1715 return 1; 1716} 1717 1718 1719/* 1720 * getnetnum - given a host name, return its net number 1721 * and (optional) full name 1722 */ 1723int 1724getnetnum( 1725 const char *hname, 1726 struct sockaddr_storage *num, 1727 char *fullhost, 1728 int af 1729 ) 1730{ 1731 int sockaddr_len; 1732 struct addrinfo hints, *ai = NULL; 1733 1734 sockaddr_len = (af == AF_INET) 1735 ? sizeof(struct sockaddr_in) 1736 : sizeof(struct sockaddr_in6); 1737 memset((char *)&hints, 0, sizeof(struct addrinfo)); 1738 hints.ai_flags = AI_CANONNAME; 1739#ifdef AI_ADDRCONFIG 1740 hints.ai_flags |= AI_ADDRCONFIG; 1741#endif 1742 1743 /* decodenetnum works with addresses only */ 1744 if (decodenetnum(hname, num)) { 1745 if (fullhost != 0) { 1746 getnameinfo((struct sockaddr *)num, sockaddr_len, 1747 fullhost, sizeof(fullhost), NULL, 0, 1748 NI_NUMERICHOST); 1749 } 1750 return 1; 1751 } else if (getaddrinfo(hname, "ntp", &hints, &ai) == 0) { 1752 memmove((char *)num, ai->ai_addr, ai->ai_addrlen); 1753 if (ai->ai_canonname != 0) 1754 (void) strcpy(fullhost, ai->ai_canonname); 1755 return 1; 1756 } else { 1757 (void) fprintf(stderr, "***Can't find host %s\n", hname); 1758 return 0; 1759 } 1760 /*NOTREACHED*/ 1761} 1762 1763/* 1764 * nntohost - convert network number to host name. This routine enforces 1765 * the showhostnames setting. 1766 */ 1767char * 1768nntohost( 1769 struct sockaddr_storage *netnum 1770 ) 1771{ 1772 if (!showhostnames) 1773 return stoa(netnum); 1774 if ((netnum->ss_family == AF_INET) && ISREFCLOCKADR(netnum)) 1775 return refnumtoa(netnum); 1776 return socktohost(netnum); 1777} 1778 1779 1780/* 1781 * rtdatetolfp - decode an RT-11 date into an l_fp 1782 */ 1783static int 1784rtdatetolfp( 1785 char *str, 1786 l_fp *lfp 1787 ) 1788{ 1789 register char *cp; 1790 register int i; 1791 struct calendar cal; 1792 char buf[4]; 1793 static const char *months[12] = { 1794 "Jan", "Feb", "Mar", "Apr", "May", "Jun", 1795 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" 1796 }; 1797 1798 cal.yearday = 0; 1799 1800 /* 1801 * An RT-11 date looks like: 1802 * 1803 * d[d]-Mth-y[y] hh:mm:ss 1804 * 1805 * (No docs, but assume 4-digit years are also legal...) 1806 * 1807 * d[d]-Mth-y[y[y[y]]] hh:mm:ss 1808 */ 1809 cp = str; 1810 if (!isdigit((int)*cp)) { 1811 if (*cp == '-') { 1812 /* 1813 * Catch special case 1814 */ 1815 L_CLR(lfp); 1816 return 1; 1817 } 1818 return 0; 1819 } 1820 1821 cal.monthday = (u_char) (*cp++ - '0'); /* ascii dependent */ 1822 if (isdigit((int)*cp)) { 1823 cal.monthday = (u_char)((cal.monthday << 3) + (cal.monthday << 1)); 1824 cal.monthday = (u_char)(cal.monthday + *cp++ - '0'); 1825 } 1826 1827 if (*cp++ != '-') 1828 return 0; 1829 1830 for (i = 0; i < 3; i++) 1831 buf[i] = *cp++; 1832 buf[3] = '\0'; 1833 1834 for (i = 0; i < 12; i++) 1835 if (STREQ(buf, months[i])) 1836 break; 1837 if (i == 12) 1838 return 0; 1839 cal.month = (u_char)(i + 1); 1840 1841 if (*cp++ != '-') 1842 return 0; 1843 1844 if (!isdigit((int)*cp)) 1845 return 0; 1846 cal.year = (u_short)(*cp++ - '0'); 1847 if (isdigit((int)*cp)) { 1848 cal.year = (u_short)((cal.year << 3) + (cal.year << 1)); 1849 cal.year = (u_short)(*cp++ - '0'); 1850 } 1851 if (isdigit((int)*cp)) { 1852 cal.year = (u_short)((cal.year << 3) + (cal.year << 1)); 1853 cal.year = (u_short)(cal.year + *cp++ - '0'); 1854 } 1855 if (isdigit((int)*cp)) { 1856 cal.year = (u_short)((cal.year << 3) + (cal.year << 1)); 1857 cal.year = (u_short)(cal.year + *cp++ - '0'); 1858 } 1859 1860 /* 1861 * Catch special case. If cal.year == 0 this is a zero timestamp. 1862 */ 1863 if (cal.year == 0) { 1864 L_CLR(lfp); 1865 return 1; 1866 } 1867 1868 if (*cp++ != ' ' || !isdigit((int)*cp)) 1869 return 0; 1870 cal.hour = (u_char)(*cp++ - '0'); 1871 if (isdigit((int)*cp)) { 1872 cal.hour = (u_char)((cal.hour << 3) + (cal.hour << 1)); 1873 cal.hour = (u_char)(cal.hour + *cp++ - '0'); 1874 } 1875 1876 if (*cp++ != ':' || !isdigit((int)*cp)) 1877 return 0; 1878 cal.minute = (u_char)(*cp++ - '0'); 1879 if (isdigit((int)*cp)) { 1880 cal.minute = (u_char)((cal.minute << 3) + (cal.minute << 1)); 1881 cal.minute = (u_char)(cal.minute + *cp++ - '0'); 1882 } 1883 1884 if (*cp++ != ':' || !isdigit((int)*cp)) 1885 return 0; 1886 cal.second = (u_char)(*cp++ - '0'); 1887 if (isdigit((int)*cp)) { 1888 cal.second = (u_char)((cal.second << 3) + (cal.second << 1)); 1889 cal.second = (u_char)(cal.second + *cp++ - '0'); 1890 } 1891 1892 /* 1893 * For RT-11, 1972 seems to be the pivot year 1894 */ 1895 if (cal.year < 72) 1896 cal.year += 2000; 1897 if (cal.year < 100) 1898 cal.year += 1900; 1899 1900 lfp->l_ui = caltontp(&cal); 1901 lfp->l_uf = 0; 1902 return 1; 1903} 1904 1905 1906/* 1907 * decodets - decode a timestamp into an l_fp format number, with 1908 * consideration of fuzzball formats. 1909 */ 1910int 1911decodets( 1912 char *str, 1913 l_fp *lfp 1914 ) 1915{ 1916 /* 1917 * If it starts with a 0x, decode as hex. 1918 */ 1919 if (*str == '0' && (*(str+1) == 'x' || *(str+1) == 'X')) 1920 return hextolfp(str+2, lfp); 1921 1922 /* 1923 * If it starts with a '"', try it as an RT-11 date. 1924 */ 1925 if (*str == '"') { 1926 register char *cp = str+1; 1927 register char *bp; 1928 char buf[30]; 1929 1930 bp = buf; 1931 while (*cp != '"' && *cp != '\0' && bp < &buf[29]) 1932 *bp++ = *cp++; 1933 *bp = '\0'; 1934 return rtdatetolfp(buf, lfp); 1935 } 1936 1937 /* 1938 * Might still be hex. Check out the first character. Talk 1939 * about heuristics! 1940 */ 1941 if ((*str >= 'A' && *str <= 'F') || (*str >= 'a' && *str <= 'f')) 1942 return hextolfp(str, lfp); 1943 1944 /* 1945 * Try it as a decimal. If this fails, try as an unquoted 1946 * RT-11 date. This code should go away eventually. 1947 */ 1948 if (atolfp(str, lfp)) 1949 return 1; 1950 return rtdatetolfp(str, lfp); 1951} 1952 1953 1954/* 1955 * decodetime - decode a time value. It should be in milliseconds 1956 */ 1957int 1958decodetime( 1959 char *str, 1960 l_fp *lfp 1961 ) 1962{ 1963 return mstolfp(str, lfp); 1964} 1965 1966 1967/* 1968 * decodeint - decode an integer 1969 */ 1970int 1971decodeint( 1972 char *str, 1973 long *val 1974 ) 1975{ 1976 if (*str == '0') { 1977 if (*(str+1) == 'x' || *(str+1) == 'X') 1978 return hextoint(str+2, val); 1979 return octtoint(str, val); 1980 } 1981 return atoint(str, val); 1982} 1983 1984 1985/* 1986 * decodeuint - decode an unsigned integer 1987 */ 1988int 1989decodeuint( 1990 char *str, 1991 u_long *val 1992 ) 1993{ 1994 if (*str == '0') { 1995 if (*(str + 1) == 'x' || *(str + 1) == 'X') 1996 return (hextoint(str + 2, val)); 1997 return (octtoint(str, val)); 1998 } 1999 return (atouint(str, val)); 2000} 2001 2002 2003/* 2004 * decodearr - decode an array of time values 2005 */ 2006static int 2007decodearr( 2008 char *str, 2009 int *narr, 2010 l_fp *lfparr 2011 ) 2012{ 2013 register char *cp, *bp; 2014 register l_fp *lfp; 2015 char buf[60]; 2016 2017 lfp = lfparr; 2018 cp = str; 2019 *narr = 0; 2020 2021 while (*narr < 8) { 2022 while (isspace((int)*cp)) 2023 cp++; 2024 if (*cp == '\0') 2025 break; 2026 2027 bp = buf; 2028 while (!isspace((int)*cp) && *cp != '\0') 2029 *bp++ = *cp++; 2030 *bp++ = '\0'; 2031 2032 if (!decodetime(buf, lfp)) 2033 return 0; 2034 (*narr)++; 2035 lfp++; 2036 } 2037 return 1; 2038} 2039 2040 2041/* 2042 * Finally, the built in command handlers 2043 */ 2044 2045/* 2046 * help - tell about commands, or details of a particular command 2047 */ 2048static void 2049help( 2050 struct parse *pcmd, 2051 FILE *fp 2052 ) 2053{ 2054 struct xcmd *xcp; 2055 char *cmd; 2056 const char *list[100]; 2057 int word, words; 2058 int row, rows; 2059 int col, cols; 2060 2061 if (pcmd->nargs == 0) { 2062 words = 0; 2063 for (xcp = builtins; xcp->keyword != 0; xcp++) { 2064 if (*(xcp->keyword) != '?') 2065 list[words++] = xcp->keyword; 2066 } 2067 for (xcp = opcmds; xcp->keyword != 0; xcp++) 2068 list[words++] = xcp->keyword; 2069 2070 qsort( 2071#ifdef QSORT_USES_VOID_P 2072 (void *) 2073#else 2074 (char *) 2075#endif 2076 (list), (size_t)(words), sizeof(char *), helpsort); 2077 col = 0; 2078 for (word = 0; word < words; word++) { 2079 int length = strlen(list[word]); 2080 if (col < length) { 2081 col = length; 2082 } 2083 } 2084 2085 cols = SCREENWIDTH / ++col; 2086 rows = (words + cols - 1) / cols; 2087 2088 (void) fprintf(fp, "ntpq commands:\n"); 2089 2090 for (row = 0; row < rows; row++) { 2091 for (word = row; word < words; word += rows) { 2092 (void) fprintf(fp, "%-*.*s", col, col-1, list[word]); 2093 } 2094 (void) fprintf(fp, "\n"); 2095 } 2096 } else { 2097 cmd = pcmd->argval[0].string; 2098 words = findcmd(cmd, builtins, opcmds, &xcp); 2099 if (words == 0) { 2100 (void) fprintf(stderr, 2101 "Command `%s' is unknown\n", cmd); 2102 return; 2103 } else if (words >= 2) { 2104 (void) fprintf(stderr, 2105 "Command `%s' is ambiguous\n", cmd); 2106 return; 2107 } 2108 (void) fprintf(fp, "function: %s\n", xcp->comment); 2109 printusage(xcp, fp); 2110 } 2111} 2112 2113 2114/* 2115 * helpsort - do hostname qsort comparisons 2116 */ 2117#ifdef QSORT_USES_VOID_P 2118static int 2119helpsort( 2120 const void *t1, 2121 const void *t2 2122 ) 2123{ 2124 char const * const * name1 = (char const * const *)t1; 2125 char const * const * name2 = (char const * const *)t2; 2126 2127 return strcmp(*name1, *name2); 2128} 2129 2130#else 2131static int 2132helpsort( 2133 char **name1, 2134 char **name2 2135 ) 2136{ 2137 return strcmp(*name1, *name2); 2138} 2139#endif 2140 2141/* 2142 * printusage - print usage information for a command 2143 */ 2144static void 2145printusage( 2146 struct xcmd *xcp, 2147 FILE *fp 2148 ) 2149{ 2150 register int i; 2151 2152 (void) fprintf(fp, "usage: %s", xcp->keyword); 2153 for (i = 0; i < MAXARGS && xcp->arg[i] != NO; i++) { 2154 if (xcp->arg[i] & OPT) 2155 (void) fprintf(fp, " [ %s ]", xcp->desc[i]); 2156 else 2157 (void) fprintf(fp, " %s", xcp->desc[i]); 2158 } 2159 (void) fprintf(fp, "\n"); 2160} 2161 2162 2163/* 2164 * timeout - set time out time 2165 */ 2166static void 2167timeout( 2168 struct parse *pcmd, 2169 FILE *fp 2170 ) 2171{ 2172 int val; 2173 2174 if (pcmd->nargs == 0) { 2175 val = tvout.tv_sec * 1000 + tvout.tv_usec / 1000; 2176 (void) fprintf(fp, "primary timeout %d ms\n", val); 2177 } else { 2178 tvout.tv_sec = pcmd->argval[0].uval / 1000; 2179 tvout.tv_usec = (pcmd->argval[0].uval - (tvout.tv_sec * 1000)) 2180 * 1000; 2181 } 2182} 2183 2184 2185/* 2186 * auth_delay - set delay for auth requests 2187 */ 2188static void 2189auth_delay( 2190 struct parse *pcmd, 2191 FILE *fp 2192 ) 2193{ 2194 int isneg; 2195 u_long val; 2196 2197 if (pcmd->nargs == 0) { 2198 val = delay_time.l_ui * 1000 + delay_time.l_uf / 4294967; 2199 (void) fprintf(fp, "delay %lu ms\n", val); 2200 } else { 2201 if (pcmd->argval[0].ival < 0) { 2202 isneg = 1; 2203 val = (u_long)(-pcmd->argval[0].ival); 2204 } else { 2205 isneg = 0; 2206 val = (u_long)pcmd->argval[0].ival; 2207…
Large files files are truncated, but you can click here to view the full file