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: #include "ntp_assert.h"
20: #include "ntp_lineedit.h"
21: #include "ntp_debug.h"
22: #include "isc/net.h"
23: #include "isc/result.h"
24: #include <ssl_applink.c>
25:
26: #include "ntp_libopts.h"
27: #include "ntpq-opts.h"
28:
29: #ifdef SYS_WINNT
30: # include <Mswsock.h>
31: # include <io.h>
32: #endif /* SYS_WINNT */
33:
34: #ifdef SYS_VXWORKS
35: /* vxWorks needs mode flag -casey*/
36: # define open(name, flags) open(name, flags, 0777)
37: # define SERVER_PORT_NUM 123
38: #endif
39:
40: /* we use COMMAND as an autogen keyword */
41: #ifdef COMMAND
42: # undef COMMAND
43: #endif
44:
45: /*
46: * Because we potentially understand a lot of commands we will run
47: * interactive if connected to a terminal.
48: */
49: int interactive = 0; /* set to 1 when we should prompt */
50: const char *prompt = "ntpq> "; /* prompt to ask him about */
51:
52: /*
53: * use old readvars behavior? --old-rv processing in ntpq resets
54: * this value based on the presence or absence of --old-rv. It is
55: * initialized to 1 here to maintain backward compatibility with
56: * libntpq clients such as ntpsnmpd, which are free to reset it as
57: * desired.
58: */
59: int old_rv = 1;
60:
61:
62: /*
63: * for get_systime()
64: */
65: s_char sys_precision; /* local clock precision (log2 s) */
66:
67: /*
68: * Keyid used for authenticated requests. Obtained on the fly.
69: */
70: u_long info_auth_keyid = 0;
71:
72: static int info_auth_keytype = NID_md5; /* MD5 */
73: static size_t info_auth_hashlen = 16; /* MD5 */
74: u_long current_time; /* needed by authkeys; not used */
75:
76: /*
77: * Flag which indicates we should always send authenticated requests
78: */
79: int always_auth = 0;
80:
81: /*
82: * Flag which indicates raw mode output.
83: */
84: int rawmode = 0;
85:
86: /*
87: * Packet version number we use
88: */
89: u_char pktversion = NTP_OLDVERSION + 1;
90:
91: /*
92: * Don't jump if no set jmp.
93: */
94: volatile int jump = 0;
95:
96: /*
97: * Format values
98: */
99: #define PADDING 0
100: #define TS 1 /* time stamp */
101: #define FL 2 /* l_fp type value */
102: #define FU 3 /* u_fp type value */
103: #define FS 4 /* s_fp type value */
104: #define UI 5 /* unsigned integer value */
105: #define SI 6 /* signed integer value */
106: #define HA 7 /* host address */
107: #define NA 8 /* network address */
108: #define ST 9 /* string value */
109: #define RF 10 /* refid (sometimes string, sometimes not) */
110: #define LP 11 /* leap (print in binary) */
111: #define OC 12 /* integer, print in octal */
112: #define MD 13 /* mode */
113: #define AR 14 /* array of times */
114: #define FX 15 /* test flags */
115: #define EOV 255 /* end of table */
116:
117:
118: /*
119: * System variable values. The array can be indexed by
120: * the variable index to find the textual name.
121: */
122: struct ctl_var sys_var[] = {
123: { 0, PADDING, "" }, /* 0 */
124: { CS_LEAP, LP, "leap" }, /* 1 */
125: { CS_STRATUM, UI, "stratum" }, /* 2 */
126: { CS_PRECISION, SI, "precision" }, /* 3 */
127: { CS_ROOTDELAY, FS, "rootdelay" }, /* 4 */
128: { CS_ROOTDISPERSION, FU, "rootdispersion" }, /* 5 */
129: { CS_REFID, RF, "refid" }, /* 6 */
130: { CS_REFTIME, TS, "reftime" }, /* 7 */
131: { CS_POLL, UI, "poll" }, /* 8 */
132: { CS_PEERID, UI, "peer" }, /* 9 */
133: { CS_OFFSET, FL, "offset" }, /* 10 */
134: { CS_DRIFT, FS, "frequency" }, /* 11 */
135: { CS_JITTER, FU, "jitter" }, /* 12 */
136: { CS_CLOCK, TS, "clock" }, /* 13 */
137: { CS_PROCESSOR, ST, "processor" }, /* 14 */
138: { CS_SYSTEM, ST, "system" }, /* 15 */
139: { CS_VERSION, ST, "version" }, /* 16 */
140: { CS_STABIL, FS, "stability" }, /* 17 */
141: { CS_VARLIST, ST, "sys_var_list" }, /* 18 */
142: { 0, EOV, "" }
143: };
144:
145:
146: /*
147: * Peer variable list
148: */
149: struct 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, "rootdisp" }, /* 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: */
203: struct 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: */
224: static const char *tstflagnames[] = {
225: "pkt_dup", /* TEST1 */
226: "pkt_bogus", /* TEST2 */
227: "pkt_unsync", /* TEST3 */
228: "pkt_denied", /* TEST4 */
229: "pkt_auth", /* TEST5 */
230: "pkt_stratum", /* TEST6 */
231: "pkt_header", /* TEST7 */
232: "pkt_autokey", /* TEST8 */
233: "pkt_crypto", /* TEST9 */
234: "peer_stratum", /* TEST10 */
235: "peer_dist", /* TEST11 */
236: "peer_loop", /* TEST12 */
237: "peer_unreach" /* TEST13 */
238: };
239:
240:
241: int ntpqmain (int, char **);
242: /*
243: * Built in command handler declarations
244: */
245: static int openhost (const char *);
246:
247: static int sendpkt (void *, size_t);
248: static int getresponse (int, int, u_short *, int *, const char **, int);
249: static int sendrequest (int, int, int, int, char *);
250: static char * tstflags (u_long);
251: #ifndef BUILD_AS_LIB
252: static void getcmds (void);
253: #ifndef SYS_WINNT
254: static RETSIGTYPE abortcmd (int);
255: #endif /* SYS_WINNT */
256: static void docmd (const char *);
257: static void tokenize (const char *, char **, int *);
258: static int getarg (char *, int, arg_v *);
259: #endif /* BUILD_AS_LIB */
260: static int findcmd (char *, struct xcmd *, struct xcmd *, struct xcmd **);
261: static int rtdatetolfp (char *, l_fp *);
262: static int decodearr (char *, int *, l_fp *);
263: static void help (struct parse *, FILE *);
264: static int helpsort (const void *, const void *);
265: static void printusage (struct xcmd *, FILE *);
266: static void timeout (struct parse *, FILE *);
267: static void auth_delay (struct parse *, FILE *);
268: static void host (struct parse *, FILE *);
269: static void ntp_poll (struct parse *, FILE *);
270: static void keyid (struct parse *, FILE *);
271: static void keytype (struct parse *, FILE *);
272: static void passwd (struct parse *, FILE *);
273: static void hostnames (struct parse *, FILE *);
274: static void setdebug (struct parse *, FILE *);
275: static void quit (struct parse *, FILE *);
276: static void version (struct parse *, FILE *);
277: static void raw (struct parse *, FILE *);
278: static void cooked (struct parse *, FILE *);
279: static void authenticate (struct parse *, FILE *);
280: static void ntpversion (struct parse *, FILE *);
281: static void warning (const char *, const char *, const char *);
282: static void error (const char *, const char *, const char *);
283: static u_long getkeyid (const char *);
284: static void atoascii (const char *, size_t, char *, size_t);
285: static void cookedprint (int, int, const char *, int, int, FILE *);
286: static void rawprint (int, int, const char *, int, int, FILE *);
287: static void startoutput (void);
288: static void output (FILE *, char *, char *);
289: static void endoutput (FILE *);
290: static void outputarr (FILE *, char *, int, l_fp *);
291: static int assoccmp (const void *, const void *);
292: void ntpq_custom_opt_handler (tOptions *, tOptDesc *);
293:
294:
295: /*
296: * Built-in commands we understand
297: */
298: struct xcmd builtins[] = {
299: { "?", help, { OPT|NTP_STR, NO, NO, NO },
300: { "command", "", "", "" },
301: "tell the use and syntax of commands" },
302: { "help", help, { OPT|NTP_STR, NO, NO, NO },
303: { "command", "", "", "" },
304: "tell the use and syntax of commands" },
305: { "timeout", timeout, { OPT|NTP_UINT, NO, NO, NO },
306: { "msec", "", "", "" },
307: "set the primary receive time out" },
308: { "delay", auth_delay, { OPT|NTP_INT, NO, NO, NO },
309: { "msec", "", "", "" },
310: "set the delay added to encryption time stamps" },
311: { "host", host, { OPT|NTP_STR, OPT|NTP_STR, NO, NO },
312: { "-4|-6", "hostname", "", "" },
313: "specify the host whose NTP server we talk to" },
314: { "poll", ntp_poll, { OPT|NTP_UINT, OPT|NTP_STR, NO, NO },
315: { "n", "verbose", "", "" },
316: "poll an NTP server in client mode `n' times" },
317: { "passwd", passwd, { NO, NO, NO, NO },
318: { "", "", "", "" },
319: "specify a password to use for authenticated requests"},
320: { "hostnames", hostnames, { OPT|NTP_STR, NO, NO, NO },
321: { "yes|no", "", "", "" },
322: "specify whether hostnames or net numbers are printed"},
323: { "debug", setdebug, { OPT|NTP_STR, NO, NO, NO },
324: { "no|more|less", "", "", "" },
325: "set/change debugging level" },
326: { "quit", quit, { NO, NO, NO, NO },
327: { "", "", "", "" },
328: "exit ntpq" },
329: { "exit", quit, { NO, NO, NO, NO },
330: { "", "", "", "" },
331: "exit ntpq" },
332: { "keyid", keyid, { OPT|NTP_UINT, NO, NO, NO },
333: { "key#", "", "", "" },
334: "set keyid to use for authenticated requests" },
335: { "version", version, { NO, NO, NO, NO },
336: { "", "", "", "" },
337: "print version number" },
338: { "raw", raw, { NO, NO, NO, NO },
339: { "", "", "", "" },
340: "do raw mode variable output" },
341: { "cooked", cooked, { NO, NO, NO, NO },
342: { "", "", "", "" },
343: "do cooked mode variable output" },
344: { "authenticate", authenticate, { OPT|NTP_STR, NO, NO, NO },
345: { "yes|no", "", "", "" },
346: "always authenticate requests to this server" },
347: { "ntpversion", ntpversion, { OPT|NTP_UINT, NO, NO, NO },
348: { "version number", "", "", "" },
349: "set the NTP version number to use for requests" },
350: { "keytype", keytype, { OPT|NTP_STR, NO, NO, NO },
351: { "key type (md5|des)", "", "", "" },
352: "set key type to use for authenticated requests (des|md5)" },
353: { 0, 0, { NO, NO, NO, NO },
354: { "", "", "", "" }, "" }
355: };
356:
357:
358: /*
359: * Default values we use.
360: */
361: #define DEFHOST "localhost" /* default host name */
362: #define DEFTIMEOUT (5) /* 5 second time out */
363: #define DEFSTIMEOUT (2) /* 2 second time out after first */
364: #define DEFDELAY 0x51EB852 /* 20 milliseconds, l_fp fraction */
365: #define LENHOSTNAME 256 /* host name is 256 characters long */
366: #define MAXCMDS 100 /* maximum commands on cmd line */
367: #define MAXHOSTS 200 /* maximum hosts on cmd line */
368: #define MAXLINE 512 /* maximum line length */
369: #define MAXTOKENS (1+MAXARGS+2) /* maximum number of usable tokens */
370: #define MAXVARLEN 256 /* maximum length of a variable name */
371: #define MAXVALLEN 400 /* maximum length of a variable value */
372: #define MAXOUTLINE 72 /* maximum length of an output line */
373: #define SCREENWIDTH 76 /* nominal screen width in columns */
374:
375: /*
376: * Some variables used and manipulated locally
377: */
378: struct sock_timeval tvout = { DEFTIMEOUT, 0 }; /* time out for reads */
379: struct sock_timeval tvsout = { DEFSTIMEOUT, 0 };/* secondary time out */
380: l_fp delay_time; /* delay time */
381: char currenthost[LENHOSTNAME]; /* current host name */
382: int currenthostisnum; /* is prior text from IP? */
383: struct sockaddr_in hostaddr = { 0 }; /* host address */
384: int showhostnames = 1; /* show host names by default */
385:
386: int ai_fam_templ; /* address family */
387: int ai_fam_default; /* default address family */
388: SOCKET sockfd; /* fd socket is opened on */
389: int havehost = 0; /* set to 1 when host open */
390: int s_port = 0;
391: struct servent *server_entry = NULL; /* server entry for ntp */
392:
393:
394: /*
395: * Sequence number used for requests. It is incremented before
396: * it is used.
397: */
398: u_short sequence;
399:
400: /*
401: * Holds data returned from queries. Declare buffer long to be sure of
402: * alignment.
403: */
404: #define MAXFRAGS 24 /* maximum number of fragments */
405: #define DATASIZE (MAXFRAGS*480) /* maximum amount of data */
406: long pktdata[DATASIZE/sizeof(long)];
407:
408: /*
409: * Holds association data for use with the &n operator.
410: */
411: struct association assoc_cache[MAXASSOC];
412: int numassoc = 0; /* number of cached associations */
413:
414: /*
415: * For commands typed on the command line (with the -c option)
416: */
417: int numcmds = 0;
418: const char *ccmds[MAXCMDS];
419: #define ADDCMD(cp) if (numcmds < MAXCMDS) ccmds[numcmds++] = (cp)
420:
421: /*
422: * When multiple hosts are specified.
423: */
424: int numhosts = 0;
425: const char *chosts[MAXHOSTS];
426: #define ADDHOST(cp) if (numhosts < MAXHOSTS) chosts[numhosts++] = (cp)
427:
428: /*
429: * Error codes for internal use
430: */
431: #define ERR_UNSPEC 256
432: #define ERR_INCOMPLETE 257
433: #define ERR_TIMEOUT 258
434: #define ERR_TOOMUCH 259
435:
436: /*
437: * Macro definitions we use
438: */
439: #define ISSPACE(c) ((c) == ' ' || (c) == '\t')
440: #define ISEOL(c) ((c) == '\n' || (c) == '\r' || (c) == '\0')
441: #define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
442:
443: /*
444: * Jump buffer for longjumping back to the command level
445: */
446: jmp_buf interrupt_buf;
447:
448: /*
449: * Points at file being currently printed into
450: */
451: FILE *current_output;
452:
453: /*
454: * Command table imported from ntpdc_ops.c
455: */
456: extern struct xcmd opcmds[];
457:
458: char *progname;
459: volatile int debug;
460:
461: #ifdef NO_MAIN_ALLOWED
462: #ifndef BUILD_AS_LIB
463: CALL(ntpq,"ntpq",ntpqmain);
464:
465: void clear_globals(void)
466: {
467: extern int ntp_optind;
468: showhostnames = 0; /* don'tshow host names by default */
469: ntp_optind = 0;
470: server_entry = NULL; /* server entry for ntp */
471: havehost = 0; /* set to 1 when host open */
472: numassoc = 0; /* number of cached associations */
473: numcmds = 0;
474: numhosts = 0;
475: }
476: #endif /* !BUILD_AS_LIB */
477: #endif /* NO_MAIN_ALLOWED */
478:
479: /*
480: * main - parse arguments and handle options
481: */
482: #ifndef NO_MAIN_ALLOWED
483: int
484: main(
485: int argc,
486: char *argv[]
487: )
488: {
489: return ntpqmain(argc, argv);
490: }
491: #endif
492:
493: #ifndef BUILD_AS_LIB
494: int
495: ntpqmain(
496: int argc,
497: char *argv[]
498: )
499: {
500: extern int ntp_optind;
501:
502: #ifdef SYS_VXWORKS
503: clear_globals();
504: taskPrioritySet(taskIdSelf(), 100 );
505: #endif
506:
507: delay_time.l_ui = 0;
508: delay_time.l_uf = DEFDELAY;
509:
510: init_lib(); /* sets up ipv4_works, ipv6_works */
511: ssl_applink();
512:
513: /* Check to see if we have IPv6. Otherwise default to IPv4 */
514: if (!ipv6_works)
515: ai_fam_default = AF_INET;
516:
517: progname = argv[0];
518:
519: {
520: int optct = ntpOptionProcess(&ntpqOptions, argc, argv);
521: argc -= optct;
522: argv += optct;
523: }
524:
525: /*
526: * Process options other than -c and -p, which are specially
527: * handled by ntpq_custom_opt_handler().
528: */
529:
530: debug = DESC(DEBUG_LEVEL).optOccCt;
531:
532: if (HAVE_OPT(IPV4))
533: ai_fam_templ = AF_INET;
534: else if (HAVE_OPT(IPV6))
535: ai_fam_templ = AF_INET6;
536: else
537: ai_fam_templ = ai_fam_default;
538:
539: if (HAVE_OPT(INTERACTIVE))
540: interactive = 1;
541:
542: if (HAVE_OPT(NUMERIC))
543: showhostnames = 0;
544:
545: old_rv = HAVE_OPT(OLD_RV);
546:
547: #if 0
548: while ((c = ntp_getopt(argc, argv, "46c:dinp")) != EOF)
549: switch (c) {
550: case '4':
551: ai_fam_templ = AF_INET;
552: break;
553: case '6':
554: ai_fam_templ = AF_INET6;
555: break;
556: case 'c':
557: ADDCMD(ntp_optarg);
558: break;
559: case 'd':
560: ++debug;
561: break;
562: case 'i':
563: interactive = 1;
564: break;
565: case 'n':
566: showhostnames = 0;
567: break;
568: case 'p':
569: ADDCMD("peers");
570: break;
571: default:
572: errflg++;
573: break;
574: }
575: if (errflg) {
576: (void) fprintf(stderr,
577: "usage: %s [-46dinp] [-c cmd] host ...\n",
578: progname);
579: exit(2);
580: }
581: #endif
582: NTP_INSIST(ntp_optind <= argc);
583: if (ntp_optind == argc) {
584: ADDHOST(DEFHOST);
585: } else {
586: for (; ntp_optind < argc; ntp_optind++)
587: ADDHOST(argv[ntp_optind]);
588: }
589:
590: if (numcmds == 0 && interactive == 0
591: && isatty(fileno(stdin)) && isatty(fileno(stderr))) {
592: interactive = 1;
593: }
594:
595: #ifndef SYS_WINNT /* Under NT cannot handle SIGINT, WIN32 spawns a handler */
596: if (interactive)
597: (void) signal_no_reset(SIGINT, abortcmd);
598: #endif /* SYS_WINNT */
599:
600: if (numcmds == 0) {
601: (void) openhost(chosts[0]);
602: getcmds();
603: } else {
604: int ihost;
605: int icmd;
606:
607: for (ihost = 0; ihost < numhosts; ihost++) {
608: if (openhost(chosts[ihost]))
609: for (icmd = 0; icmd < numcmds; icmd++)
610: docmd(ccmds[icmd]);
611: }
612: }
613: #ifdef SYS_WINNT
614: WSACleanup();
615: #endif /* SYS_WINNT */
616: return 0;
617: }
618: #endif /* !BUILD_AS_LIB */
619:
620: /*
621: * openhost - open a socket to a host
622: */
623: static int
624: openhost(
625: const char *hname
626: )
627: {
628: char temphost[LENHOSTNAME];
629: int a_info, i;
630: struct addrinfo hints, *ai = NULL;
631: register const char *cp;
632: char name[LENHOSTNAME];
633: char service[5];
634:
635: /*
636: * We need to get by the [] if they were entered
637: */
638:
639: cp = hname;
640:
641: if (*cp == '[') {
642: cp++;
643: for (i = 0; *cp && *cp != ']'; cp++, i++)
644: name[i] = *cp;
645: if (*cp == ']') {
646: name[i] = '\0';
647: hname = name;
648: } else {
649: return 0;
650: }
651: }
652:
653: /*
654: * First try to resolve it as an ip address and if that fails,
655: * do a fullblown (dns) lookup. That way we only use the dns
656: * when it is needed and work around some implementations that
657: * will return an "IPv4-mapped IPv6 address" address if you
658: * give it an IPv4 address to lookup.
659: */
660: strcpy(service, "ntp");
661: ZERO(hints);
662: hints.ai_family = ai_fam_templ;
663: hints.ai_protocol = IPPROTO_UDP;
664: hints.ai_socktype = SOCK_DGRAM;
665: hints.ai_flags = Z_AI_NUMERICHOST;
666:
667: a_info = getaddrinfo(hname, service, &hints, &ai);
668: if (a_info == EAI_NONAME
669: #ifdef EAI_NODATA
670: || a_info == EAI_NODATA
671: #endif
672: ) {
673: hints.ai_flags = AI_CANONNAME;
674: #ifdef AI_ADDRCONFIG
675: hints.ai_flags |= AI_ADDRCONFIG;
676: #endif
677: a_info = getaddrinfo(hname, service, &hints, &ai);
678: }
679: #ifdef AI_ADDRCONFIG
680: /* Some older implementations don't like AI_ADDRCONFIG. */
681: if (a_info == EAI_BADFLAGS) {
682: hints.ai_flags = AI_CANONNAME;
683: a_info = getaddrinfo(hname, service, &hints, &ai);
684: }
685: #endif
686: if (a_info != 0) {
687: (void) fprintf(stderr, "%s\n", gai_strerror(a_info));
688: return 0;
689: }
690:
691: if (!showhostnames || ai->ai_canonname == NULL) {
692: strncpy(temphost,
693: stoa((sockaddr_u *)ai->ai_addr),
694: LENHOSTNAME);
695: currenthostisnum = TRUE;
696: } else {
697: strncpy(temphost, ai->ai_canonname, LENHOSTNAME);
698: currenthostisnum = FALSE;
699: }
700: temphost[LENHOSTNAME-1] = '\0';
701:
702: if (debug > 2)
703: printf("Opening host %s\n", temphost);
704:
705: if (havehost == 1) {
706: if (debug > 2)
707: printf("Closing old host %s\n", currenthost);
708: (void) closesocket(sockfd);
709: havehost = 0;
710: }
711: (void) strcpy(currenthost, temphost);
712:
713: /* port maps to the same location in both families */
714: s_port = ((struct sockaddr_in6 *)ai->ai_addr)->sin6_port;
715: #ifdef SYS_VXWORKS
716: ((struct sockaddr_in6 *)&hostaddr)->sin6_port = htons(SERVER_PORT_NUM);
717: if (ai->ai_family == AF_INET)
718: *(struct sockaddr_in *)&hostaddr=
719: *((struct sockaddr_in *)ai->ai_addr);
720: else
721: *(struct sockaddr_in6 *)&hostaddr=
722: *((struct sockaddr_in6 *)ai->ai_addr);
723: #endif /* SYS_VXWORKS */
724:
725: #ifdef SYS_WINNT
726: {
727: int optionValue = SO_SYNCHRONOUS_NONALERT;
728: int err;
729:
730: err = setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
731: (char *)&optionValue, sizeof(optionValue));
732: if (err) {
733: err = WSAGetLastError();
734: fprintf(stderr,
735: "setsockopt(SO_SYNCHRONOUS_NONALERT) "
736: "error: %s\n", strerror(err));
737: exit(1);
738: }
739: }
740: #endif /* SYS_WINNT */
741:
742: sockfd = socket(ai->ai_family, SOCK_DGRAM, 0);
743: if (sockfd == INVALID_SOCKET) {
744: error("socket", "", "");
745: }
746:
747:
748: #ifdef NEED_RCVBUF_SLOP
749: # ifdef SO_RCVBUF
750: { int rbufsize = DATASIZE + 2048; /* 2K for slop */
751: if (setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF,
752: &rbufsize, sizeof(int)) == -1)
753: error("setsockopt", "", "");
754: }
755: # endif
756: #endif
757:
758: #ifdef SYS_VXWORKS
759: if (connect(sockfd, (struct sockaddr *)&hostaddr,
760: sizeof(hostaddr)) == -1)
761: #else
762: if (connect(sockfd, (struct sockaddr *)ai->ai_addr,
763: ai->ai_addrlen) == -1)
764: #endif /* SYS_VXWORKS */
765: error("connect", "", "");
766: if (a_info == 0)
767: freeaddrinfo(ai);
768: havehost = 1;
769: return 1;
770: }
771:
772:
773: /* XXX ELIMINATE sendpkt similar in ntpq.c, ntpdc.c, ntp_io.c, ntptrace.c */
774: /*
775: * sendpkt - send a packet to the remote host
776: */
777: static int
778: sendpkt(
779: void * xdata,
780: size_t xdatalen
781: )
782: {
783: if (debug >= 3)
784: printf("Sending %lu octets\n", (u_long)xdatalen);
785:
786: if (send(sockfd, xdata, (size_t)xdatalen, 0) == -1) {
787: warning("write to %s failed", currenthost, "");
788: return -1;
789: }
790:
791: if (debug >= 4) {
792: int first = 8;
793: char *cdata = xdata;
794:
795: printf("Packet data:\n");
796: while (xdatalen-- > 0) {
797: if (first-- == 0) {
798: printf("\n");
799: first = 7;
800: }
801: printf(" %02x", *cdata++ & 0xff);
802: }
803: printf("\n");
804: }
805: return 0;
806: }
807:
808:
809:
810: /*
811: * getresponse - get a (series of) response packet(s) and return the data
812: */
813: static int
814: getresponse(
815: int opcode,
816: int associd,
817: u_short *rstatus,
818: int *rsize,
819: const char **rdata,
820: int timeo
821: )
822: {
823: struct ntp_control rpkt;
824: struct sock_timeval tvo;
825: u_short offsets[MAXFRAGS+1];
826: u_short counts[MAXFRAGS+1];
827: u_short offset;
828: u_short count;
829: size_t numfrags;
830: size_t f;
831: size_t ff;
832: int seenlastfrag;
833: int shouldbesize;
834: fd_set fds;
835: int n;
836: int len;
837: int first;
838: char *data;
839:
840: /*
841: * This is pretty tricky. We may get between 1 and MAXFRAG packets
842: * back in response to the request. We peel the data out of
843: * each packet and collect it in one long block. When the last
844: * packet in the sequence is received we'll know how much data we
845: * should have had. Note we use one long time out, should reconsider.
846: */
847: *rsize = 0;
848: if (rstatus)
849: *rstatus = 0;
850: *rdata = (char *)pktdata;
851:
852: numfrags = 0;
853: seenlastfrag = 0;
854:
855: FD_ZERO(&fds);
856:
857: /*
858: * Loop until we have an error or a complete response. Nearly all
859: * code paths to loop again use continue.
860: */
861: for (;;) {
862:
863: if (numfrags == 0)
864: tvo = tvout;
865: else
866: tvo = tvsout;
867:
868: FD_SET(sockfd, &fds);
869: n = select(sockfd + 1, &fds, NULL, NULL, &tvo);
870:
871: if (n == -1) {
872: warning("select fails", "", "");
873: return -1;
874: }
875: if (n == 0) {
876: /*
877: * Timed out. Return what we have
878: */
879: if (numfrags == 0) {
880: if (timeo)
881: fprintf(stderr,
882: "%s: timed out, nothing received\n",
883: currenthost);
884: return ERR_TIMEOUT;
885: }
886: if (timeo)
887: fprintf(stderr,
888: "%s: timed out with incomplete data\n",
889: currenthost);
890: if (debug) {
891: fprintf(stderr,
892: "ERR_INCOMPLETE: Received fragments:\n");
893: for (f = 0; f < numfrags; f++)
894: fprintf(stderr,
895: "%2u: %5d %5d\t%3d octets\n",
896: f, offsets[f],
897: offsets[f] +
898: counts[f],
899: counts[f]);
900: fprintf(stderr,
901: "last fragment %sreceived\n",
902: (seenlastfrag)
903: ? ""
904: : "not ");
905: }
906: return ERR_INCOMPLETE;
907: }
908:
909: n = recv(sockfd, (char *)&rpkt, sizeof(rpkt), 0);
910: if (n == -1) {
911: warning("read", "", "");
912: return -1;
913: }
914:
915: if (debug >= 4) {
916: len = n;
917: first = 8;
918: 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: continue;
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: continue;
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: continue;
951: }
952: if (!CTL_ISRESPONSE(rpkt.r_m_e_op)) {
953: if (debug)
954: printf("Received request packet, wanted response\n");
955: continue;
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("Received sequnce number %d, wanted %d\n",
965: ntohs(rpkt.sequence), sequence);
966: continue;
967: }
968: if (CTL_OP(rpkt.r_m_e_op) != opcode) {
969: if (debug)
970: printf(
971: "Received opcode %d, wanted %d (sequence number okay)\n",
972: CTL_OP(rpkt.r_m_e_op), opcode);
973: continue;
974: }
975:
976: /*
977: * Check the error code. If non-zero, return it.
978: */
979: if (CTL_ISERROR(rpkt.r_m_e_op)) {
980: int errcode;
981:
982: errcode = (ntohs(rpkt.status) >> 8) & 0xff;
983: if (debug && CTL_ISMORE(rpkt.r_m_e_op)) {
984: printf("Error code %d received on not-final packet\n",
985: errcode);
986: }
987: if (errcode == CERR_UNSPEC)
988: return ERR_UNSPEC;
989: return errcode;
990: }
991:
992: /*
993: * Check the association ID to make sure it matches what
994: * we sent.
995: */
996: if (ntohs(rpkt.associd) != associd) {
997: if (debug)
998: printf("Association ID %d doesn't match expected %d\n",
999: ntohs(rpkt.associd), associd);
1000: /*
1001: * Hack for silly fuzzballs which, at the time of writing,
1002: * return an assID of sys.peer when queried for system variables.
1003: */
1004: #ifdef notdef
1005: continue;
1006: #endif
1007: }
1008:
1009: /*
1010: * Collect offset and count. Make sure they make sense.
1011: */
1012: offset = ntohs(rpkt.offset);
1013: count = ntohs(rpkt.count);
1014:
1015: /*
1016: * validate received payload size is padded to next 32-bit
1017: * boundary and no smaller than claimed by rpkt.count
1018: */
1019: if (n & 0x3) {
1020: if (debug)
1021: printf("Response packet not padded, "
1022: "size = %d\n", n);
1023: continue;
1024: }
1025:
1026: shouldbesize = (CTL_HEADER_LEN + count + 3) & ~3;
1027:
1028: if (n < shouldbesize) {
1029: printf("Response packet claims %u octets "
1030: "payload, above %d received\n",
1031: count,
1032: n - CTL_HEADER_LEN
1033: );
1034: return ERR_INCOMPLETE;
1035: }
1036:
1037: if (debug >= 3 && shouldbesize > n) {
1038: u_int32 key;
1039: u_int32 *lpkt;
1040: int maclen;
1041:
1042: /*
1043: * Usually we ignore authentication, but for debugging purposes
1044: * we watch it here.
1045: */
1046: /* round to 8 octet boundary */
1047: shouldbesize = (shouldbesize + 7) & ~7;
1048:
1049: maclen = n - shouldbesize;
1050: if (maclen >= MIN_MAC_LEN) {
1051: printf(
1052: "Packet shows signs of authentication (total %d, data %d, mac %d)\n",
1053: n, shouldbesize, maclen);
1054: lpkt = (u_int32 *)&rpkt;
1055: printf("%08lx %08lx %08lx %08lx %08lx %08lx\n",
1056: (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_int32) - 3]),
1057: (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_int32) - 2]),
1058: (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_int32) - 1]),
1059: (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_int32)]),
1060: (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_int32) + 1]),
1061: (u_long)ntohl(lpkt[(n - maclen)/sizeof(u_int32) + 2]));
1062: key = ntohl(lpkt[(n - maclen) / sizeof(u_int32)]);
1063: printf("Authenticated with keyid %lu\n", (u_long)key);
1064: if (key != 0 && key != info_auth_keyid) {
1065: printf("We don't know that key\n");
1066: } else {
1067: if (authdecrypt(key, (u_int32 *)&rpkt,
1068: n - maclen, maclen)) {
1069: printf("Auth okay!\n");
1070: } else {
1071: printf("Auth failed!\n");
1072: }
1073: }
1074: }
1075: }
1076:
1077: if (debug >= 2)
1078: printf("Got packet, size = %d\n", n);
1079: if ((int)count > (n - CTL_HEADER_LEN)) {
1080: if (debug)
1081: printf("Received count of %d octets, "
1082: "data in packet is %d\n",
1083: count, n-CTL_HEADER_LEN);
1084: continue;
1085: }
1086: if (count == 0 && CTL_ISMORE(rpkt.r_m_e_op)) {
1087: if (debug)
1088: printf("Received count of 0 in non-final fragment\n");
1089: continue;
1090: }
1091: if (offset + count > sizeof(pktdata)) {
1092: if (debug)
1093: printf("Offset %d, count %d, too big for buffer\n",
1094: offset, count);
1095: return ERR_TOOMUCH;
1096: }
1097: if (seenlastfrag && !CTL_ISMORE(rpkt.r_m_e_op)) {
1098: if (debug)
1099: printf("Received second last fragment packet\n");
1100: continue;
1101: }
1102:
1103: /*
1104: * So far, so good. Record this fragment, making sure it doesn't
1105: * overlap anything.
1106: */
1107: if (debug >= 2)
1108: printf("Packet okay\n");;
1109:
1110: if (numfrags > (MAXFRAGS - 1)) {
1111: if (debug)
1112: printf("Number of fragments exceeds maximum %d\n",
1113: MAXFRAGS - 1);
1114: return ERR_TOOMUCH;
1115: }
1116:
1117: /*
1118: * Find the position for the fragment relative to any
1119: * previously received.
1120: */
1121: for (f = 0;
1122: f < numfrags && offsets[f] < offset;
1123: f++) {
1124: /* empty body */ ;
1125: }
1126:
1127: if (f < numfrags && offset == offsets[f]) {
1128: if (debug)
1129: printf("duplicate %u octets at %u ignored, prior %u at %u\n",
1130: count, offset, counts[f],
1131: offsets[f]);
1132: continue;
1133: }
1134:
1135: if (f > 0 && (offsets[f-1] + counts[f-1]) > offset) {
1136: if (debug)
1137: printf("received frag at %u overlaps with %u octet frag at %u\n",
1138: offset, counts[f-1],
1139: offsets[f-1]);
1140: continue;
1141: }
1142:
1143: if (f < numfrags && (offset + count) > offsets[f]) {
1144: if (debug)
1145: printf("received %u octet frag at %u overlaps with frag at %u\n",
1146: count, offset, offsets[f]);
1147: continue;
1148: }
1149:
1150: for (ff = numfrags; ff > f; ff--) {
1151: offsets[ff] = offsets[ff-1];
1152: counts[ff] = counts[ff-1];
1153: }
1154: offsets[f] = offset;
1155: counts[f] = count;
1156: numfrags++;
1157:
1158: /*
1159: * Got that stuffed in right. Figure out if this was the last.
1160: * Record status info out of the last packet.
1161: */
1162: if (!CTL_ISMORE(rpkt.r_m_e_op)) {
1163: seenlastfrag = 1;
1164: if (rstatus != 0)
1165: *rstatus = ntohs(rpkt.status);
1166: }
1167:
1168: /*
1169: * Copy the data into the data buffer.
1170: */
1171: memcpy((char *)pktdata + offset, rpkt.data, count);
1172:
1173: /*
1174: * If we've seen the last fragment, look for holes in the sequence.
1175: * If there aren't any, we're done.
1176: */
1177: if (seenlastfrag && offsets[0] == 0) {
1178: for (f = 1; f < numfrags; f++)
1179: if (offsets[f-1] + counts[f-1] !=
1180: offsets[f])
1181: break;
1182: if (f == numfrags) {
1183: *rsize = offsets[f-1] + counts[f-1];
1184: if (debug)
1185: fprintf(stderr,
1186: "%u packets reassembled into response\n",
1187: numfrags);
1188: return 0;
1189: }
1190: }
1191: } /* giant for (;;) collecting response packets */
1192: } /* getresponse() */
1193:
1194:
1195: /*
1196: * sendrequest - format and send a request packet
1197: */
1198: static int
1199: sendrequest(
1200: int opcode,
1201: int associd,
1202: int auth,
1203: int qsize,
1204: char *qdata
1205: )
1206: {
1207: struct ntp_control qpkt;
1208: int pktsize;
1209: u_long key_id;
1210: char * pass;
1211: int maclen;
1212:
1213: /*
1214: * Check to make sure the data will fit in one packet
1215: */
1216: if (qsize > CTL_MAX_DATA_LEN) {
1217: fprintf(stderr,
1218: "***Internal error! qsize (%d) too large\n",
1219: qsize);
1220: return 1;
1221: }
1222:
1223: /*
1224: * Fill in the packet
1225: */
1226: qpkt.li_vn_mode = PKT_LI_VN_MODE(0, pktversion, MODE_CONTROL);
1227: qpkt.r_m_e_op = (u_char)(opcode & CTL_OP_MASK);
1228: qpkt.sequence = htons(sequence);
1229: qpkt.status = 0;
1230: qpkt.associd = htons((u_short)associd);
1231: qpkt.offset = 0;
1232: qpkt.count = htons((u_short)qsize);
1233:
1234: pktsize = CTL_HEADER_LEN;
1235:
1236: /*
1237: * If we have data, copy and pad it out to a 32-bit boundary.
1238: */
1239: if (qsize > 0) {
1240: memcpy(qpkt.data, qdata, (size_t)qsize);
1241: pktsize += qsize;
1242: while (pktsize & (sizeof(u_int32) - 1)) {
1243: qpkt.data[qsize++] = 0;
1244: pktsize++;
1245: }
1246: }
1247:
1248: /*
1249: * If it isn't authenticated we can just send it. Otherwise
1250: * we're going to have to think about it a little.
1251: */
1252: if (!auth && !always_auth) {
1253: return sendpkt(&qpkt, pktsize);
1254: }
1255:
1256: /*
1257: * Pad out packet to a multiple of 8 octets to be sure
1258: * receiver can handle it.
1259: */
1260: while (pktsize & 7) {
1261: qpkt.data[qsize++] = 0;
1262: pktsize++;
1263: }
1264:
1265: /*
1266: * Get the keyid and the password if we don't have one.
1267: */
1268: if (info_auth_keyid == 0) {
1269: key_id = getkeyid("Keyid: ");
1270: if (key_id == 0 || key_id > NTP_MAXKEY) {
1271: fprintf(stderr,
1272: "Invalid key identifier\n");
1273: return 1;
1274: }
1275: info_auth_keyid = key_id;
1276: }
1277: if (!authistrusted(info_auth_keyid)) {
1278: pass = getpass_keytype(info_auth_keytype);
1279: if ('\0' == pass[0]) {
1280: fprintf(stderr, "Invalid password\n");
1281: return 1;
1282: }
1283: authusekey(info_auth_keyid, info_auth_keytype,
1284: (u_char *)pass);
1285: authtrust(info_auth_keyid, 1);
1286: }
1287:
1288: /*
1289: * Do the encryption.
1290: */
1291: maclen = authencrypt(info_auth_keyid, (void *)&qpkt, pktsize);
1292: if (!maclen) {
1293: fprintf(stderr, "Key not found\n");
1294: return 1;
1295: } else if ((size_t)maclen != (info_auth_hashlen + sizeof(keyid_t))) {
1296: fprintf(stderr,
1297: "%d octet MAC, %lu expected with %lu octet digest\n",
1298: maclen, (u_long)(info_auth_hashlen + sizeof(keyid_t)),
1299: (u_long)info_auth_hashlen);
1300: return 1;
1301: }
1302:
1303: return sendpkt((char *)&qpkt, pktsize + maclen);
1304: }
1305:
1306:
1307: /*
1308: * show_error_msg - display the error text for a mode 6 error response.
1309: */
1310: void
1311: show_error_msg(
1312: int m6resp,
1313: associd_t associd
1314: )
1315: {
1316: if (numhosts > 1)
1317: fprintf(stderr, "server=%s ", currenthost);
1318:
1319: switch(m6resp) {
1320:
1321: case CERR_BADFMT:
1322: fprintf(stderr,
1323: "***Server reports a bad format request packet\n");
1324: break;
1325:
1326: case CERR_PERMISSION:
1327: fprintf(stderr,
1328: "***Server disallowed request (authentication?)\n");
1329: break;
1330:
1331: case CERR_BADOP:
1332: fprintf(stderr,
1333: "***Server reports a bad opcode in request\n");
1334: break;
1335:
1336: case CERR_BADASSOC:
1337: fprintf(stderr,
1338: "***Association ID %d unknown to server\n",
1339: associd);
1340: break;
1341:
1342: case CERR_UNKNOWNVAR:
1343: fprintf(stderr,
1344: "***A request variable unknown to the server\n");
1345: break;
1346:
1347: case CERR_BADVALUE:
1348: fprintf(stderr,
1349: "***Server indicates a request variable was bad\n");
1350: break;
1351:
1352: case ERR_UNSPEC:
1353: fprintf(stderr,
1354: "***Server returned an unspecified error\n");
1355: break;
1356:
1357: case ERR_TIMEOUT:
1358: fprintf(stderr, "***Request timed out\n");
1359: break;
1360:
1361: case ERR_INCOMPLETE:
1362: fprintf(stderr,
1363: "***Response from server was incomplete\n");
1364: break;
1365:
1366: case ERR_TOOMUCH:
1367: fprintf(stderr,
1368: "***Buffer size exceeded for returned data\n");
1369: break;
1370:
1371: default:
1372: fprintf(stderr,
1373: "***Server returns unknown error code %d\n",
1374: m6resp);
1375: }
1376: }
1377:
1378: /*
1379: * doquery - send a request and process the response, displaying
1380: * error messages for any error responses.
1381: */
1382: int
1383: doquery(
1384: int opcode,
1385: associd_t associd,
1386: int auth,
1387: int qsize,
1388: char *qdata,
1389: u_short *rstatus,
1390: int *rsize,
1391: const char **rdata
1392: )
1393: {
1394: return doqueryex(opcode, associd, auth, qsize, qdata, rstatus,
1395: rsize, rdata, FALSE);
1396: }
1397:
1398:
1399: /*
1400: * doqueryex - send a request and process the response, optionally
1401: * displaying error messages for any error responses.
1402: */
1403: int
1404: doqueryex(
1405: int opcode,
1406: associd_t associd,
1407: int auth,
1408: int qsize,
1409: char *qdata,
1410: u_short *rstatus,
1411: int *rsize,
1412: const char **rdata,
1413: int quiet
1414: )
1415: {
1416: int res;
1417: int done;
1418:
1419: /*
1420: * Check to make sure host is open
1421: */
1422: if (!havehost) {
1423: fprintf(stderr, "***No host open, use `host' command\n");
1424: return -1;
1425: }
1426:
1427: done = 0;
1428: sequence++;
1429:
1430: again:
1431: /*
1432: * send a request
1433: */
1434: res = sendrequest(opcode, associd, auth, qsize, qdata);
1435: if (res != 0)
1436: return res;
1437:
1438: /*
1439: * Get the response. If we got a standard error, print a message
1440: */
1441: res = getresponse(opcode, associd, rstatus, rsize, rdata, done);
1442:
1443: if (res > 0) {
1444: if (!done && (res == ERR_TIMEOUT || res == ERR_INCOMPLETE)) {
1445: if (res == ERR_INCOMPLETE) {
1446: /*
1447: * better bump the sequence so we don't
1448: * get confused about differing fragments.
1449: */
1450: sequence++;
1451: }
1452: done = 1;
1453: goto again;
1454: }
1455: if (!quiet)
1456: show_error_msg(res, associd);
1457:
1458: }
1459: return res;
1460: }
1461:
1462:
1463: #ifndef BUILD_AS_LIB
1464: /*
1465: * getcmds - read commands from the standard input and execute them
1466: */
1467: static void
1468: getcmds(void)
1469: {
1470: char * line;
1471: int count;
1472:
1473: ntp_readline_init(interactive ? prompt : NULL);
1474:
1475: for (;;) {
1476: line = ntp_readline(&count);
1477: if (NULL == line)
1478: break;
1479: docmd(line);
1480: free(line);
1481: }
1482:
1483: ntp_readline_uninit();
1484: }
1485: #endif /* !BUILD_AS_LIB */
1486:
1487:
1488: #if !defined(SYS_WINNT) && !defined(BUILD_AS_LIB)
1489: /*
1490: * abortcmd - catch interrupts and abort the current command
1491: */
1492: static RETSIGTYPE
1493: abortcmd(
1494: int sig
1495: )
1496: {
1497: if (current_output == stdout)
1498: (void) fflush(stdout);
1499: putc('\n', stderr);
1500: (void) fflush(stderr);
1501: if (jump) longjmp(interrupt_buf, 1);
1502: }
1503: #endif /* !SYS_WINNT && !BUILD_AS_LIB */
1504:
1505:
1506: #ifndef BUILD_AS_LIB
1507: /*
1508: * docmd - decode the command line and execute a command
1509: */
1510: static void
1511: docmd(
1512: const char *cmdline
1513: )
1514: {
1515: char *tokens[1+MAXARGS+2];
1516: struct parse pcmd;
1517: int ntok;
1518: static int i;
1519: struct xcmd *xcmd;
1520:
1521: /*
1522: * Tokenize the command line. If nothing on it, return.
1523: */
1524: tokenize(cmdline, tokens, &ntok);
1525: if (ntok == 0)
1526: return;
1527:
1528: /*
1529: * Find the appropriate command description.
1530: */
1531: i = findcmd(tokens[0], builtins, opcmds, &xcmd);
1532: if (i == 0) {
1533: (void) fprintf(stderr, "***Command `%s' unknown\n",
1534: tokens[0]);
1535: return;
1536: } else if (i >= 2) {
1537: (void) fprintf(stderr, "***Command `%s' ambiguous\n",
1538: tokens[0]);
1539: return;
1540: }
1541:
1542: /*
1543: * Save the keyword, then walk through the arguments, interpreting
1544: * as we go.
1545: */
1546: pcmd.keyword = tokens[0];
1547: pcmd.nargs = 0;
1548: for (i = 0; i < MAXARGS && xcmd->arg[i] != NO; i++) {
1549: if ((i+1) >= ntok) {
1550: if (!(xcmd->arg[i] & OPT)) {
1551: printusage(xcmd, stderr);
1552: return;
1553: }
1554: break;
1555: }
1556: if ((xcmd->arg[i] & OPT) && (*tokens[i+1] == '>'))
1557: break;
1558: if (!getarg(tokens[i+1], (int)xcmd->arg[i], &pcmd.argval[i]))
1559: return;
1560: pcmd.nargs++;
1561: }
1562:
1563: i++;
1564: if (i < ntok && *tokens[i] == '>') {
1565: char *fname;
1566:
1567: if (*(tokens[i]+1) != '\0')
1568: fname = tokens[i]+1;
1569: else if ((i+1) < ntok)
1570: fname = tokens[i+1];
1571: else {
1572: (void) fprintf(stderr, "***No file for redirect\n");
1573: return;
1574: }
1575:
1576: current_output = fopen(fname, "w");
1577: if (current_output == NULL) {
1578: (void) fprintf(stderr, "***Error opening %s: ", fname);
1579: perror("");
1580: return;
1581: }
1582: i = 1; /* flag we need a close */
1583: } else {
1584: current_output = stdout;
1585: i = 0; /* flag no close */
1586: }
1587:
1588: if (interactive && setjmp(interrupt_buf)) {
1589: jump = 0;
1590: return;
1591: } else {
1592: jump++;
1593: (xcmd->handler)(&pcmd, current_output);
1594: jump = 0; /* HMS: 961106: was after fclose() */
1595: if (i) (void) fclose(current_output);
1596: }
1597: }
1598:
1599:
1600: /*
1601: * tokenize - turn a command line into tokens
1602: *
1603: * SK: Modified to allow a quoted string
1604: *
1605: * HMS: If the first character of the first token is a ':' then (after
1606: * eating inter-token whitespace) the 2nd token is the rest of the line.
1607: */
1608:
1609: static void
1610: tokenize(
1611: const char *line,
1612: char **tokens,
1613: int *ntok
1614: )
1615: {
1616: register const char *cp;
1617: register char *sp;
1618: static char tspace[MAXLINE];
1619:
1620: sp = tspace;
1621: cp = line;
1622: for (*ntok = 0; *ntok < MAXTOKENS; (*ntok)++) {
1623: tokens[*ntok] = sp;
1624:
1625: /* Skip inter-token whitespace */
1626: while (ISSPACE(*cp))
1627: cp++;
1628:
1629: /* If we're at EOL we're done */
1630: if (ISEOL(*cp))
1631: break;
1632:
1633: /* If this is the 2nd token and the first token begins
1634: * with a ':', then just grab to EOL.
1635: */
1636:
1637: if (*ntok == 1 && tokens[0][0] == ':') {
1638: do {
1639: *sp++ = *cp++;
1640: } while (!ISEOL(*cp));
1641: }
1642:
1643: /* Check if this token begins with a double quote.
1644: * If yes, continue reading till the next double quote
1645: */
1646: else if (*cp == '\"') {
1647: ++cp;
1648: do {
1649: *sp++ = *cp++;
1650: } while ((*cp != '\"') && !ISEOL(*cp));
1651: /* HMS: a missing closing " should be an error */
1652: }
1653: else {
1654: do {
1655: *sp++ = *cp++;
1656: } while ((*cp != '\"') && !ISSPACE(*cp) && !ISEOL(*cp));
1657: /* HMS: Why check for a " in the previous line? */
1658: }
1659:
1660: *sp++ = '\0';
1661: }
1662: }
1663:
1664:
1665: /*
1666: * getarg - interpret an argument token
1667: */
1668: static int
1669: getarg(
1670: char *str,
1671: int code,
1672: arg_v *argp
1673: )
1674: {
1675: int isneg;
1676: char *cp, *np;
1677: static const char *digits = "0123456789";
1678:
1679: switch (code & ~OPT) {
1680: case NTP_STR:
1681: argp->string = str;
1682: break;
1683: case NTP_ADD:
1684: if (!getnetnum(str, &(argp->netnum), (char *)0, 0)) {
1685: return 0;
1686: }
1687: break;
1688: case NTP_INT:
1689: case NTP_UINT:
1690: isneg = 0;
1691: np = str;
1692: if (*np == '&') {
1693: np++;
1694: isneg = atoi(np);
1695: if (isneg <= 0) {
1696: (void) fprintf(stderr,
1697: "***Association value `%s' invalid/undecodable\n", str);
1698: return 0;
1699: }
1700: if (isneg > numassoc) {
1701: if (numassoc == 0) {
1702: (void) fprintf(stderr,
1703: "***Association for `%s' unknown (max &%d)\n",
1704: str, numassoc);
1705: return 0;
1706: } else {
1707: isneg = numassoc;
1708: }
1709: }
1710: argp->uval = assoc_cache[isneg-1].assid;
1711: break;
1712: }
1713:
1714: if (*np == '-') {
1715: np++;
1716: isneg = 1;
1717: }
1718:
1719: argp->uval = 0;
1720: do {
1721: cp = strchr(digits, *np);
1722: if (cp == NULL) {
1723: (void) fprintf(stderr,
1724: "***Illegal integer value %s\n", str);
1725: return 0;
1726: }
1727: argp->uval *= 10;
1728: argp->uval += (cp - digits);
1729: } while (*(++np) != '\0');
1730:
1731: if (isneg) {
1732: if ((code & ~OPT) == NTP_UINT) {
1733: (void) fprintf(stderr,
1734: "***Value %s should be unsigned\n", str);
1735: return 0;
1736: }
1737: argp->ival = -argp->ival;
1738: }
1739: break;
1740: case IP_VERSION:
1741: if (!strcmp("-6", str))
1742: argp->ival = 6 ;
1743: else if (!strcmp("-4", str))
1744: argp->ival = 4 ;
1745: else {
1746: (void) fprintf(stderr,
1747: "***Version must be either 4 or 6\n");
1748: return 0;
1749: }
1750: break;
1751: }
1752:
1753: return 1;
1754: }
1755: #endif /* !BUILD_AS_LIB */
1756:
1757:
1758: /*
1759: * findcmd - find a command in a command description table
1760: */
1761: static int
1762: findcmd(
1763: register char *str,
1764: struct xcmd *clist1,
1765: struct xcmd *clist2,
1766: struct xcmd **cmd
1767: )
1768: {
1769: register struct xcmd *cl;
1770: register int clen;
1771: int nmatch;
1772: struct xcmd *nearmatch = NULL;
1773: struct xcmd *clist;
1774:
1775: clen = strlen(str);
1776: nmatch = 0;
1777: if (clist1 != 0)
1778: clist = clist1;
1779: else if (clist2 != 0)
1780: clist = clist2;
1781: else
1782: return 0;
1783:
1784: again:
1785: for (cl = clist; cl->keyword != 0; cl++) {
1786: /* do a first character check, for efficiency */
1787: if (*str != *(cl->keyword))
1788: continue;
1789: if (strncmp(str, cl->keyword, (unsigned)clen) == 0) {
1790: /*
1791: * Could be extact match, could be approximate.
1792: * Is exact if the length of the keyword is the
1793: * same as the str.
1794: */
1795: if (*((cl->keyword) + clen) == '\0') {
1796: *cmd = cl;
1797: return 1;
1798: }
1799: nmatch++;
1800: nearmatch = cl;
1801: }
1802: }
1803:
1804: /*
1805: * See if there is more to do. If so, go again. Sorry about the
1806: * goto, too much looking at BSD sources...
1807: */
1808: if (clist == clist1 && clist2 != 0) {
1809: clist = clist2;
1810: goto again;
1811: }
1812:
1813: /*
1814: * If we got extactly 1 near match, use it, else return number
1815: * of matches.
1816: */
1817: if (nmatch == 1) {
1818: *cmd = nearmatch;
1819: return 1;
1820: }
1821: return nmatch;
1822: }
1823:
1824:
1825: /*
1826: * getnetnum - given a host name, return its net number
1827: * and (optional) full name
1828: */
1829: int
1830: getnetnum(
1831: const char *hname,
1832: sockaddr_u *num,
1833: char *fullhost,
1834: int af
1835: )
1836: {
1837: struct addrinfo hints, *ai = NULL;
1838:
1839: ZERO(hints);
1840: hints.ai_flags = AI_CANONNAME;
1841: #ifdef AI_ADDRCONFIG
1842: hints.ai_flags |= AI_ADDRCONFIG;
1843: #endif
1844:
1845: /*
1846: * decodenetnum only works with addresses, but handles syntax
1847: * that getaddrinfo doesn't: [2001::1]:1234
1848: */
1849: if (decodenetnum(hname, num)) {
1850: if (fullhost != NULL)
1851: getnameinfo(&num->sa, SOCKLEN(num), fullhost,
1852: LENHOSTNAME, NULL, 0, 0);
1853: return 1;
1854: } else if (getaddrinfo(hname, "ntp", &hints, &ai) == 0) {
1855: NTP_INSIST(sizeof(*num) >= ai->ai_addrlen);
1856: memcpy(num, ai->ai_addr, ai->ai_addrlen);
1857: if (fullhost != NULL) {
1858: if (ai->ai_canonname != NULL) {
1859: strncpy(fullhost, ai->ai_canonname,
1860: LENHOSTNAME);
1861: fullhost[LENHOSTNAME - 1] = '\0';
1862: } else {
1863: getnameinfo(&num->sa, SOCKLEN(num),
1864: fullhost, LENHOSTNAME, NULL,
1865: 0, 0);
1866: }
1867: }
1868: return 1;
1869: }
1870: fprintf(stderr, "***Can't find host %s\n", hname);
1871:
1872: return 0;
1873: }
1874:
1875: /*
1876: * nntohost - convert network number to host name. This routine enforces
1877: * the showhostnames setting.
1878: */
1879: char *
1880: nntohost(
1881: sockaddr_u *netnum
1882: )
1883: {
1884: return nntohost_col(netnum, LIB_BUFLENGTH - 1, FALSE);
1885: }
1886:
1887:
1888: /*
1889: * nntohost_col - convert network number to host name in fixed width.
1890: * This routine enforces the showhostnames setting.
1891: * When displaying hostnames longer than the width,
1892: * the first part of the hostname is displayed. When
1893: * displaying numeric addresses longer than the width,
1894: * Such as IPv6 addresses, the caller decides whether
1895: * the first or last of the numeric address is used.
1896: */
1897: char *
1898: nntohost_col(
1899: sockaddr_u * addr,
1900: size_t width,
1901: int preserve_lowaddrbits
1902: )
1903: {
1904: const char * out;
1905:
1906: if (!showhostnames) {
1907: if (preserve_lowaddrbits)
1908: out = trunc_left(stoa(addr), width);
1909: else
1910: out = trunc_right(stoa(addr), width);
1911: } else if (ISREFCLOCKADR(addr)) {
1912: out = refnumtoa(addr);
1913: } else {
1914: out = trunc_right(socktohost(addr), width);
1915: }
1916: return out;
1917: }
1918:
1919:
1920: /*
1921: * rtdatetolfp - decode an RT-11 date into an l_fp
1922: */
1923: static int
1924: rtdatetolfp(
1925: char *str,
1926: l_fp *lfp
1927: )
1928: {
1929: register char *cp;
1930: register int i;
1931: struct calendar cal;
1932: char buf[4];
1933: static const char *months[12] = {
1934: "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1935: "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
1936: };
1937:
1938: cal.yearday = 0;
1939:
1940: /*
1941: * An RT-11 date looks like:
1942: *
1943: * d[d]-Mth-y[y] hh:mm:ss
1944: *
1945: * (No docs, but assume 4-digit years are also legal...)
1946: *
1947: * d[d]-Mth-y[y[y[y]]] hh:mm:ss
1948: */
1949: cp = str;
1950: if (!isdigit((int)*cp)) {
1951: if (*cp == '-') {
1952: /*
1953: * Catch special case
1954: */
1955: L_CLR(lfp);
1956: return 1;
1957: }
1958: return 0;
1959: }
1960:
1961: cal.monthday = (u_char) (*cp++ - '0'); /* ascii dependent */
1962: if (isdigit((int)*cp)) {
1963: cal.monthday = (u_char)((cal.monthday << 3) + (cal.monthday << 1));
1964: cal.monthday = (u_char)(cal.monthday + *cp++ - '0');
1965: }
1966:
1967: if (*cp++ != '-')
1968: return 0;
1969:
1970: for (i = 0; i < 3; i++)
1971: buf[i] = *cp++;
1972: buf[3] = '\0';
1973:
1974: for (i = 0; i < 12; i++)
1975: if (STREQ(buf, months[i]))
1976: break;
1977: if (i == 12)
1978: return 0;
1979: cal.month = (u_char)(i + 1);
1980:
1981: if (*cp++ != '-')
1982: return 0;
1983:
1984: if (!isdigit((int)*cp))
1985: return 0;
1986: cal.year = (u_short)(*cp++ - '0');
1987: if (isdigit((int)*cp)) {
1988: cal.year = (u_short)((cal.year << 3) + (cal.year << 1));
1989: cal.year = (u_short)(*cp++ - '0');
1990: }
1991: if (isdigit((int)*cp)) {
1992: cal.year = (u_short)((cal.year << 3) + (cal.year << 1));
1993: cal.year = (u_short)(cal.year + *cp++ - '0');
1994: }
1995: if (isdigit((int)*cp)) {
1996: cal.year = (u_short)((cal.year << 3) + (cal.year << 1));
1997: cal.year = (u_short)(cal.year + *cp++ - '0');
1998: }
1999:
2000: /*
2001: * Catch special case. If cal.year == 0 this is a zero timestamp.
2002: */
2003: if (cal.year == 0) {
2004: L_CLR(lfp);
2005: return 1;
2006: }
2007:
2008: if (*cp++ != ' ' || !isdigit((int)*cp))
2009: return 0;
2010: cal.hour = (u_char)(*cp++ - '0');
2011: if (isdigit((int)*cp)) {
2012: cal.hour = (u_char)((cal.hour << 3) + (cal.hour << 1));
2013: cal.hour = (u_char)(cal.hour + *cp++ - '0');
2014: }
2015:
2016: if (*cp++ != ':' || !isdigit((int)*cp))
2017: return 0;
2018: cal.minute = (u_char)(*cp++ - '0');
2019: if (isdigit((int)*cp)) {
2020: cal.minute = (u_char)((cal.minute << 3) + (cal.minute << 1));
2021: cal.minute = (u_char)(cal.minute + *cp++ - '0');
2022: }
2023:
2024: if (*cp++ != ':' || !isdigit((int)*cp))
2025: return 0;
2026: cal.second = (u_char)(*cp++ - '0');
2027: if (isdigit((int)*cp)) {
2028: cal.second = (u_char)((cal.second << 3) + (cal.second << 1));
2029: cal.second = (u_char)(cal.second + *cp++ - '0');
2030: }
2031:
2032: /*
2033: * For RT-11, 1972 seems to be the pivot year
2034: */
2035: if (cal.year < 72)
2036: cal.year += 2000;
2037: if (cal.year < 100)
2038: cal.year += 1900;
2039:
2040: lfp->l_ui = caltontp(&cal);
2041: lfp->l_uf = 0;
2042: return 1;
2043: }
2044:
2045:
2046: /*
2047: * decodets - decode a timestamp into an l_fp format number, with
2048: * consideration of fuzzball formats.
2049: */
2050: int
2051: decodets(
2052: char *str,
2053: l_fp *lfp
2054: )
2055: {
2056: char *cp;
2057: char buf[30];
2058: size_t b;
2059:
2060: /*
2061: * If it starts with a 0x, decode as hex.
2062: */
2063: if (*str == '0' && (*(str+1) == 'x' || *(str+1) == 'X'))
2064: return hextolfp(str+2, lfp);
2065:
2066: /*
2067: * If it starts with a '"', try it as an RT-11 date.
2068: */
2069: if (*str == '"') {
2070: cp = str + 1;
2071: b = 0;
2072: while ('"' != *cp && '\0' != *cp &&
2073: b < COUNTOF(buf) - 1)
2074: buf[b++] = *cp++;
2075: buf[b] = '\0';
2076: return rtdatetolfp(buf, lfp);
2077: }
2078:
2079: /*
2080: * Might still be hex. Check out the first character. Talk
2081: * about heuristics!
2082: */
2083: if ((*str >= 'A' && *str <= 'F') || (*str >= 'a' && *str <= 'f'))
2084: return hextolfp(str, lfp);
2085:
2086: /*
2087: * Try it as a decimal. If this fails, try as an unquoted
2088: * RT-11 date. This code should go away eventually.
2089: */
2090: if (atolfp(str, lfp))
2091: return 1;
2092:
2093: return rtdatetolfp(str, lfp);
2094: }
2095:
2096:
2097: /*
2098: * decodetime - decode a time value. It should be in milliseconds
2099: */
2100: int
2101: decodetime(
2102: char *str,
2103: l_fp *lfp
2104: )
2105: {
2106: return mstolfp(str, lfp);
2107: }
2108:
2109:
2110: /*
2111: * decodeint - decode an integer
2112: */
2113: int
2114: decodeint(
2115: char *str,
2116: long *val
2117: )
2118: {
2119: if (*str == '0') {
2120: if (*(str+1) == 'x' || *(str+1) == 'X')
2121: return hextoint(str+2, (u_long *)val);
2122: return octtoint(str, (u_long *)val);
2123: }
2124: return atoint(str, val);
2125: }
2126:
2127:
2128: /*
2129: * decodeuint - decode an unsigned integer
2130: */
2131: int
2132: decodeuint(
2133: char *str,
2134: u_long *val
2135: )
2136: {
2137: if (*str == '0') {
2138: if (*(str + 1) == 'x' || *(str + 1) == 'X')
2139: return (hextoint(str + 2, val));
2140: return (octtoint(str, val));
2141: }
2142: return (atouint(str, val));
2143: }
2144:
2145:
2146: /*
2147: * decodearr - decode an array of time values
2148: */
2149: static int
2150: decodearr(
2151: char *str,
2152: int *narr,
2153: l_fp *lfparr
2154: )
2155: {
2156: register char *cp, *bp;
2157: register l_fp *lfp;
2158: char buf[60];
2159:
2160: lfp = lfparr;
2161: cp = str;
2162: *narr = 0;
2163:
2164: while (*narr < 8) {
2165: while (isspace((int)*cp))
2166: cp++;
2167: if (*cp == '\0')
2168: break;
2169:
2170: bp = buf;
2171: while (!isspace((int)*cp) && *cp != '\0')
2172: *bp++ = *cp++;
2173: *bp++ = '\0';
2174:
2175: if (!decodetime(buf, lfp))
2176: return 0;
2177: (*narr)++;
2178: lfp++;
2179: }
2180: return 1;
2181: }
2182:
2183:
2184: /*
2185: * Finally, the built in command handlers
2186: */
2187:
2188: /*
2189: * help - tell about commands, or details of a particular command
2190: */
2191: static void
2192: help(
2193: struct parse *pcmd,
2194: FILE *fp
2195: )
2196: {
2197: struct xcmd *xcp = NULL; /* quiet warning */
2198: char *cmd;
2199: const char *list[100];
2200: size_t word, words;
2201: size_t row, rows;
2202: size_t col, cols;
2203: size_t length;
2204:
2205: if (pcmd->nargs == 0) {
2206: words = 0;
2207: for (xcp = builtins; xcp->keyword != NULL; xcp++) {
2208: if (*(xcp->keyword) != '?')
2209: list[words++] = xcp->keyword;
2210: }
2211: for (xcp = opcmds; xcp->keyword != NULL; xcp++)
2212: list[words++] = xcp->keyword;
2213:
2214: qsort((void *)list, (size_t)words, sizeof(list[0]),
2215: helpsort);
2216: col = 0;
2217: for (word = 0; word < words; word++) {
2218: length = strlen(list[word]);
2219: col = max(col, length);
2220: }
2221:
2222: cols = SCREENWIDTH / ++col;
2223: rows = (words + cols - 1) / cols;
2224:
2225: fprintf(fp, "ntpq commands:\n");
2226:
2227: for (row = 0; row < rows; row++) {
2228: for (word = row; word < words; word += rows)
2229: fprintf(fp, "%-*.*s", col, col-1,
2230: list[word]);
2231: fprintf(fp, "\n");
2232: }
2233: } else {
2234: cmd = pcmd->argval[0].string;
2235: words = findcmd(cmd, builtins, opcmds, &xcp);
2236: if (words == 0) {
2237: fprintf(stderr,
2238: "Command `%s' is unknown\n", cmd);
2239: return;
2240: } else if (words >= 2) {
2241: fprintf(stderr,
2242: "Command `%s' is ambiguous\n", cmd);
2243: return;
2244: }
2245: fprintf(fp, "function: %s\n", xcp->comment);
2246: printusage(xcp, fp);
2247: }
2248: }
2249:
2250:
2251: /*
2252: * helpsort - do hostname qsort comparisons
2253: */
2254: static int
2255: helpsort(
2256: const void *t1,
2257: const void *t2
2258: )
2259: {
2260: const char * const * name1 = t1;
2261: const char * const * name2 = t2;
2262:
2263: return strcmp(*name1, *name2);
2264: }
2265:
2266:
2267: /*
2268: * printusage - print usage information for a command
2269: */
2270: static void
2271: printusage(
2272: struct xcmd *xcp,
2273: FILE *fp
2274: )
2275: {
2276: register int i;
2277:
2278: (void) fprintf(fp, "usage: %s", xcp->keyword);
2279: for (i = 0; i < MAXARGS && xcp->arg[i] != NO; i++) {
2280: if (xcp->arg[i] & OPT)
2281: (void) fprintf(fp, " [ %s ]", xcp->desc[i]);
2282: else
2283: (void) fprintf(fp, " %s", xcp->desc[i]);
2284: }
2285: (void) fprintf(fp, "\n");
2286: }
2287:
2288:
2289: /*
2290: * timeout - set time out time
2291: */
2292: static void
2293: timeout(
2294: struct parse *pcmd,
2295: FILE *fp
2296: )
2297: {
2298: int val;
2299:
2300: if (pcmd->nargs == 0) {
2301: val = (int)tvout.tv_sec * 1000 + tvout.tv_usec / 1000;
2302: (void) fprintf(fp, "primary timeout %d ms\n", val);
2303: } else {
2304: tvout.tv_sec = pcmd->argval[0].uval / 1000;
2305: tvout.tv_usec = (pcmd->argval[0].uval - ((long)tvout.tv_sec * 1000))
2306: * 1000;
2307: }
2308: }
2309:
2310:
2311: /*
2312: * auth_delay - set delay for auth requests
2313: */
2314: static void
2315: auth_delay(
2316: struct parse *pcmd,
2317: FILE *fp
2318: )
2319: {
2320: int isneg;
2321: u_long val;
2322:
2323: if (pcmd->nargs == 0) {
2324: val = delay_time.l_ui * 1000 + delay_time.l_uf / 4294967;
2325: (void) fprintf(fp, "delay %lu ms\n", val);
2326: } else {
2327: if (pcmd->argval[0].ival < 0) {
2328: isneg = 1;
2329: val = (u_long)(-pcmd->argval[0].ival);
2330: } else {
2331: isneg = 0;
2332: val = (u_long)pcmd->argval[0].ival;
2333: }
2334:
2335: delay_time.l_ui = val / 1000;
2336: val %= 1000;
2337: delay_time.l_uf = val * 4294967; /* 2**32/1000 */
2338:
2339: if (isneg)
2340: L_NEG(&delay_time);
2341: }
2342: }
2343:
2344:
2345: /*
2346: * host - set the host we are dealing with.
2347: */
2348: static void
2349: host(
2350: struct parse *pcmd,
2351: FILE *fp
2352: )
2353: {
2354: int i;
2355:
2356: if (pcmd->nargs == 0) {
2357: if (havehost)
2358: (void) fprintf(fp, "current host is %s\n",
2359: currenthost);
2360: else
2361: (void) fprintf(fp, "no current host\n");
2362: return;
2363: }
2364:
2365: i = 0;
2366: ai_fam_templ = ai_fam_default;
2367: if (pcmd->nargs == 2) {
2368: if (!strcmp("-4", pcmd->argval[i].string))
2369: ai_fam_templ = AF_INET;
2370: else if (!strcmp("-6", pcmd->argval[i].string))
2371: ai_fam_templ = AF_INET6;
2372: else {
2373: if (havehost)
2374: (void) fprintf(fp,
2375: "current host remains %s\n",
2376: currenthost);
2377: else
2378: (void) fprintf(fp, "still no current host\n");
2379: return;
2380: }
2381: i = 1;
2382: }
2383: if (openhost(pcmd->argval[i].string)) {
2384: (void) fprintf(fp, "current host set to %s\n", currenthost);
2385: numassoc = 0;
2386: } else {
2387: if (havehost)
2388: (void) fprintf(fp,
2389: "current host remains %s\n",
2390: currenthost);
2391: else
2392: (void) fprintf(fp, "still no current host\n");
2393: }
2394: }
2395:
2396:
2397: /*
2398: * poll - do one (or more) polls of the host via NTP
2399: */
2400: /*ARGSUSED*/
2401: static void
2402: ntp_poll(
2403: struct parse *pcmd,
2404: FILE *fp
2405: )
2406: {
2407: (void) fprintf(fp, "poll not implemented yet\n");
2408: }
2409:
2410:
2411: /*
2412: * keyid - get a keyid to use for authenticating requests
2413: */
2414: static void
2415: keyid(
2416: struct parse *pcmd,
2417: FILE *fp
2418: )
2419: {
2420: if (pcmd->nargs == 0) {
2421: if (info_auth_keyid == 0)
2422: (void) fprintf(fp, "no keyid defined\n");
2423: else
2424: (void) fprintf(fp, "keyid is %lu\n", (u_long)info_auth_keyid);
2425: } else {
2426: /* allow zero so that keyid can be cleared. */
2427: if(pcmd->argval[0].uval > NTP_MAXKEY)
2428: (void) fprintf(fp, "Invalid key identifier\n");
2429: info_auth_keyid = pcmd->argval[0].uval;
2430: }
2431: }
2432:
2433: /*
2434: * keytype - get type of key to use for authenticating requests
2435: */
2436: static void
2437: keytype(
2438: struct parse *pcmd,
2439: FILE *fp
2440: )
2441: {
2442: const char * digest_name;
2443: size_t digest_len;
2444: int key_type;
2445:
2446: if (!pcmd->nargs) {
2447: fprintf(fp, "keytype is %s with %lu octet digests\n",
2448: keytype_name(info_auth_keytype),
2449: (u_long)info_auth_hashlen);
2450: return;
2451: }
2452:
2453: digest_name = pcmd->argval[0].string;
2454: digest_len = 0;
2455: key_type = keytype_from_text(digest_name, &digest_len);
2456:
2457: if (!key_type) {
2458: fprintf(fp, "keytype must be 'md5'%s\n",
2459: #ifdef OPENSSL
2460: " or a digest type provided by OpenSSL");
2461: #else
2462: "");
2463: #endif
2464: return;
2465: }
2466:
2467: info_auth_keytype = key_type;
2468: info_auth_hashlen = digest_len;
2469: }
2470:
2471:
2472: /*
2473: * passwd - get an authentication key
2474: */
2475: /*ARGSUSED*/
2476: static void
2477: passwd(
2478: struct parse *pcmd,
2479: FILE *fp
2480: )
2481: {
2482: char *pass;
2483:
2484: if (info_auth_keyid == 0) {
2485: int u_keyid = getkeyid("Keyid: ");
2486: if (u_keyid == 0 || u_keyid > NTP_MAXKEY) {
2487: (void)fprintf(fp, "Invalid key identifier\n");
2488: return;
2489: }
2490: info_auth_keyid = u_keyid;
2491: }
2492: if (pcmd->nargs >= 1)
2493: pass = pcmd->argval[0].string;
2494: else {
2495: pass = getpass_keytype(info_auth_keytype);
2496: if ('\0' == pass[0]) {
2497: fprintf(fp, "Password unchanged\n");
2498: return;
2499: }
2500: }
2501: authusekey(info_auth_keyid, info_auth_keytype, (u_char *)pass);
2502: authtrust(info_auth_keyid, 1);
2503: }
2504:
2505:
2506: /*
2507: * hostnames - set the showhostnames flag
2508: */
2509: static void
2510: hostnames(
2511: struct parse *pcmd,
2512: FILE *fp
2513: )
2514: {
2515: if (pcmd->nargs == 0) {
2516: if (showhostnames)
2517: (void) fprintf(fp, "hostnames being shown\n");
2518: else
2519: (void) fprintf(fp, "hostnames not being shown\n");
2520: } else {
2521: if (STREQ(pcmd->argval[0].string, "yes"))
2522: showhostnames = 1;
2523: else if (STREQ(pcmd->argval[0].string, "no"))
2524: showhostnames = 0;
2525: else
2526: (void)fprintf(stderr, "What?\n");
2527: }
2528: }
2529:
2530:
2531:
2532: /*
2533: * setdebug - set/change debugging level
2534: */
2535: static void
2536: setdebug(
2537: struct parse *pcmd,
2538: FILE *fp
2539: )
2540: {
2541: if (pcmd->nargs == 0) {
2542: (void) fprintf(fp, "debug level is %d\n", debug);
2543: return;
2544: } else if (STREQ(pcmd->argval[0].string, "no")) {
2545: debug = 0;
2546: } else if (STREQ(pcmd->argval[0].string, "more")) {
2547: debug++;
2548: } else if (STREQ(pcmd->argval[0].string, "less")) {
2549: debug--;
2550: } else {
2551: (void) fprintf(fp, "What?\n");
2552: return;
2553: }
2554: (void) fprintf(fp, "debug level set to %d\n", debug);
2555: }
2556:
2557:
2558: /*
2559: * quit - stop this nonsense
2560: */
2561: /*ARGSUSED*/
2562: static void
2563: quit(
2564: struct parse *pcmd,
2565: FILE *fp
2566: )
2567: {
2568: if (havehost)
2569: closesocket(sockfd); /* cleanliness next to godliness */
2570: exit(0);
2571: }
2572:
2573:
2574: /*
2575: * version - print the current version number
2576: */
2577: /*ARGSUSED*/
2578: static void
2579: version(
2580: struct parse *pcmd,
2581: FILE *fp
2582: )
2583: {
2584:
2585: (void) fprintf(fp, "%s\n", Version);
2586: return;
2587: }
2588:
2589:
2590: /*
2591: * raw - set raw mode output
2592: */
2593: /*ARGSUSED*/
2594: static void
2595: raw(
2596: struct parse *pcmd,
2597: FILE *fp
2598: )
2599: {
2600: rawmode = 1;
2601: (void) fprintf(fp, "Output set to raw\n");
2602: }
2603:
2604:
2605: /*
2606: * cooked - set cooked mode output
2607: */
2608: /*ARGSUSED*/
2609: static void
2610: cooked(
2611: struct parse *pcmd,
2612: FILE *fp
2613: )
2614: {
2615: rawmode = 0;
2616: (void) fprintf(fp, "Output set to cooked\n");
2617: return;
2618: }
2619:
2620:
2621: /*
2622: * authenticate - always authenticate requests to this host
2623: */
2624: static void
2625: authenticate(
2626: struct parse *pcmd,
2627: FILE *fp
2628: )
2629: {
2630: if (pcmd->nargs == 0) {
2631: if (always_auth) {
2632: (void) fprintf(fp,
2633: "authenticated requests being sent\n");
2634: } else
2635: (void) fprintf(fp,
2636: "unauthenticated requests being sent\n");
2637: } else {
2638: if (STREQ(pcmd->argval[0].string, "yes")) {
2639: always_auth = 1;
2640: } else if (STREQ(pcmd->argval[0].string, "no")) {
2641: always_auth = 0;
2642: } else
2643: (void)fprintf(stderr, "What?\n");
2644: }
2645: }
2646:
2647:
2648: /*
2649: * ntpversion - choose the NTP version to use
2650: */
2651: static void
2652: ntpversion(
2653: struct parse *pcmd,
2654: FILE *fp
2655: )
2656: {
2657: if (pcmd->nargs == 0) {
2658: (void) fprintf(fp,
2659: "NTP version being claimed is %d\n", pktversion);
2660: } else {
2661: if (pcmd->argval[0].uval < NTP_OLDVERSION
2662: || pcmd->argval[0].uval > NTP_VERSION) {
2663: (void) fprintf(stderr, "versions %d to %d, please\n",
2664: NTP_OLDVERSION, NTP_VERSION);
2665: } else {
2666: pktversion = (u_char) pcmd->argval[0].uval;
2667: }
2668: }
2669: }
2670:
2671:
2672: /*
2673: * warning - print a warning message
2674: */
2675: static void
2676: warning(
2677: const char *fmt,
2678: const char *st1,
2679: const char *st2
2680: )
2681: {
2682: (void) fprintf(stderr, "%s: ", progname);
2683: (void) fprintf(stderr, fmt, st1, st2);
2684: (void) fprintf(stderr, ": ");
2685: perror("");
2686: }
2687:
2688:
2689: /*
2690: * error - print a message and exit
2691: */
2692: static void
2693: error(
2694: const char *fmt,
2695: const char *st1,
2696: const char *st2
2697: )
2698: {
2699: warning(fmt, st1, st2);
2700: exit(1);
2701: }
2702:
2703: /*
2704: * getkeyid - prompt the user for a keyid to use
2705: */
2706: static u_long
2707: getkeyid(
2708: const char *keyprompt
2709: )
2710: {
2711: int c;
2712: FILE *fi;
2713: char pbuf[20];
2714: size_t i;
2715: size_t ilim;
2716:
2717: #ifndef SYS_WINNT
2718: if ((fi = fdopen(open("/dev/tty", 2), "r")) == NULL)
2719: #else
2720: if ((fi = _fdopen(open("CONIN$", _O_TEXT), "r")) == NULL)
2721: #endif /* SYS_WINNT */
2722: fi = stdin;
2723: else
2724: setbuf(fi, (char *)NULL);
2725: fprintf(stderr, "%s", keyprompt); fflush(stderr);
2726: for (i = 0, ilim = COUNTOF(pbuf) - 1;
2727: i < ilim && (c = getc(fi)) != '\n' && c != EOF;
2728: )
2729: pbuf[i++] = (char)c;
2730: pbuf[i] = '\0';
2731: if (fi != stdin)
2732: fclose(fi);
2733:
2734: return (u_long) atoi(pbuf);
2735: }
2736:
2737:
2738: /*
2739: * atoascii - printable-ize possibly ascii data using the character
2740: * transformations cat -v uses.
2741: */
2742: static void
2743: atoascii(
2744: const char *in,
2745: size_t in_octets,
2746: char *out,
2747: size_t out_octets
2748: )
2749: {
2750: register const u_char * pchIn;
2751: const u_char * pchInLimit;
2752: register u_char * pchOut;
2753: register u_char c;
2754:
2755: pchIn = (const u_char *)in;
2756: pchInLimit = pchIn + in_octets;
2757: pchOut = (u_char *)out;
2758:
2759: if (NULL == pchIn) {
2760: if (0 < out_octets)
2761: *pchOut = '\0';
2762: return;
2763: }
2764:
2765: #define ONEOUT(c) \
2766: do { \
2767: if (0 == --out_octets) { \
2768: *pchOut = '\0'; \
2769: return; \
2770: } \
2771: *pchOut++ = (c); \
2772: } while (0)
2773:
2774: for ( ; pchIn < pchInLimit; pchIn++) {
2775: c = *pchIn;
2776: if ('\0' == c)
2777: break;
2778: if (c & 0x80) {
2779: ONEOUT('M');
2780: ONEOUT('-');
2781: c &= 0x7f;
2782: }
2783: if (c < ' ') {
2784: ONEOUT('^');
2785: ONEOUT((u_char)(c + '@'));
2786: } else if (0x7f == c) {
2787: ONEOUT('^');
2788: ONEOUT('?');
2789: } else
2790: ONEOUT(c);
2791: }
2792: ONEOUT('\0');
2793:
2794: #undef ONEOUT
2795: }
2796:
2797:
2798: /*
2799: * makeascii - print possibly ascii data using the character
2800: * transformations that cat -v uses.
2801: */
2802: void
2803: makeascii(
2804: int length,
2805: const char *data,
2806: FILE *fp
2807: )
2808: {
2809: const u_char *data_u_char;
2810: const u_char *cp;
2811: int c;
2812:
2813: data_u_char = (const u_char *)data;
2814:
2815: for (cp = data_u_char; cp < data_u_char + length; cp++) {
2816: c = (int)*cp;
2817: if (c & 0x80) {
2818: putc('M', fp);
2819: putc('-', fp);
2820: c &= 0x7f;
2821: }
2822:
2823: if (c < ' ') {
2824: putc('^', fp);
2825: putc(c + '@', fp);
2826: } else if (0x7f == c) {
2827: putc('^', fp);
2828: putc('?', fp);
2829: } else
2830: putc(c, fp);
2831: }
2832: }
2833:
2834:
2835: /*
2836: * asciize - same thing as makeascii except add a newline
2837: */
2838: void
2839: asciize(
2840: int length,
2841: char *data,
2842: FILE *fp
2843: )
2844: {
2845: makeascii(length, data, fp);
2846: putc('\n', fp);
2847: }
2848:
2849:
2850: /*
2851: * truncate string to fit clipping excess at end.
2852: * "too long" -> "too l"
2853: * Used for hostnames.
2854: */
2855: char *
2856: trunc_right(
2857: const char * src,
2858: size_t width
2859: )
2860: {
2861: size_t sl;
2862: char * out;
2863:
2864:
2865: sl = strlen(src);
2866: if (sl > width && LIB_BUFLENGTH - 1 > width && width > 0) {
2867: LIB_GETBUF(out);
2868: memcpy(out, src, width);
2869: out[width] = '\0';
2870:
2871: return out;
2872: }
2873:
2874: return src;
2875: }
2876:
2877:
2878: /*
2879: * truncate string to fit by preserving right side and using '_' to hint
2880: * "too long" -> "_long"
2881: * Used for local IPv6 addresses, where low bits differentiate.
2882: */
2883: char *
2884: trunc_left(
2885: const char * src,
2886: size_t width
2887: )
2888: {
2889: size_t sl;
2890: char * out;
2891:
2892:
2893: sl = strlen(src);
2894: if (sl > width && LIB_BUFLENGTH - 1 > width && width > 1) {
2895: LIB_GETBUF(out);
2896: out[0] = '_';
2897: memcpy(&out[1], &src[sl + 1 - width], width);
2898:
2899: return out;
2900: }
2901:
2902: return src;
2903: }
2904:
2905:
2906: /*
2907: * Some circular buffer space
2908: */
2909: #define CBLEN 80
2910: #define NUMCB 6
2911:
2912: char circ_buf[NUMCB][CBLEN];
2913: int nextcb = 0;
2914:
2915: /*
2916: * nextvar - find the next variable in the buffer
2917: */
2918: int
2919: nextvar(
2920: int *datalen,
2921: const char **datap,
2922: char **vname,
2923: char **vvalue
2924: )
2925: {
2926: const char *cp;
2927: char *np;
2928: const char *cpend;
2929: char *npend; /* character after last */
2930: int quoted = 0;
2931: static char name[MAXVARLEN];
2932: static char value[MAXVALLEN];
2933:
2934: cp = *datap;
2935: cpend = cp + *datalen;
2936:
2937: /*
2938: * Space past commas and white space
2939: */
2940: while (cp < cpend && (*cp == ',' || isspace((int)*cp)))
2941: cp++;
2942: if (cp == cpend)
2943: return 0;
2944:
2945: /*
2946: * Copy name until we hit a ',', an '=', a '\r' or a '\n'. Backspace
2947: * over any white space and terminate it.
2948: */
2949: np = name;
2950: npend = &name[MAXVARLEN];
2951: while (cp < cpend && np < npend && *cp != ',' && *cp != '='
2952: && *cp != '\r' && *cp != '\n')
2953: *np++ = *cp++;
2954: /*
2955: * Check if we ran out of name space, without reaching the end or a
2956: * terminating character
2957: */
2958: if (np == npend && !(cp == cpend || *cp == ',' || *cp == '=' ||
2959: *cp == '\r' || *cp == '\n'))
2960: return 0;
2961: while (isspace((int)(*(np-1))))
2962: np--;
2963: *np = '\0';
2964: *vname = name;
2965:
2966: /*
2967: * Check if we hit the end of the buffer or a ','. If so we are done.
2968: */
2969: if (cp == cpend || *cp == ',' || *cp == '\r' || *cp == '\n') {
2970: if (cp != cpend)
2971: cp++;
2972: *datap = cp;
2973: *datalen = cpend - cp;
2974: *vvalue = (char *)0;
2975: return 1;
2976: }
2977:
2978: /*
2979: * So far, so good. Copy out the value
2980: */
2981: cp++; /* past '=' */
2982: while (cp < cpend && (isspace((int)*cp) && *cp != '\r' && *cp != '\n'))
2983: cp++;
2984: np = value;
2985: npend = &value[MAXVALLEN];
2986: while (cp < cpend && np < npend && ((*cp != ',') || quoted))
2987: {
2988: quoted ^= ((*np++ = *cp++) == '"');
2989: }
2990:
2991: /*
2992: * Check if we overran the value buffer while still in a quoted string
2993: * or without finding a comma
2994: */
2995: if (np == npend && (quoted || *cp != ','))
2996: return 0;
2997: /*
2998: * Trim off any trailing whitespace
2999: */
3000: while (np > value && isspace((int)(*(np-1))))
3001: np--;
3002: *np = '\0';
3003:
3004: /*
3005: * Return this. All done.
3006: */
3007: if (cp != cpend)
3008: cp++;
3009: *datap = cp;
3010: *datalen = cpend - cp;
3011: *vvalue = value;
3012: return 1;
3013: }
3014:
3015:
3016: /*
3017: * findvar - see if this variable is known to us.
3018: * If "code" is 1, return ctl_var->code.
3019: * Otherwise return the ordinal position of the found variable.
3020: */
3021: int
3022: findvar(
3023: char *varname,
3024: struct ctl_var *varlist,
3025: int code
3026: )
3027: {
3028: register char *np;
3029: register struct ctl_var *vl;
3030:
3031: vl = varlist;
3032: np = varname;
3033: while (vl->fmt != EOV) {
3034: if (vl->fmt != PADDING && STREQ(np, vl->text))
3035: return (code)
3036: ? vl->code
3037: : (vl - varlist)
3038: ;
3039: vl++;
3040: }
3041: return 0;
3042: }
3043:
3044:
3045:
3046: /*
3047: * printvars - print variables returned in response packet
3048: */
3049: void
3050: printvars(
3051: int length,
3052: const char *data,
3053: int status,
3054: int sttype,
3055: int quiet,
3056: FILE *fp
3057: )
3058: {
3059: if (rawmode)
3060: rawprint(sttype, length, data, status, quiet, fp);
3061: else
3062: cookedprint(sttype, length, data, status, quiet, fp);
3063: }
3064:
3065:
3066: /*
3067: * rawprint - do a printout of the data in raw mode
3068: */
3069: static void
3070: rawprint(
3071: int datatype,
3072: int length,
3073: const char *data,
3074: int status,
3075: int quiet,
3076: FILE *fp
3077: )
3078: {
3079: const char *cp;
3080: const char *cpend;
3081:
3082: /*
3083: * Essentially print the data as is. We reformat unprintables, though.
3084: */
3085: cp = data;
3086: cpend = data + length;
3087:
3088: if (!quiet)
3089: (void) fprintf(fp, "status=0x%04x,\n", status);
3090:
3091: while (cp < cpend) {
3092: if (*cp == '\r') {
3093: /*
3094: * If this is a \r and the next character is a
3095: * \n, supress this, else pretty print it. Otherwise
3096: * just output the character.
3097: */
3098: if (cp == (cpend - 1) || *(cp + 1) != '\n')
3099: makeascii(1, cp, fp);
3100: } else if (isspace(*cp) || isprint(*cp))
3101: putc(*cp, fp);
3102: else
3103: makeascii(1, cp, fp);
3104: cp++;
3105: }
3106: }
3107:
3108:
3109: /*
3110: * Global data used by the cooked output routines
3111: */
3112: int out_chars; /* number of characters output */
3113: int out_linecount; /* number of characters output on this line */
3114:
3115:
3116: /*
3117: * startoutput - get ready to do cooked output
3118: */
3119: static void
3120: startoutput(void)
3121: {
3122: out_chars = 0;
3123: out_linecount = 0;
3124: }
3125:
3126:
3127: /*
3128: * output - output a variable=value combination
3129: */
3130: static void
3131: output(
3132: FILE *fp,
3133: char *name,
3134: char *value
3135: )
3136: {
3137: size_t len;
3138:
3139: /* strlen of "name=value" */
3140: len = strlen(name) + 1 + strlen(value);
3141:
3142: if (out_chars != 0) {
3143: out_chars += 2;
3144: if ((out_linecount + len + 2) > MAXOUTLINE) {
3145: fputs(",\n", fp);
3146: out_linecount = 0;
3147: } else {
3148: fputs(", ", fp);
3149: out_linecount += 2;
3150: }
3151: }
3152:
3153: fputs(name, fp);
3154: putc('=', fp);
3155: fputs(value, fp);
3156: out_chars += len;
3157: out_linecount += len;
3158: }
3159:
3160:
3161: /*
3162: * endoutput - terminate a block of cooked output
3163: */
3164: static void
3165: endoutput(
3166: FILE *fp
3167: )
3168: {
3169: if (out_chars != 0)
3170: putc('\n', fp);
3171: }
3172:
3173:
3174: /*
3175: * outputarr - output an array of values
3176: */
3177: static void
3178: outputarr(
3179: FILE *fp,
3180: char *name,
3181: int narr,
3182: l_fp *lfp
3183: )
3184: {
3185: register char *bp;
3186: register char *cp;
3187: register int i;
3188: register int len;
3189: char buf[256];
3190:
3191: bp = buf;
3192: /*
3193: * Hack to align delay and offset values
3194: */
3195: for (i = (int)strlen(name); i < 11; i++)
3196: *bp++ = ' ';
3197:
3198: for (i = narr; i > 0; i--) {
3199: if (i != narr)
3200: *bp++ = ' ';
3201: cp = lfptoms(lfp, 2);
3202: len = strlen(cp);
3203: if (len > 7) {
3204: cp[7] = '\0';
3205: len = 7;
3206: }
3207: while (len < 7) {
3208: *bp++ = ' ';
3209: len++;
3210: }
3211: while (*cp != '\0')
3212: *bp++ = *cp++;
3213: lfp++;
3214: }
3215: *bp = '\0';
3216: output(fp, name, buf);
3217: }
3218:
3219: static char *
3220: tstflags(
3221: u_long val
3222: )
3223: {
3224: register char *cp, *s;
3225: size_t cb;
3226: register int i;
3227: register const char *sep;
3228:
3229: sep = "";
3230: i = 0;
3231: s = cp = circ_buf[nextcb];
3232: if (++nextcb >= NUMCB)
3233: nextcb = 0;
3234: cb = sizeof(circ_buf[0]);
3235:
3236: snprintf(cp, cb, "%02lx", val);
3237: cp += strlen(cp);
3238: cb -= strlen(cp);
3239: if (!val) {
3240: strncat(cp, " ok", cb);
3241: cp += strlen(cp);
3242: cb -= strlen(cp);
3243: } else {
3244: if (cb) {
3245: *cp++ = ' ';
3246: cb--;
3247: }
3248: for (i = 0; i < COUNTOF(tstflagnames); i++) {
3249: if (val & 0x1) {
3250: snprintf(cp, cb, "%s%s", sep,
3251: tstflagnames[i]);
3252: sep = ", ";
3253: cp += strlen(cp);
3254: cb -= strlen(cp);
3255: }
3256: val >>= 1;
3257: }
3258: }
3259: if (cb)
3260: *cp = '\0';
3261:
3262: return s;
3263: }
3264:
3265: /*
3266: * cookedprint - output variables in cooked mode
3267: */
3268: static void
3269: cookedprint(
3270: int datatype,
3271: int length,
3272: const char *data,
3273: int status,
3274: int quiet,
3275: FILE *fp
3276: )
3277: {
3278: register int varid;
3279: char *name;
3280: char *value;
3281: char output_raw;
3282: int fmt;
3283: struct ctl_var *varlist;
3284: l_fp lfp;
3285: long ival;
3286: sockaddr_u hval;
3287: u_long uval;
3288: l_fp lfparr[8];
3289: int narr;
3290:
3291: switch (datatype) {
3292: case TYPE_PEER:
3293: varlist = peer_var;
3294: break;
3295: case TYPE_SYS:
3296: varlist = sys_var;
3297: break;
3298: case TYPE_CLOCK:
3299: varlist = clock_var;
3300: break;
3301: default:
3302: fprintf(stderr, "Unknown datatype(0x%x) in cookedprint\n",
3303: datatype);
3304: return;
3305: }
3306:
3307: if (!quiet)
3308: fprintf(fp, "status=%04x %s,\n", status,
3309: statustoa(datatype, status));
3310:
3311: startoutput();
3312: while (nextvar(&length, &data, &name, &value)) {
3313: varid = findvar(name, varlist, 0);
3314: if (varid == 0) {
3315: output_raw = '*';
3316: } else {
3317: output_raw = 0;
3318: fmt = varlist[varid].fmt;
3319: switch(fmt) {
3320: case TS:
3321: if (!decodets(value, &lfp))
3322: output_raw = '?';
3323: else
3324: output(fp, name, prettydate(&lfp));
3325: break;
3326: case FL:
3327: case FU:
3328: case FS:
3329: if (!decodetime(value, &lfp))
3330: output_raw = '?';
3331: else {
3332: switch (fmt) {
3333: case FL:
3334: output(fp, name,
3335: lfptoms(&lfp, 3));
3336: break;
3337: case FU:
3338: output(fp, name,
3339: ulfptoms(&lfp, 3));
3340: break;
3341: case FS:
3342: output(fp, name,
3343: lfptoms(&lfp, 3));
3344: break;
3345: }
3346: }
3347: break;
3348:
3349: case UI:
3350: if (!decodeuint(value, &uval))
3351: output_raw = '?';
3352: else
3353: output(fp, name, uinttoa(uval));
3354: break;
3355:
3356: case SI:
3357: if (!decodeint(value, &ival))
3358: output_raw = '?';
3359: else
3360: output(fp, name, inttoa(ival));
3361: break;
3362:
3363: case HA:
3364: case NA:
3365: if (!decodenetnum(value, &hval))
3366: output_raw = '?';
3367: else if (fmt == HA){
3368: output(fp, name, nntohost(&hval));
3369: } else {
3370: output(fp, name, stoa(&hval));
3371: }
3372: break;
3373:
3374: case ST:
3375: output_raw = '*';
3376: break;
3377:
3378: case RF:
3379: if (decodenetnum(value, &hval)) {
3380: if (ISREFCLOCKADR(&hval))
3381: output(fp, name,
3382: refnumtoa(&hval));
3383: else
3384: output(fp, name, stoa(&hval));
3385: } else if ((int)strlen(value) <= 4)
3386: output(fp, name, value);
3387: else
3388: output_raw = '?';
3389: break;
3390:
3391: case LP:
3392: if (!decodeuint(value, &uval) || uval > 3)
3393: output_raw = '?';
3394: else {
3395: char b[3];
3396: b[0] = b[1] = '0';
3397: if (uval & 0x2)
3398: b[0] = '1';
3399: if (uval & 0x1)
3400: b[1] = '1';
3401: b[2] = '\0';
3402: output(fp, name, b);
3403: }
3404: break;
3405:
3406: case OC:
3407: if (!decodeuint(value, &uval))
3408: output_raw = '?';
3409: else {
3410: char b[12];
3411:
3412: (void) snprintf(b, sizeof b, "%03lo", uval);
3413: output(fp, name, b);
3414: }
3415: break;
3416:
3417: case MD:
3418: if (!decodeuint(value, &uval))
3419: output_raw = '?';
3420: else
3421: output(fp, name, uinttoa(uval));
3422: break;
3423:
3424: case AR:
3425: if (!decodearr(value, &narr, lfparr))
3426: output_raw = '?';
3427: else
3428: outputarr(fp, name, narr, lfparr);
3429: break;
3430:
3431: case FX:
3432: if (!decodeuint(value, &uval))
3433: output_raw = '?';
3434: else
3435: output(fp, name, tstflags(uval));
3436: break;
3437:
3438: default:
3439: (void) fprintf(stderr,
3440: "Internal error in cookedprint, %s=%s, fmt %d\n",
3441: name, value, fmt);
3442: break;
3443: }
3444:
3445: }
3446: if (output_raw != 0) {
3447: char bn[401];
3448: char bv[401];
3449: int len;
3450:
3451: atoascii(name, MAXVARLEN, bn, sizeof(bn));
3452: atoascii(value, MAXVARLEN, bv, sizeof(bv));
3453: if (output_raw != '*') {
3454: len = strlen(bv);
3455: bv[len] = output_raw;
3456: bv[len+1] = '\0';
3457: }
3458: output(fp, bn, bv);
3459: }
3460: }
3461: endoutput(fp);
3462: }
3463:
3464:
3465: /*
3466: * sortassoc - sort associations in the cache into ascending order
3467: */
3468: void
3469: sortassoc(void)
3470: {
3471: if (numassoc > 1)
3472: qsort((void *)assoc_cache, (size_t)numassoc,
3473: sizeof(assoc_cache[0]), assoccmp);
3474: }
3475:
3476:
3477: /*
3478: * assoccmp - compare two associations
3479: */
3480: static int
3481: assoccmp(
3482: const void *t1,
3483: const void *t2
3484: )
3485: {
3486: const struct association *ass1 = t1;
3487: const struct association *ass2 = t2;
3488:
3489: if (ass1->assid < ass2->assid)
3490: return -1;
3491: if (ass1->assid > ass2->assid)
3492: return 1;
3493: return 0;
3494: }
3495:
3496:
3497: /*
3498: * ntpq_custom_opt_handler - autoopts handler for -c and -p
3499: *
3500: * By default, autoopts loses the relative order of -c and -p options
3501: * on the command line. This routine replaces the default handler for
3502: * those routines and builds a list of commands to execute preserving
3503: * the order.
3504: */
3505: void
3506: ntpq_custom_opt_handler(
3507: tOptions *pOptions,
3508: tOptDesc *pOptDesc
3509: )
3510: {
3511: switch (pOptDesc->optValue) {
3512:
3513: default:
3514: fprintf(stderr,
3515: "ntpq_custom_opt_handler unexpected option '%c' (%d)\n",
3516: pOptDesc->optValue, pOptDesc->optValue);
3517: exit(-1);
3518:
3519: case 'c':
3520: ADDCMD(pOptDesc->pzLastArg);
3521: break;
3522:
3523: case 'p':
3524: ADDCMD("peers");
3525: break;
3526: }
3527: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ntpq.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpq