contrib/ntp/ntpq/ntpq.c

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