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