2 * ntpdc_ops.c - subroutines which are called to perform operations by xntpdc
13 #include "ntp_control.h"
14 #include "ntp_refclock.h"
15 #include "ntp_stdlib.h"
18 #ifdef HAVE_SYS_TIMEX_H
19 # include <sys/timex.h>
21 #if !defined(__bsdi__) && !defined(apollo)
22 #include <netinet/in.h>
25 #include <arpa/inet.h>
28 * Declarations for command handlers in here
30 static int checkitems P((int, FILE *));
31 static int checkitemsize P((int, int));
32 static int check1item P((int, FILE *));
33 static void peerlist P((struct parse *, FILE *));
34 static void peers P((struct parse *, FILE *));
35 static void doconfig P((struct parse *pcmd, FILE *fp, int mode, int refc));
36 static void dmpeers P((struct parse *, FILE *));
37 static void dopeers P((struct parse *, FILE *, int));
38 static void printpeer P((struct info_peer *, FILE *));
39 static void showpeer P((struct parse *, FILE *));
40 static void peerstats P((struct parse *, FILE *));
41 static void loopinfo P((struct parse *, FILE *));
42 static void sysinfo P((struct parse *, FILE *));
43 static void sysstats P((struct parse *, FILE *));
44 static void iostats P((struct parse *, FILE *));
45 static void memstats P((struct parse *, FILE *));
46 static void timerstats P((struct parse *, FILE *));
47 static void addpeer P((struct parse *, FILE *));
48 static void addserver P((struct parse *, FILE *));
49 static void addrefclock P((struct parse *, FILE *));
50 static void broadcast P((struct parse *, FILE *));
51 static void doconfig P((struct parse *, FILE *, int, int));
52 static void unconfig P((struct parse *, FILE *));
53 static void set P((struct parse *, FILE *));
54 static void sys_clear P((struct parse *, FILE *));
55 static void doset P((struct parse *, FILE *, int));
56 static void reslist P((struct parse *, FILE *));
57 static void new_restrict P((struct parse *, FILE *));
58 static void unrestrict P((struct parse *, FILE *));
59 static void delrestrict P((struct parse *, FILE *));
60 static void do_restrict P((struct parse *, FILE *, int));
61 static void monlist P((struct parse *, FILE *));
62 static void reset P((struct parse *, FILE *));
63 static void preset P((struct parse *, FILE *));
64 static void readkeys P((struct parse *, FILE *));
65 static void trustkey P((struct parse *, FILE *));
66 static void untrustkey P((struct parse *, FILE *));
67 static void do_trustkey P((struct parse *, FILE *, int));
68 static void authinfo P((struct parse *, FILE *));
69 static void traps P((struct parse *, FILE *));
70 static void addtrap P((struct parse *, FILE *));
71 static void clrtrap P((struct parse *, FILE *));
72 static void do_addclr_trap P((struct parse *, FILE *, int));
73 static void requestkey P((struct parse *, FILE *));
74 static void controlkey P((struct parse *, FILE *));
75 static void do_changekey P((struct parse *, FILE *, int));
76 static void ctlstats P((struct parse *, FILE *));
77 static void clockstat P((struct parse *, FILE *));
78 static void fudge P((struct parse *, FILE *));
79 static void clkbug P((struct parse *, FILE *));
80 static void kerninfo P((struct parse *, FILE *));
81 static void get_if_stats P((struct parse *, FILE *));
82 static void do_if_reload P((struct parse *, FILE *));
85 * Commands we understand. Ntpdc imports this.
87 struct xcmd opcmds[] = {
88 { "listpeers", peerlist, { OPT|IP_VERSION, NO, NO, NO },
89 { "-4|-6", "", "", "" },
90 "display list of peers the server knows about [IP Version]" },
91 { "peers", peers, { OPT|IP_VERSION, NO, NO, NO },
92 { "-4|-6", "", "", "" },
93 "display peer summary information [IP Version]" },
94 { "dmpeers", dmpeers, { OPT|IP_VERSION, NO, NO, NO },
95 { "-4|-6", "", "", "" },
96 "display peer summary info the way Dave Mills likes it (IP Version)" },
97 { "showpeer", showpeer, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD},
98 { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" },
99 "display detailed information for one or more peers" },
100 { "pstats", peerstats, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD },
101 { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" },
102 "display statistical information for one or more peers" },
103 { "loopinfo", loopinfo, { OPT|NTP_STR, NO, NO, NO },
104 { "oneline|multiline", "", "", "" },
105 "display loop filter information" },
106 { "sysinfo", sysinfo, { NO, NO, NO, NO },
108 "display local server information" },
109 { "sysstats", sysstats, { NO, NO, NO, NO },
111 "display local server statistics" },
112 { "memstats", memstats, { NO, NO, NO, NO },
114 "display peer memory usage statistics" },
115 { "iostats", iostats, { NO, NO, NO, NO },
117 "display I/O subsystem statistics" },
118 { "timerstats", timerstats, { NO, NO, NO, NO },
120 "display event timer subsystem statistics" },
121 { "addpeer", addpeer, { NTP_ADD, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
122 { "addr", "keyid", "version", "minpoll#|prefer|burst|iburst|'minpoll N'|'maxpoll N'|'keyid N'|'version N' ..." },
123 "configure a new peer association" },
124 { "addserver", addserver, { NTP_ADD, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
125 { "addr", "keyid", "version", "minpoll#|prefer|burst|iburst|'minpoll N'|'maxpoll N'|'keyid N'|'version N' ..." },
126 "configure a new server" },
127 { "addrefclock",addrefclock, { NTP_ADD, OPT|NTP_UINT, OPT|NTP_STR, OPT|NTP_STR },
128 { "addr", "mode", "minpoll|prefer", "minpoll|prefer" },
129 "configure a new server" },
130 { "broadcast", broadcast, { NTP_ADD, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
131 { "addr", "keyid", "version", "minpoll" },
132 "configure broadcasting time service" },
133 { "unconfig", unconfig, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD },
134 { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" },
135 "unconfigure existing peer assocations" },
136 { "enable", set, { NTP_STR, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
137 { "auth|bclient|monitor|pll|kernel|stats", "...", "...", "..." },
138 "set a system flag (auth, bclient, monitor, pll, kernel, stats)" },
139 { "disable", sys_clear, { NTP_STR, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
140 { "auth|bclient|monitor|pll|kernel|stats", "...", "...", "..." },
141 "clear a system flag (auth, bclient, monitor, pll, kernel, stats)" },
142 { "reslist", reslist, {OPT|IP_VERSION, NO, NO, NO },
143 { "-4|-6", "", "", "" },
144 "display the server's restrict list" },
145 { "restrict", new_restrict, { NTP_ADD, NTP_ADD, NTP_STR, OPT|NTP_STR },
147 "ntpport|ignore|noserve|notrust|noquery|nomodify|nopeer|version|kod",
149 "create restrict entry/add flags to entry" },
150 { "unrestrict", unrestrict, { NTP_ADD, NTP_ADD, NTP_STR, OPT|NTP_STR },
152 "ntpport|ignore|noserve|notrust|noquery|nomodify|nopeer|version|kod",
154 "remove flags from a restrict entry" },
155 { "delrestrict", delrestrict, { NTP_ADD, NTP_ADD, OPT|NTP_STR, NO },
156 { "address", "mask", "ntpport", "" },
157 "delete a restrict entry" },
158 { "monlist", monlist, { OPT|NTP_INT, NO, NO, NO },
159 { "version", "", "", "" },
160 "display data the server's monitor routines have collected" },
161 { "reset", reset, { NTP_STR, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
162 { "io|sys|mem|timer|auth|allpeers", "...", "...", "..." },
163 "reset various subsystem statistics counters" },
164 { "preset", preset, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD },
165 { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" },
166 "reset stat counters associated with particular peer(s)" },
167 { "readkeys", readkeys, { NO, NO, NO, NO },
169 "request a reread of the keys file and re-init of system keys" },
170 { "trustedkey", trustkey, { NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT },
171 { "keyid", "keyid", "keyid", "keyid" },
172 "add one or more key ID's to the trusted list" },
173 { "untrustedkey", untrustkey, { NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT },
174 { "keyid", "keyid", "keyid", "keyid" },
175 "remove one or more key ID's from the trusted list" },
176 { "authinfo", authinfo, { NO, NO, NO, NO },
178 "display the state of the authentication code" },
179 { "traps", traps, { NO, NO, NO, NO },
181 "display the traps set in the server" },
182 { "addtrap", addtrap, { NTP_ADD, OPT|NTP_UINT, OPT|NTP_ADD, NO },
183 { "address", "port", "interface", "" },
184 "configure a trap in the server" },
185 { "clrtrap", clrtrap, { NTP_ADD, OPT|NTP_UINT, OPT|NTP_ADD, NO },
186 { "address", "port", "interface", "" },
187 "remove a trap (configured or otherwise) from the server" },
188 { "requestkey", requestkey, { NTP_UINT, NO, NO, NO },
189 { "keyid", "", "", "" },
190 "change the keyid the server uses to authenticate requests" },
191 { "controlkey", controlkey, { NTP_UINT, NO, NO, NO },
192 { "keyid", "", "", "" },
193 "change the keyid the server uses to authenticate control messages" },
194 { "ctlstats", ctlstats, { NO, NO, NO, NO },
196 "display packet count statistics from the control module" },
197 { "clockstat", clockstat, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD },
198 { "address", "address", "address", "address" },
199 "display clock status information" },
200 { "fudge", fudge, { NTP_ADD, NTP_STR, NTP_STR, NO },
201 { "address", "time1|time2|val1|val2|flags", "value", "" },
202 "set/change one of a clock's fudge factors" },
203 { "clkbug", clkbug, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD },
204 { "address", "address", "address", "address" },
205 "display clock debugging information" },
206 { "kerninfo", kerninfo, { NO, NO, NO, NO },
208 "display the kernel pll/pps variables" },
209 { "ifstats", get_if_stats, { NO, NO, NO, NO },
211 "list interface statistics" },
212 { "ifreload", do_if_reload, { NO, NO, NO, NO },
214 "reload interface configuration" },
215 { 0, 0, { NO, NO, NO, NO },
216 { "", "", "", "" }, "" }
220 * For quick string comparisons
222 #define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
226 * checkitems - utility to print a message if no items were returned
235 (void) fprintf(fp, "No data returned in response to query\n");
243 * checkitemsize - utility to print a message if the item size is wrong
251 if (itemsize != expected) {
252 (void) fprintf(stderr,
253 "***Incorrect item size returned by remote host (%d should be %d)\n",
262 * check1item - check to make sure we have exactly one item
271 (void) fprintf(fp, "No data returned in response to query\n");
275 (void) fprintf(fp, "Expected one item in response, got %d\n",
285 * peerlist - get a short list of peers
294 struct info_peer_list *plist;
295 struct sockaddr_storage paddr;
301 res = doquery(impl_ver, REQ_PEER_LIST, 0, 0, 0, (char *)NULL, &items,
302 &itemsize, (void *)&plist, 0,
303 sizeof(struct info_peer_list));
305 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
306 impl_ver = IMPL_XNTPD_OLD;
313 if (!checkitems(items, fp))
316 if (!checkitemsize(itemsize, sizeof(struct info_peer_list)) &&
317 !checkitemsize(itemsize, v4sizeof(struct info_peer_list)))
321 memset((char *)&paddr, 0, sizeof(paddr));
322 if (plist->v6_flag != 0) {
323 GET_INADDR6(paddr) = plist->addr6;
324 paddr.ss_family = AF_INET6;
326 GET_INADDR(paddr) = plist->addr;
327 paddr.ss_family = AF_INET;
329 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
330 paddr.ss_len = SOCKLEN(&paddr);
332 if ((pcmd->nargs == 0) ||
333 ((pcmd->argval->ival == 6) && (plist->v6_flag != 0)) ||
334 ((pcmd->argval->ival == 4) && (plist->v6_flag == 0)))
335 (void) fprintf(fp, "%-9s %s\n",
336 modetoa(plist->hmode),
345 * peers - show peer summary
353 dopeers(pcmd, fp, 0);
357 * dmpeers - show peer summary, Dave Mills style
365 dopeers(pcmd, fp, 1);
370 * peers - show peer summary
380 struct info_peer_summary *plist;
381 struct sockaddr_storage dstadr;
382 struct sockaddr_storage srcadr;
391 res = doquery(impl_ver, REQ_PEER_LIST_SUM, 0, 0, 0, (char *)NULL,
392 &items, &itemsize, (void *)&plist, 0,
393 sizeof(struct info_peer_summary));
395 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
396 impl_ver = IMPL_XNTPD_OLD;
403 if (!checkitems(items, fp))
406 if (!checkitemsize(itemsize, sizeof(struct info_peer_summary)) &&
407 !checkitemsize(itemsize, v4sizeof(struct info_peer_summary)))
411 " remote local st poll reach delay offset disp\n");
413 "=======================================================================\n");
416 if (plist->flags & INFO_FLAG_SYSPEER)
418 else if (plist->hmode == MODE_ACTIVE)
420 else if (plist->hmode == MODE_PASSIVE)
422 else if (plist->hmode == MODE_CLIENT)
424 else if (plist->hmode == MODE_BROADCAST)
426 else if (plist->hmode == MODE_BCLIENT)
431 if (plist->flags & INFO_FLAG_SYSPEER)
433 else if (plist->flags & INFO_FLAG_SHORTLIST)
435 else if (plist->flags & INFO_FLAG_SEL_CANDIDATE)
440 NTOHL_FP(&(plist->offset), &tempts);
441 ntp_poll = 1<<max(min3(plist->ppoll, plist->hpoll, NTP_MAXPOLL),
443 memset((char *)&dstadr, 0, sizeof(dstadr));
444 memset((char *)&srcadr, 0, sizeof(srcadr));
445 if (plist->v6_flag != 0) {
446 GET_INADDR6(dstadr) = plist->dstadr6;
447 GET_INADDR6(srcadr) = plist->srcadr6;
448 srcadr.ss_family = AF_INET6;
449 dstadr.ss_family = AF_INET6;
451 GET_INADDR(dstadr) = plist->dstadr;
452 GET_INADDR(srcadr) = plist->srcadr;
453 srcadr.ss_family = AF_INET;
454 dstadr.ss_family = AF_INET;
456 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
457 srcadr.ss_len = SOCKLEN(&srcadr);
458 dstadr.ss_len = SOCKLEN(&dstadr);
460 if ((pcmd->nargs == 0) ||
461 ((pcmd->argval->ival == 6) && (plist->v6_flag != 0)) ||
462 ((pcmd->argval->ival == 4) && (plist->v6_flag == 0)))
464 "%c%-15.15s %-15.15s %2d %4d %3o %7.7s %9.9s %7.7s\n",
465 c, nntohost(&srcadr), stoa(&dstadr),
466 plist->stratum, ntp_poll, plist->reach,
467 fptoa(NTOHS_FP(plist->delay), 5),
469 ufptoa(NTOHS_FP(plist->dispersion), 5));
475 /* Convert a refid & stratum (in host order) to a string */
485 memmove(junk, (char *)&refid, 4);
489 return numtoa(refid);
501 (void) fprintf(fp, " none\n");
504 if (flags & INFO_FLAG_SYSPEER) {
505 (void) fprintf(fp, " system_peer");
508 if (flags & INFO_FLAG_CONFIG) {
509 (void) fprintf(fp, "%s config", str);
512 if (flags & INFO_FLAG_REFCLOCK) {
513 (void) fprintf(fp, "%s refclock", str);
516 if (flags & INFO_FLAG_AUTHENABLE) {
517 (void) fprintf(fp, "%s auth", str);
520 if (flags & INFO_FLAG_BCLIENT) {
521 (void) fprintf(fp, "%s bclient", str);
524 if (flags & INFO_FLAG_PREFER) {
525 (void) fprintf(fp, "%s prefer", str);
528 if (flags & INFO_FLAG_IBURST) {
529 (void) fprintf(fp, "%s iburst", str);
532 if (flags & INFO_FLAG_BURST) {
533 (void) fprintf(fp, "%s burst", str);
535 (void) fprintf(fp, "\n");
539 * printpeer - print detail information for a peer
543 register struct info_peer *pp,
549 struct sockaddr_storage srcadr, dstadr;
551 memset((char *)&srcadr, 0, sizeof(srcadr));
552 memset((char *)&dstadr, 0, sizeof(dstadr));
553 if (pp->v6_flag != 0) {
554 srcadr.ss_family = AF_INET6;
555 dstadr.ss_family = AF_INET6;
556 GET_INADDR6(srcadr) = pp->srcadr6;
557 GET_INADDR6(dstadr) = pp->dstadr6;
559 srcadr.ss_family = AF_INET;
560 dstadr.ss_family = AF_INET;
561 GET_INADDR(srcadr) = pp->srcadr;
562 GET_INADDR(dstadr) = pp->dstadr;
564 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
565 srcadr.ss_len = SOCKLEN(&srcadr);
566 dstadr.ss_len = SOCKLEN(&dstadr);
568 (void) fprintf(fp, "remote %s, local %s\n",
569 stoa(&srcadr), stoa(&dstadr));
570 (void) fprintf(fp, "hmode %s, pmode %s, stratum %d, precision %d\n",
571 modetoa(pp->hmode), modetoa(pp->pmode),
572 pp->stratum, pp->precision);
575 "leap %c%c, refid [%s], rootdistance %s, rootdispersion %s\n",
576 pp->leap & 0x2 ? '1' : '0',
577 pp->leap & 0x1 ? '1' : '0',
578 refid_string(pp->refid, pp->stratum), fptoa(NTOHS_FP(pp->rootdelay), 5),
579 ufptoa(NTOHS_FP(pp->rootdispersion), 5));
582 "ppoll %d, hpoll %d, keyid %lu, version %d, association %u\n",
583 pp->ppoll, pp->hpoll, (u_long)pp->keyid, pp->version, ntohs(pp->associd));
586 "reach %03o, unreach %d, flash 0x%04x, ",
587 pp->reach, pp->unreach, pp->flash2);
589 (void) fprintf(fp, "boffset %s, ttl/mode %d\n",
590 fptoa(NTOHS_FP(pp->estbdelay), 5), pp->ttl);
592 (void) fprintf(fp, "timer %lds, flags", (long)ntohl(pp->timer));
593 print_pflag(fp, pp->flags);
595 NTOHL_FP(&pp->reftime, &tempts);
596 (void) fprintf(fp, "reference time: %s\n",
597 prettydate(&tempts));
598 NTOHL_FP(&pp->org, &tempts);
599 (void) fprintf(fp, "originate timestamp: %s\n",
600 prettydate(&tempts));
601 NTOHL_FP(&pp->rec, &tempts);
602 (void) fprintf(fp, "receive timestamp: %s\n",
603 prettydate(&tempts));
604 NTOHL_FP(&pp->xmt, &tempts);
605 (void) fprintf(fp, "transmit timestamp: %s\n",
606 prettydate(&tempts));
608 (void) fprintf(fp, "filter delay: ");
609 for (i = 0; i < NTP_SHIFT; i++) {
610 (void) fprintf(fp, " %-8.8s",
611 fptoa(NTOHS_FP(pp->filtdelay[i]), 5));
612 if (i == (NTP_SHIFT>>1)-1)
613 (void) fprintf(fp, "\n ");
615 (void) fprintf(fp, "\n");
617 (void) fprintf(fp, "filter offset:");
618 for (i = 0; i < NTP_SHIFT; i++) {
619 NTOHL_FP(&pp->filtoffset[i], &tempts);
620 (void) fprintf(fp, " %-8.8s", lfptoa(&tempts, 6));
621 if (i == (NTP_SHIFT>>1)-1)
622 (void) fprintf(fp, "\n ");
624 (void) fprintf(fp, "\n");
626 (void) fprintf(fp, "filter order: ");
627 for (i = 0; i < NTP_SHIFT; i++) {
628 (void) fprintf(fp, " %-8d", pp->order[i]);
629 if (i == (NTP_SHIFT>>1)-1)
630 (void) fprintf(fp, "\n ");
632 (void) fprintf(fp, "\n");
635 NTOHL_FP(&pp->offset, &tempts);
637 "offset %s, delay %s, error bound %s, filter error %s\n",
638 lfptoa(&tempts, 6), fptoa(NTOHS_FP(pp->delay), 5),
639 ufptoa(NTOHS_FP(pp->dispersion), 5),
640 ufptoa(NTOHS_FP(pp->selectdisp), 5));
645 * showpeer - show detailed information for a peer
653 struct info_peer *pp;
654 /* 4 is the maximum number of peers which will fit in a packet */
655 struct info_peer_list *pl, plist[min(MAXARGS, 4)];
663 if (impl_ver == IMPL_XNTPD)
664 sendsize = sizeof(struct info_peer_list);
666 sendsize = v4sizeof(struct info_peer_list);
668 for (qitems = 0, pl = plist; qitems < min(pcmd->nargs, 4); qitems++) {
669 if (pcmd->argval[qitems].netnum.ss_family == AF_INET) {
670 pl->addr = GET_INADDR(pcmd->argval[qitems].netnum);
671 if (impl_ver == IMPL_XNTPD)
674 if (impl_ver == IMPL_XNTPD_OLD) {
676 "***Server doesn't understand IPv6 addresses\n");
679 pl->addr6 = GET_INADDR6(pcmd->argval[qitems].netnum);
682 pl->port = (u_short)s_port;
683 pl->hmode = pl->flags = 0;
684 pl = (struct info_peer_list *)((char *)pl + sendsize);
687 res = doquery(impl_ver, REQ_PEER_INFO, 0, qitems,
688 sendsize, (char *)plist, &items,
689 &itemsize, (void *)&pp, 0, sizeof(struct info_peer));
691 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
692 impl_ver = IMPL_XNTPD_OLD;
699 if (!checkitems(items, fp))
702 if (!checkitemsize(itemsize, sizeof(struct info_peer)) &&
703 !checkitemsize(itemsize, v4sizeof(struct info_peer)))
706 while (items-- > 0) {
709 (void) fprintf(fp, "\n");
716 * peerstats - return statistics for a peer
724 struct info_peer_stats *pp;
725 /* 4 is the maximum number of peers which will fit in a packet */
726 struct info_peer_list *pl, plist[min(MAXARGS, 4)];
727 struct sockaddr_storage src, dst;
735 if (impl_ver == IMPL_XNTPD)
736 sendsize = sizeof(struct info_peer_list);
738 sendsize = v4sizeof(struct info_peer_list);
740 memset((char *)plist, 0, sizeof(struct info_peer_list) * min(MAXARGS, 4));
741 for (qitems = 0, pl = plist; qitems < min(pcmd->nargs, 4); qitems++) {
742 if (pcmd->argval[qitems].netnum.ss_family == AF_INET) {
743 pl->addr = GET_INADDR(pcmd->argval[qitems].netnum);
744 if (impl_ver == IMPL_XNTPD)
747 if (impl_ver == IMPL_XNTPD_OLD) {
749 "***Server doesn't understand IPv6 addresses\n");
752 pl->addr6 = GET_INADDR6(pcmd->argval[qitems].netnum);
755 pl->port = (u_short)s_port;
756 pl->hmode = plist[qitems].flags = 0;
757 pl = (struct info_peer_list *)((char *)pl + sendsize);
760 res = doquery(impl_ver, REQ_PEER_STATS, 0, qitems,
761 sendsize, (char *)plist, &items,
762 &itemsize, (void *)&pp, 0,
763 sizeof(struct info_peer_stats));
765 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
766 impl_ver = IMPL_XNTPD_OLD;
773 if (!checkitems(items, fp))
776 if (!checkitemsize(itemsize, sizeof(struct info_peer_stats)) &&
777 !checkitemsize(itemsize, v4sizeof(struct info_peer_stats)))
780 while (items-- > 0) {
781 memset((char *)&src, 0, sizeof(src));
782 memset((char *)&dst, 0, sizeof(dst));
783 if (pp->v6_flag != 0) {
784 GET_INADDR6(src) = pp->srcadr6;
785 GET_INADDR6(dst) = pp->dstadr6;
786 src.ss_family = AF_INET6;
787 dst.ss_family = AF_INET6;
789 GET_INADDR(src) = pp->srcadr;
790 GET_INADDR(dst) = pp->dstadr;
791 src.ss_family = AF_INET;
792 dst.ss_family = AF_INET;
794 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
795 src.ss_len = SOCKLEN(&src);
796 dst.ss_len = SOCKLEN(&dst);
798 (void) fprintf(fp, "remote host: %s\n",
800 (void) fprintf(fp, "local interface: %s\n",
802 (void) fprintf(fp, "time last received: %lds\n",
803 (long)ntohl(pp->timereceived));
804 (void) fprintf(fp, "time until next send: %lds\n",
805 (long)ntohl(pp->timetosend));
806 (void) fprintf(fp, "reachability change: %lds\n",
807 (long)ntohl(pp->timereachable));
808 (void) fprintf(fp, "packets sent: %ld\n",
809 (long)ntohl(pp->sent));
810 (void) fprintf(fp, "packets received: %ld\n",
811 (long)ntohl(pp->processed));
812 (void) fprintf(fp, "bad authentication: %ld\n",
813 (long)ntohl(pp->badauth));
814 (void) fprintf(fp, "bogus origin: %ld\n",
815 (long)ntohl(pp->bogusorg));
816 (void) fprintf(fp, "duplicate: %ld\n",
817 (long)ntohl(pp->oldpkt));
818 (void) fprintf(fp, "bad dispersion: %ld\n",
819 (long)ntohl(pp->seldisp));
820 (void) fprintf(fp, "bad reference time: %ld\n",
821 (long)ntohl(pp->selbroken));
822 (void) fprintf(fp, "candidate order: %d\n",
825 (void) fprintf(fp, "\n");
826 (void) fprintf(fp, "flags: ");
827 print_pflag(fp, ntohs(pp->flags));
834 * loopinfo - show loop filter information
842 struct info_loop *il;
849 if (pcmd->nargs > 0) {
850 if (STREQ(pcmd->argval[0].string, "oneline"))
852 else if (STREQ(pcmd->argval[0].string, "multiline"))
855 (void) fprintf(stderr, "How many lines?\n");
861 res = doquery(impl_ver, REQ_LOOP_INFO, 0, 0, 0, (char *)NULL,
862 &items, &itemsize, (void *)&il, 0,
863 sizeof(struct info_loop));
865 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
866 impl_ver = IMPL_XNTPD_OLD;
873 if (!check1item(items, fp))
876 if (!checkitemsize(itemsize, sizeof(struct info_loop)))
882 NTOHL_FP(&il->last_offset, &tempts);
883 NTOHL_FP(&il->drift_comp, &temp2ts);
886 "offset %s, frequency %s, time_const %ld, watchdog %ld\n",
889 (long)(int32_t)ntohl((u_long)il->compliance),
890 (u_long)ntohl((u_long)il->watchdog_timer));
892 NTOHL_FP(&il->last_offset, &tempts);
893 (void) fprintf(fp, "offset: %s s\n",
895 NTOHL_FP(&il->drift_comp, &tempts);
896 (void) fprintf(fp, "frequency: %s ppm\n",
898 (void) fprintf(fp, "poll adjust: %ld\n",
899 (long)(int32_t)ntohl(il->compliance));
900 (void) fprintf(fp, "watchdog timer: %ld s\n",
901 (u_long)ntohl(il->watchdog_timer));
907 * sysinfo - show current system state
917 struct sockaddr_storage peeraddr;
924 res = doquery(impl_ver, REQ_SYS_INFO, 0, 0, 0, (char *)NULL,
925 &items, &itemsize, (void *)&is, 0,
926 sizeof(struct info_sys));
928 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
929 impl_ver = IMPL_XNTPD_OLD;
936 if (!check1item(items, fp))
939 if (!checkitemsize(itemsize, sizeof(struct info_sys)) &&
940 !checkitemsize(itemsize, v4sizeof(struct info_sys)))
943 memset((char *)&peeraddr, 0, sizeof(peeraddr));
944 if (is->v6_flag != 0) {
945 GET_INADDR6(peeraddr) = is->peer6;
946 peeraddr.ss_family = AF_INET6;
948 GET_INADDR(peeraddr) = is->peer;
949 peeraddr.ss_family = AF_INET;
951 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
952 peeraddr.ss_len = SOCKLEN(&peeraddr);
954 (void) fprintf(fp, "system peer: %s\n", nntohost(&peeraddr));
955 (void) fprintf(fp, "system peer mode: %s\n", modetoa(is->peer_mode));
956 (void) fprintf(fp, "leap indicator: %c%c\n",
957 is->leap & 0x2 ? '1' : '0',
958 is->leap & 0x1 ? '1' : '0');
959 (void) fprintf(fp, "stratum: %d\n", (int)is->stratum);
960 (void) fprintf(fp, "precision: %d\n", (int)is->precision);
961 (void) fprintf(fp, "root distance: %s s\n",
962 fptoa(NTOHS_FP(is->rootdelay), 5));
963 (void) fprintf(fp, "root dispersion: %s s\n",
964 ufptoa(NTOHS_FP(is->rootdispersion), 5));
965 (void) fprintf(fp, "reference ID: [%s]\n",
966 refid_string(is->refid, is->stratum));
967 NTOHL_FP(&is->reftime, &tempts);
968 (void) fprintf(fp, "reference time: %s\n", prettydate(&tempts));
970 (void) fprintf(fp, "system flags: ");
971 if ((is->flags & (INFO_FLAG_BCLIENT | INFO_FLAG_AUTHENABLE |
972 INFO_FLAG_NTP | INFO_FLAG_KERNEL| INFO_FLAG_CAL |
973 INFO_FLAG_PPS_SYNC | INFO_FLAG_MONITOR | INFO_FLAG_FILEGEN)) == 0) {
974 (void) fprintf(fp, "none\n");
976 if (is->flags & INFO_FLAG_BCLIENT)
977 (void) fprintf(fp, "bclient ");
978 if (is->flags & INFO_FLAG_AUTHENTICATE)
979 (void) fprintf(fp, "auth ");
980 if (is->flags & INFO_FLAG_MONITOR)
981 (void) fprintf(fp, "monitor ");
982 if (is->flags & INFO_FLAG_NTP)
983 (void) fprintf(fp, "ntp ");
984 if (is->flags & INFO_FLAG_KERNEL)
985 (void) fprintf(fp, "kernel ");
986 if (is->flags & INFO_FLAG_FILEGEN)
987 (void) fprintf(fp, "stats ");
988 if (is->flags & INFO_FLAG_CAL)
989 (void) fprintf(fp, "calibrate ");
990 if (is->flags & INFO_FLAG_PPS_SYNC)
991 (void) fprintf(fp, "pps ");
992 (void) fprintf(fp, "\n");
994 (void) fprintf(fp, "jitter: %s s\n",
995 fptoa(ntohl(is->frequency), 6));
996 (void) fprintf(fp, "stability: %s ppm\n",
997 ufptoa(ntohl(is->stability), 3));
998 (void) fprintf(fp, "broadcastdelay: %s s\n",
999 fptoa(NTOHS_FP(is->bdelay), 6));
1000 NTOHL_FP(&is->authdelay, &tempts);
1001 (void) fprintf(fp, "authdelay: %s s\n", lfptoa(&tempts, 6));
1006 * sysstats - print system statistics
1015 struct info_sys_stats *ss;
1021 res = doquery(impl_ver, REQ_SYS_STATS, 0, 0, 0, (char *)NULL,
1022 &items, &itemsize, (void *)&ss, 0,
1023 sizeof(struct info_sys_stats));
1025 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1026 impl_ver = IMPL_XNTPD_OLD;
1033 if (!check1item(items, fp))
1036 if (itemsize != sizeof(struct info_sys_stats) &&
1037 itemsize != sizeof(struct old_info_sys_stats)) {
1038 /* issue warning according to new structure size */
1039 checkitemsize(itemsize, sizeof(struct info_sys_stats));
1042 fprintf(fp, "time since restart: %ld\n",
1043 (u_long)ntohl(ss->timeup));
1044 fprintf(fp, "time since reset: %ld\n",
1045 (u_long)ntohl(ss->timereset));
1046 fprintf(fp, "packets received: %ld\n",
1047 (u_long)ntohl(ss->received));
1048 fprintf(fp, "packets processed: %ld\n",
1049 (u_long)ntohl(ss->processed));
1050 fprintf(fp, "current version: %ld\n",
1051 (u_long)ntohl(ss->newversionpkt));
1052 fprintf(fp, "previous version: %ld\n",
1053 (u_long)ntohl(ss->oldversionpkt));
1054 fprintf(fp, "bad version: %ld\n",
1055 (u_long)ntohl(ss->unknownversion));
1056 fprintf(fp, "access denied: %ld\n",
1057 (u_long)ntohl(ss->denied));
1058 fprintf(fp, "bad length or format: %ld\n",
1059 (u_long)ntohl(ss->badlength));
1060 fprintf(fp, "bad authentication: %ld\n",
1061 (u_long)ntohl(ss->badauth));
1062 if (itemsize != sizeof(struct info_sys_stats))
1065 fprintf(fp, "rate exceeded: %ld\n",
1066 (u_long)ntohl(ss->limitrejected));
1072 * iostats - print I/O statistics
1081 struct info_io_stats *io;
1087 res = doquery(impl_ver, REQ_IO_STATS, 0, 0, 0, (char *)NULL,
1088 &items, &itemsize, (void *)&io, 0,
1089 sizeof(struct info_io_stats));
1091 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1092 impl_ver = IMPL_XNTPD_OLD;
1099 if (!check1item(items, fp))
1102 if (!checkitemsize(itemsize, sizeof(struct info_io_stats)))
1105 (void) fprintf(fp, "time since reset: %ld\n",
1106 (u_long)ntohl(io->timereset));
1107 (void) fprintf(fp, "receive buffers: %d\n",
1108 ntohs(io->totalrecvbufs));
1109 (void) fprintf(fp, "free receive buffers: %d\n",
1110 ntohs(io->freerecvbufs));
1111 (void) fprintf(fp, "used receive buffers: %d\n",
1112 ntohs(io->fullrecvbufs));
1113 (void) fprintf(fp, "low water refills: %d\n",
1114 ntohs(io->lowwater));
1115 (void) fprintf(fp, "dropped packets: %ld\n",
1116 (u_long)ntohl(io->dropped));
1117 (void) fprintf(fp, "ignored packets: %ld\n",
1118 (u_long)ntohl(io->ignored));
1119 (void) fprintf(fp, "received packets: %ld\n",
1120 (u_long)ntohl(io->received));
1121 (void) fprintf(fp, "packets sent: %ld\n",
1122 (u_long)ntohl(io->sent));
1123 (void) fprintf(fp, "packets not sent: %ld\n",
1124 (u_long)ntohl(io->notsent));
1125 (void) fprintf(fp, "interrupts handled: %ld\n",
1126 (u_long)ntohl(io->interrupts));
1127 (void) fprintf(fp, "received by int: %ld\n",
1128 (u_long)ntohl(io->int_received));
1133 * memstats - print peer memory statistics
1142 struct info_mem_stats *mem;
1149 res = doquery(impl_ver, REQ_MEM_STATS, 0, 0, 0, (char *)NULL,
1150 &items, &itemsize, (void *)&mem, 0,
1151 sizeof(struct info_mem_stats));
1153 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1154 impl_ver = IMPL_XNTPD_OLD;
1161 if (!check1item(items, fp))
1164 if (!checkitemsize(itemsize, sizeof(struct info_mem_stats)))
1167 (void) fprintf(fp, "time since reset: %ld\n",
1168 (u_long)ntohl(mem->timereset));
1169 (void) fprintf(fp, "total peer memory: %d\n",
1170 ntohs(mem->totalpeermem));
1171 (void) fprintf(fp, "free peer memory: %d\n",
1172 ntohs(mem->freepeermem));
1173 (void) fprintf(fp, "calls to findpeer: %ld\n",
1174 (u_long)ntohl(mem->findpeer_calls));
1175 (void) fprintf(fp, "new peer allocations: %ld\n",
1176 (u_long)ntohl(mem->allocations));
1177 (void) fprintf(fp, "peer demobilizations: %ld\n",
1178 (u_long)ntohl(mem->demobilizations));
1180 (void) fprintf(fp, "hash table counts: ");
1181 for (i = 0; i < NTP_HASH_SIZE; i++) {
1182 (void) fprintf(fp, "%4d", (int)mem->hashcount[i]);
1183 if ((i % 8) == 7 && i != (NTP_HASH_SIZE-1)) {
1184 (void) fprintf(fp, "\n ");
1187 (void) fprintf(fp, "\n");
1193 * timerstats - print timer statistics
1202 struct info_timer_stats *tim;
1208 res = doquery(impl_ver, REQ_TIMER_STATS, 0, 0, 0, (char *)NULL,
1209 &items, &itemsize, (void *)&tim, 0,
1210 sizeof(struct info_timer_stats));
1212 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1213 impl_ver = IMPL_XNTPD_OLD;
1220 if (!check1item(items, fp))
1223 if (!checkitemsize(itemsize, sizeof(struct info_timer_stats)))
1226 (void) fprintf(fp, "time since reset: %ld\n",
1227 (u_long)ntohl(tim->timereset));
1228 (void) fprintf(fp, "alarms handled: %ld\n",
1229 (u_long)ntohl(tim->alarms));
1230 (void) fprintf(fp, "alarm overruns: %ld\n",
1231 (u_long)ntohl(tim->overflows));
1232 (void) fprintf(fp, "calls to transmit: %ld\n",
1233 (u_long)ntohl(tim->xmtcalls));
1238 * addpeer - configure an active mode association
1246 doconfig(pcmd, fp, MODE_ACTIVE, 0);
1251 * addserver - configure a client mode association
1259 doconfig(pcmd, fp, MODE_CLIENT, 0);
1263 * addrefclock - configure a reference clock association
1271 doconfig(pcmd, fp, MODE_CLIENT, 1);
1275 * broadcast - configure a broadcast mode association
1283 doconfig(pcmd, fp, MODE_BROADCAST, 0);
1288 * config - configure a new peer association
1298 struct conf_peer cpeer;
1318 minpoll = NTP_MINDPOLL;
1319 maxpoll = NTP_MAXDPOLL;
1324 if (impl_ver == IMPL_XNTPD)
1325 sendsize = sizeof(struct conf_peer);
1327 sendsize = v4sizeof(struct conf_peer);
1330 while (pcmd->nargs > items) {
1331 if (STREQ(pcmd->argval[items].string, "prefer"))
1332 flags |= CONF_FLAG_PREFER;
1333 else if (STREQ(pcmd->argval[items].string, "burst"))
1334 flags |= CONF_FLAG_BURST;
1335 else if (STREQ(pcmd->argval[items].string, "dynamic"))
1336 (void) fprintf(fp, "Warning: the \"dynamic\" keyword has been obsoleted and will be removed in the next release\n");
1337 else if (STREQ(pcmd->argval[items].string, "iburst"))
1338 flags |= CONF_FLAG_IBURST;
1339 else if (!refc && STREQ(pcmd->argval[items].string, "keyid"))
1341 else if (!refc && STREQ(pcmd->argval[items].string, "version"))
1343 else if (STREQ(pcmd->argval[items].string, "minpoll"))
1345 else if (STREQ(pcmd->argval[items].string, "maxpoll"))
1349 if (!atoint(pcmd->argval[items].string, &val))
1358 version = (u_int) val;
1363 minpoll = (u_char)val;
1368 maxpoll = (u_char)val;
1373 cmode = (u_char)val;
1378 (void) fprintf(fp, "*** '%s' not understood\n",
1379 pcmd->argval[items].string);
1384 (void) fprintf(stderr,
1385 "***Value '%s' should be unsigned\n",
1386 pcmd->argval[items].string);
1393 flags |= CONF_FLAG_AUTHENABLE;
1394 if (version > NTP_VERSION ||
1395 version < NTP_OLDVERSION) {
1396 (void)fprintf(fp, "***invalid version number: %u\n",
1400 if (minpoll < NTP_MINPOLL || minpoll > NTP_MAXPOLL ||
1401 maxpoll < NTP_MINPOLL || maxpoll > NTP_MAXPOLL ||
1402 minpoll > maxpoll) {
1403 (void) fprintf(fp, "***min/max-poll must be within %d..%d\n",
1404 NTP_MINPOLL, NTP_MAXPOLL);
1411 memset((void *)&cpeer, 0, sizeof(cpeer));
1413 if (pcmd->argval[0].netnum.ss_family == AF_INET) {
1414 cpeer.peeraddr = GET_INADDR(pcmd->argval[0].netnum);
1415 if (impl_ver == IMPL_XNTPD)
1418 if (impl_ver == IMPL_XNTPD_OLD) {
1420 "***Server doesn't understand IPv6 addresses\n");
1423 cpeer.peeraddr6 = GET_INADDR6(pcmd->argval[0].netnum);
1426 cpeer.hmode = (u_char) mode;
1427 cpeer.keyid = keyid;
1428 cpeer.version = (u_char) version;
1429 cpeer.minpoll = minpoll;
1430 cpeer.maxpoll = maxpoll;
1431 cpeer.flags = (u_char)flags;
1434 res = doquery(impl_ver, REQ_CONFIG, 1, 1,
1435 sendsize, (char *)&cpeer, &items,
1436 &itemsize, &dummy, 0, sizeof(struct conf_peer));
1438 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1439 impl_ver = IMPL_XNTPD_OLD;
1443 if (res == INFO_ERR_FMT) {
1445 "***Retrying command with old conf_peer size\n");
1446 res = doquery(impl_ver, REQ_CONFIG, 1, 1,
1447 sizeof(struct old_conf_peer), (char *)&cpeer,
1448 &items, &itemsize, &dummy, 0,
1449 sizeof(struct conf_peer));
1452 (void) fprintf(fp, "done!\n");
1458 * unconfig - unconfigure some associations
1466 /* 8 is the maximum number of peers which will fit in a packet */
1467 struct conf_unpeer *pl, plist[min(MAXARGS, 8)];
1476 if (impl_ver == IMPL_XNTPD)
1477 sendsize = sizeof(struct conf_unpeer);
1479 sendsize = v4sizeof(struct conf_unpeer);
1481 for (qitems = 0, pl = plist; qitems < min(pcmd->nargs, 8); qitems++) {
1482 if (pcmd->argval[0].netnum.ss_family == AF_INET) {
1483 pl->peeraddr = GET_INADDR(pcmd->argval[qitems].netnum);
1484 if (impl_ver == IMPL_XNTPD)
1487 if (impl_ver == IMPL_XNTPD_OLD) {
1489 "***Server doesn't understand IPv6 addresses\n");
1493 GET_INADDR6(pcmd->argval[qitems].netnum);
1496 pl = (struct conf_unpeer *)((char *)pl + sendsize);
1499 res = doquery(impl_ver, REQ_UNCONFIG, 1, qitems,
1500 sendsize, (char *)plist, &items,
1501 &itemsize, &dummy, 0, sizeof(struct conf_unpeer));
1503 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1504 impl_ver = IMPL_XNTPD_OLD;
1509 (void) fprintf(fp, "done!\n");
1514 * set - set some system flags
1522 doset(pcmd, fp, REQ_SET_SYS_FLAG);
1527 * clear - clear some system flags
1535 doset(pcmd, fp, REQ_CLR_SYS_FLAG);
1540 * doset - set/clear system flags
1549 /* 8 is the maximum number of peers which will fit in a packet */
1550 struct conf_sys_flags sys;
1558 for (items = 0; items < pcmd->nargs; items++) {
1559 if (STREQ(pcmd->argval[items].string, "auth"))
1560 sys.flags |= SYS_FLAG_AUTH;
1561 else if (STREQ(pcmd->argval[items].string, "bclient"))
1562 sys.flags |= SYS_FLAG_BCLIENT;
1563 else if (STREQ(pcmd->argval[items].string, "calibrate"))
1564 sys.flags |= SYS_FLAG_CAL;
1565 else if (STREQ(pcmd->argval[items].string, "kernel"))
1566 sys.flags |= SYS_FLAG_KERNEL;
1567 else if (STREQ(pcmd->argval[items].string, "monitor"))
1568 sys.flags |= SYS_FLAG_MONITOR;
1569 else if (STREQ(pcmd->argval[items].string, "ntp"))
1570 sys.flags |= SYS_FLAG_NTP;
1571 else if (STREQ(pcmd->argval[items].string, "pps"))
1572 sys.flags |= SYS_FLAG_PPS;
1573 else if (STREQ(pcmd->argval[items].string, "stats"))
1574 sys.flags |= SYS_FLAG_FILEGEN;
1576 (void) fprintf(fp, "Unknown flag %s\n",
1577 pcmd->argval[items].string);
1582 sys.flags = htonl(sys.flags);
1583 if (res || sys.flags == 0)
1587 res = doquery(impl_ver, req, 1, 1,
1588 sizeof(struct conf_sys_flags), (char *)&sys, &items,
1589 &itemsize, &dummy, 0, sizeof(struct conf_sys_flags));
1591 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1592 impl_ver = IMPL_XNTPD_OLD;
1597 (void) fprintf(fp, "done!\n");
1602 * data for printing/interrpreting the restrict flags
1609 /* XXX: HMS: we apparently don't report set bits we do not recognize. */
1611 static struct resflags resflagsV2[] = {
1612 { "ignore", 0x001 },
1613 { "noserve", 0x002 },
1614 { "notrust", 0x004 },
1615 { "noquery", 0x008 },
1616 { "nomodify", 0x010 },
1617 { "nopeer", 0x020 },
1618 { "notrap", 0x040 },
1619 { "lptrap", 0x080 },
1620 { "limited", 0x100 },
1624 static struct resflags resflagsV3[] = {
1625 { "ignore", RES_IGNORE },
1626 { "noserve", RES_DONTSERVE },
1627 { "notrust", RES_DONTTRUST },
1628 { "noquery", RES_NOQUERY },
1629 { "nomodify", RES_NOMODIFY },
1630 { "nopeer", RES_NOPEER },
1631 { "notrap", RES_NOTRAP },
1632 { "lptrap", RES_LPTRAP },
1633 { "limited", RES_LIMITED },
1634 { "version", RES_VERSION },
1635 { "kod", RES_DEMOBILIZE },
1636 { "timeout", RES_TIMEOUT },
1641 static struct resflags resmflags[] = {
1642 { "ntpport", RESM_NTPONLY },
1643 { "interface", RESM_INTERFACE },
1649 * reslist - obtain and print the server's restrict list
1658 struct info_restrict *rl;
1659 struct sockaddr_storage resaddr;
1660 struct sockaddr_storage maskaddr;
1667 struct resflags *rf;
1672 static const char *comma = ", ";
1675 res = doquery(impl_ver, REQ_GET_RESTRICT, 0, 0, 0, (char *)NULL,
1676 &items, &itemsize, (void *)&rl, 0,
1677 sizeof(struct info_restrict));
1679 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1680 impl_ver = IMPL_XNTPD_OLD;
1687 if (!checkitems(items, fp))
1690 if (!checkitemsize(itemsize, sizeof(struct info_restrict)) &&
1691 !checkitemsize(itemsize, v4sizeof(struct info_restrict)))
1695 " address mask count flags\n");
1697 "=====================================================================\n");
1700 memset((char *)&resaddr, 0, sizeof(resaddr));
1701 memset((char *)&maskaddr, 0, sizeof(maskaddr));
1702 if (rl->v6_flag != 0) {
1703 GET_INADDR6(resaddr) = rl->addr6;
1704 GET_INADDR6(maskaddr) = rl->mask6;
1705 resaddr.ss_family = AF_INET6;
1706 maskaddr.ss_family = AF_INET6;
1707 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1708 resaddr.ss_len = SOCKLEN(&resaddr);
1710 addr = nntohost(&resaddr);
1712 GET_INADDR(resaddr) = rl->addr;
1713 GET_INADDR(maskaddr) = rl->mask;
1714 resaddr.ss_family = AF_INET;
1715 maskaddr.ss_family = AF_INET;
1716 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1717 resaddr.ss_len = SOCKLEN(&resaddr);
1719 if ((rl->mask == (u_int32)0xffffffff))
1720 addr = nntohost(&resaddr);
1722 addr = stoa(&resaddr);
1724 mask = stoa(&maskaddr);
1726 if ((pcmd->nargs == 0) ||
1727 ((pcmd->argval->ival == 6) && (rl->v6_flag != 0)) ||
1728 ((pcmd->argval->ival == 4) && (rl->v6_flag == 0)))
1730 count = ntohl(rl->count);
1731 flags = ntohs(rl->flags);
1732 mflags = ntohs(rl->mflags);
1737 while (rf->bit != 0) {
1738 if (mflags & rf->bit) {
1740 (void) strcat(flagstr, comma);
1742 (void) strcat(flagstr, rf->str);
1747 rf = (impl_ver == IMPL_XNTPD_OLD)
1751 while (rf->bit != 0) {
1752 if (flags & rf->bit) {
1754 (void) strcat(flagstr, comma);
1756 (void) strcat(flagstr, rf->str);
1761 if (flagstr[0] == '\0')
1762 (void) strcpy(flagstr, "none");
1765 (void) fprintf(fp, "%-15.15s %-15.15s %9ld %s\n",
1766 addr, mask, (u_long)count, flagstr);
1775 * new_restrict - create/add a set of restrictions
1783 do_restrict(pcmd, fp, REQ_RESADDFLAGS);
1788 * unrestrict - remove restriction flags from existing entry
1796 do_restrict(pcmd, fp, REQ_RESSUBFLAGS);
1801 * delrestrict - delete an existing restriction
1809 do_restrict(pcmd, fp, REQ_UNRESTRICT);
1814 * do_restrict - decode commandline restrictions and make the request
1823 struct conf_restrict cres;
1834 /* Initialize cres */
1842 if (impl_ver == IMPL_XNTPD)
1843 sendsize = sizeof(struct conf_restrict);
1845 sendsize = v4sizeof(struct conf_restrict);
1847 if (pcmd->argval[0].netnum.ss_family == AF_INET) {
1848 cres.addr = GET_INADDR(pcmd->argval[0].netnum);
1849 cres.mask = GET_INADDR(pcmd->argval[1].netnum);
1850 if (impl_ver == IMPL_XNTPD)
1853 if (impl_ver == IMPL_XNTPD_OLD) {
1855 "***Server doesn't understand IPv6 addresses\n");
1858 cres.addr6 = GET_INADDR6(pcmd->argval[0].netnum);
1864 for (res = 2; res < pcmd->nargs; res++) {
1865 if (STREQ(pcmd->argval[res].string, "ntpport")) {
1866 cres.mflags |= RESM_NTPONLY;
1868 for (i = 0; resflagsV3[i].bit != 0; i++) {
1869 if (STREQ(pcmd->argval[res].string,
1873 if (resflagsV3[i].bit != 0) {
1874 cres.flags |= resflagsV3[i].bit;
1875 if (req_code == REQ_UNRESTRICT) {
1877 "Flag %s inappropriate\n",
1882 (void) fprintf(fp, "Unknown flag %s\n",
1883 pcmd->argval[res].string);
1888 cres.flags = htons(cres.flags);
1889 cres.mflags = htons(cres.mflags);
1892 * Make sure mask for default address is zero. Otherwise,
1893 * make sure mask bits are contiguous.
1895 if (pcmd->argval[0].netnum.ss_family == AF_INET) {
1896 if (cres.addr == 0) {
1899 num = ntohl(cres.mask);
1900 for (bit = 0x80000000; bit != 0; bit >>= 1)
1901 if ((num & bit) == 0)
1903 for ( ; bit != 0; bit >>= 1)
1904 if ((num & bit) != 0)
1907 (void) fprintf(fp, "Invalid mask %s\n",
1913 /* XXX IPv6 sanity checking stuff */
1919 res = doquery(impl_ver, req_code, 1, 1,
1920 sendsize, (char *)&cres, &items,
1921 &itemsize, &dummy, 0, sizeof(struct conf_restrict));
1923 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1924 impl_ver = IMPL_XNTPD_OLD;
1929 (void) fprintf(fp, "done!\n");
1935 * monlist - obtain and print the server's monitor data
1945 struct sockaddr_storage addr;
1946 struct sockaddr_storage dstadr;
1952 if (pcmd->nargs > 0) {
1953 version = pcmd->argval[0].ival;
1957 res = doquery(impl_ver,
1958 (version == 1 || version == -1) ? REQ_MON_GETLIST_1 :
1959 REQ_MON_GETLIST, 0, 0, 0, (char *)NULL,
1960 &items, &itemsize, &struct_star,
1961 (version < 0) ? (1 << INFO_ERR_REQ) : 0,
1962 sizeof(struct info_monitor_1));
1964 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1965 impl_ver = IMPL_XNTPD_OLD;
1969 if (res == INFO_ERR_REQ && version < 0)
1970 res = doquery(impl_ver, REQ_MON_GETLIST, 0, 0, 0, (char *)NULL,
1971 &items, &itemsize, &struct_star, 0,
1972 sizeof(struct info_monitor));
1977 if (!checkitems(items, fp))
1980 if (itemsize == sizeof(struct info_monitor_1) ||
1981 itemsize == v4sizeof(struct info_monitor_1)) {
1982 struct info_monitor_1 *ml = (struct info_monitor_1 *) struct_star;
1985 "remote address port local address count m ver code avgint lstint\n");
1987 "===============================================================================\n");
1989 memset((char *)&addr, 0, sizeof(addr));
1990 memset((char *)&dstadr, 0, sizeof(dstadr));
1991 if (ml->v6_flag != 0) {
1992 GET_INADDR6(addr) = ml->addr6;
1993 addr.ss_family = AF_INET6;
1994 GET_INADDR6(dstadr) = ml->daddr6;
1995 dstadr.ss_family = AF_INET6;
1997 GET_INADDR(addr) = ml->addr;
1998 addr.ss_family = AF_INET;
1999 GET_INADDR(dstadr) = ml->daddr;
2000 dstadr.ss_family = AF_INET;
2002 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2003 addr.ss_len = SOCKLEN(&addr);
2004 dstadr.ss_len = SOCKLEN(&dstadr);
2006 if ((pcmd->nargs == 0) ||
2007 ((pcmd->argval->ival == 6) && (ml->v6_flag != 0)) ||
2008 ((pcmd->argval->ival == 4) && (ml->v6_flag == 0)))
2010 "%-22.22s %5d %-15s %8ld %1d %1d %6lx %6lu %7lu\n",
2014 (u_long)ntohl(ml->count),
2017 (u_long)ntohl(ml->lastdrop),
2018 (u_long)ntohl(ml->lasttime),
2019 (u_long)ntohl(ml->firsttime));
2023 } else if (itemsize == sizeof(struct info_monitor) ||
2024 itemsize == v4sizeof(struct info_monitor)) {
2025 struct info_monitor *ml = (struct info_monitor *) struct_star;
2028 " address port count mode ver code avgint lstint\n");
2030 "===============================================================================\n");
2032 memset((char *)&dstadr, 0, sizeof(dstadr));
2033 if (ml->v6_flag != 0) {
2034 GET_INADDR6(dstadr) = ml->addr6;
2035 dstadr.ss_family = AF_INET6;
2037 GET_INADDR(dstadr) = ml->addr;
2038 dstadr.ss_family = AF_INET;
2040 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2041 dstadr.ss_len = SOCKLEN(&dstadr);
2043 if ((pcmd->nargs == 0) ||
2044 ((pcmd->argval->ival == 6) && (ml->v6_flag != 0)) ||
2045 ((pcmd->argval->ival == 4) && (ml->v6_flag == 0)))
2047 "%-25.25s %5d %9ld %4d %2d %9lx %9lu %9lu\n",
2050 (u_long)ntohl(ml->count),
2053 (u_long)ntohl(ml->lastdrop),
2054 (u_long)ntohl(ml->lasttime),
2055 (u_long)ntohl(ml->firsttime));
2059 } else if (itemsize == sizeof(struct old_info_monitor)) {
2060 struct old_info_monitor *oml = (struct old_info_monitor *)struct_star;
2062 " address port count mode version lasttime firsttime\n");
2064 "======================================================================\n");
2066 memset((char *)&dstadr, 0, sizeof(dstadr));
2067 if (oml->v6_flag != 0) {
2068 GET_INADDR6(dstadr) = oml->addr6;
2069 dstadr.ss_family = AF_INET6;
2071 GET_INADDR(dstadr) = oml->addr;
2072 dstadr.ss_family = AF_INET;
2074 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2075 dstadr.ss_len = SOCKLEN(&dstadr);
2077 (void) fprintf(fp, "%-20.20s %5d %9ld %4d %3d %9lu %9lu\n",
2080 (u_long)ntohl(oml->count),
2083 (u_long)ntohl(oml->lasttime),
2084 (u_long)ntohl(oml->firsttime));
2089 /* issue warning according to new info_monitor size */
2090 checkitemsize(itemsize, sizeof(struct info_monitor));
2096 * Mapping between command line strings and stat reset flags
2102 { "io", RESET_FLAG_IO },
2103 { "sys", RESET_FLAG_SYS },
2104 { "mem", RESET_FLAG_MEM },
2105 { "timer", RESET_FLAG_TIMER },
2106 { "auth", RESET_FLAG_AUTH },
2107 { "allpeers", RESET_FLAG_ALLPEERS },
2112 * reset - reset statistic counters
2120 struct reset_flags rflags;
2130 for (res = 0; res < pcmd->nargs; res++) {
2131 for (i = 0; sreset[i].flag != 0; i++) {
2132 if (STREQ(pcmd->argval[res].string, sreset[i].str))
2135 if (sreset[i].flag == 0) {
2136 (void) fprintf(fp, "Flag %s unknown\n",
2137 pcmd->argval[res].string);
2140 rflags.flags |= sreset[i].flag;
2143 rflags.flags = htonl(rflags.flags);
2146 (void) fprintf(fp, "Not done due to errors\n");
2151 res = doquery(impl_ver, REQ_RESET_STATS, 1, 1,
2152 sizeof(struct reset_flags), (char *)&rflags, &items,
2153 &itemsize, &dummy, 0, sizeof(struct reset_flags));
2155 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2156 impl_ver = IMPL_XNTPD_OLD;
2161 (void) fprintf(fp, "done!\n");
2168 * preset - reset stat counters for particular peers
2176 /* 8 is the maximum number of peers which will fit in a packet */
2177 struct conf_unpeer *pl, plist[min(MAXARGS, 8)];
2186 if (impl_ver == IMPL_XNTPD)
2187 sendsize = sizeof(struct conf_unpeer);
2189 sendsize = v4sizeof(struct conf_unpeer);
2191 for (qitems = 0, pl = plist; qitems < min(pcmd->nargs, 8); qitems++) {
2192 if (pcmd->argval[qitems].netnum.ss_family == AF_INET) {
2193 pl->peeraddr = GET_INADDR(pcmd->argval[qitems].netnum);
2194 if (impl_ver == IMPL_XNTPD)
2197 if (impl_ver == IMPL_XNTPD_OLD) {
2199 "***Server doesn't understand IPv6 addresses\n");
2203 GET_INADDR6(pcmd->argval[qitems].netnum);
2206 pl = (struct conf_unpeer *)((char *)pl + sendsize);
2209 res = doquery(impl_ver, REQ_RESET_PEER, 1, qitems,
2210 sendsize, (char *)plist, &items,
2211 &itemsize, &dummy, 0, sizeof(struct conf_unpeer));
2213 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2214 impl_ver = IMPL_XNTPD_OLD;
2219 (void) fprintf(fp, "done!\n");
2224 * readkeys - request the server to reread the keys file
2239 res = doquery(impl_ver, REQ_REREAD_KEYS, 1, 0, 0, (char *)0,
2240 &items, &itemsize, &dummy, 0, sizeof(dummy));
2242 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2243 impl_ver = IMPL_XNTPD_OLD;
2248 (void) fprintf(fp, "done!\n");
2254 * trustkey - add some keys to the trusted key list
2262 do_trustkey(pcmd, fp, REQ_TRUSTKEY);
2267 * untrustkey - remove some keys from the trusted key list
2275 do_trustkey(pcmd, fp, REQ_UNTRUSTKEY);
2280 * do_trustkey - do grunge work of adding/deleting keys
2289 u_long keyids[MAXARGS];
2298 for (i = 0; i < pcmd->nargs; i++) {
2299 keyids[ritems++] = pcmd->argval[i].uval;
2303 res = doquery(impl_ver, req, 1, ritems, sizeof(u_long),
2304 (char *)keyids, &items, &itemsize, &dummy, 0,
2307 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2308 impl_ver = IMPL_XNTPD_OLD;
2313 (void) fprintf(fp, "done!\n");
2320 * authinfo - obtain and print info about authentication
2329 struct info_auth *ia;
2335 res = doquery(impl_ver, REQ_AUTHINFO, 0, 0, 0, (char *)NULL,
2336 &items, &itemsize, (void *)&ia, 0,
2337 sizeof(struct info_auth));
2339 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2340 impl_ver = IMPL_XNTPD_OLD;
2347 if (!check1item(items, fp))
2350 if (!checkitemsize(itemsize, sizeof(struct info_auth)))
2353 (void) fprintf(fp, "time since reset: %ld\n",
2354 (u_long)ntohl(ia->timereset));
2355 (void) fprintf(fp, "stored keys: %ld\n",
2356 (u_long)ntohl(ia->numkeys));
2357 (void) fprintf(fp, "free keys: %ld\n",
2358 (u_long)ntohl(ia->numfreekeys));
2359 (void) fprintf(fp, "key lookups: %ld\n",
2360 (u_long)ntohl(ia->keylookups));
2361 (void) fprintf(fp, "keys not found: %ld\n",
2362 (u_long)ntohl(ia->keynotfound));
2363 (void) fprintf(fp, "uncached keys: %ld\n",
2364 (u_long)ntohl(ia->keyuncached));
2365 (void) fprintf(fp, "encryptions: %ld\n",
2366 (u_long)ntohl(ia->encryptions));
2367 (void) fprintf(fp, "decryptions: %ld\n",
2368 (u_long)ntohl(ia->decryptions));
2369 (void) fprintf(fp, "expired keys: %ld\n",
2370 (u_long)ntohl(ia->expired));
2376 * traps - obtain and print a list of traps
2386 struct info_trap *it;
2387 struct sockaddr_storage trap_addr, local_addr;
2393 res = doquery(impl_ver, REQ_TRAPS, 0, 0, 0, (char *)NULL,
2394 &items, &itemsize, (void *)&it, 0,
2395 sizeof(struct info_trap));
2397 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2398 impl_ver = IMPL_XNTPD_OLD;
2405 if (!checkitems(items, fp))
2408 if (!checkitemsize(itemsize, sizeof(struct info_trap)) &&
2409 !checkitemsize(itemsize, v4sizeof(struct info_trap)))
2412 for (i = 0; i < items; i++ ) {
2414 (void) fprintf(fp, "\n");
2415 memset((char *)&trap_addr, 0, sizeof(trap_addr));
2416 memset((char *)&local_addr, 0, sizeof(local_addr));
2417 if (it->v6_flag != 0) {
2418 GET_INADDR6(trap_addr) = it->trap_address6;
2419 GET_INADDR6(local_addr) = it->local_address6;
2420 trap_addr.ss_family = AF_INET6;
2421 local_addr.ss_family = AF_INET6;
2423 GET_INADDR(trap_addr) = it->trap_address;
2424 GET_INADDR(local_addr) = it->local_address;
2425 trap_addr.ss_family = AF_INET;
2426 local_addr.ss_family = AF_INET;
2428 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2429 trap_addr.ss_len = SOCKLEN(&trap_addr);
2430 local_addr.ss_len = SOCKLEN(&local_addr);
2432 (void) fprintf(fp, "address %s, port %d\n",
2434 ntohs(it->trap_port));
2435 (void) fprintf(fp, "interface: %s, ",
2436 (it->local_address == 0)
2438 : stoa(&local_addr));
2439 if (ntohl(it->flags) & TRAP_CONFIGURED)
2440 (void) fprintf(fp, "configured\n");
2441 else if (ntohl(it->flags) & TRAP_NONPRIO)
2442 (void) fprintf(fp, "low priority\n");
2444 (void) fprintf(fp, "normal priority\n");
2446 (void) fprintf(fp, "set for %ld secs, last set %ld secs ago\n",
2447 (long)ntohl(it->origtime),
2448 (long)ntohl(it->settime));
2449 (void) fprintf(fp, "sequence %d, number of resets %ld\n",
2450 ntohs(it->sequence),
2451 (long)ntohl(it->resets));
2457 * addtrap - configure a trap
2465 do_addclr_trap(pcmd, fp, REQ_ADD_TRAP);
2470 * clrtrap - clear a trap from the server
2478 do_addclr_trap(pcmd, fp, REQ_CLR_TRAP);
2483 * do_addclr_trap - do grunge work of adding/deleting traps
2492 struct conf_trap ctrap;
2500 if (impl_ver == IMPL_XNTPD)
2501 sendsize = sizeof(struct conf_trap);
2503 sendsize = v4sizeof(struct conf_trap);
2505 if (pcmd->argval[0].netnum.ss_family == AF_INET) {
2506 ctrap.trap_address = GET_INADDR(pcmd->argval[0].netnum);
2507 if (impl_ver == IMPL_XNTPD)
2510 if (impl_ver == IMPL_XNTPD_OLD) {
2512 "***Server doesn't understand IPv6 addresses\n");
2515 ctrap.trap_address6 = GET_INADDR6(pcmd->argval[0].netnum);
2518 ctrap.local_address = 0;
2519 ctrap.trap_port = htons(TRAPPORT);
2522 if (pcmd->nargs > 1) {
2524 = htons((u_short)(pcmd->argval[1].uval & 0xffff));
2525 if (pcmd->nargs > 2) {
2526 if (pcmd->argval[2].netnum.ss_family !=
2527 pcmd->argval[0].netnum.ss_family) {
2529 "***Cannot mix IPv4 and IPv6 addresses\n");
2532 if (pcmd->argval[2].netnum.ss_family == AF_INET)
2533 ctrap.local_address = GET_INADDR(pcmd->argval[2].netnum);
2535 ctrap.local_address6 = GET_INADDR6(pcmd->argval[2].netnum);
2539 res = doquery(impl_ver, req, 1, 1, sendsize,
2540 (char *)&ctrap, &items, &itemsize, &dummy, 0,
2541 sizeof(struct conf_trap));
2543 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2544 impl_ver = IMPL_XNTPD_OLD;
2549 (void) fprintf(fp, "done!\n");
2556 * requestkey - change the server's request key (a dangerous request)
2564 do_changekey(pcmd, fp, REQ_REQUEST_KEY);
2569 * controlkey - change the server's control key
2577 do_changekey(pcmd, fp, REQ_CONTROL_KEY);
2583 * do_changekey - do grunge work of changing keys
2599 key = htonl((u_int32)pcmd->argval[0].uval);
2602 res = doquery(impl_ver, req, 1, 1, sizeof(u_int32),
2603 (char *)&key, &items, &itemsize, &dummy, 0,
2606 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2607 impl_ver = IMPL_XNTPD_OLD;
2612 (void) fprintf(fp, "done!\n");
2619 * ctlstats - obtain and print info about authentication
2628 struct info_control *ic;
2634 res = doquery(impl_ver, REQ_GET_CTLSTATS, 0, 0, 0, (char *)NULL,
2635 &items, &itemsize, (void *)&ic, 0,
2636 sizeof(struct info_control));
2638 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2639 impl_ver = IMPL_XNTPD_OLD;
2646 if (!check1item(items, fp))
2649 if (!checkitemsize(itemsize, sizeof(struct info_control)))
2652 (void) fprintf(fp, "time since reset: %ld\n",
2653 (u_long)ntohl(ic->ctltimereset));
2654 (void) fprintf(fp, "requests received: %ld\n",
2655 (u_long)ntohl(ic->numctlreq));
2656 (void) fprintf(fp, "responses sent: %ld\n",
2657 (u_long)ntohl(ic->numctlresponses));
2658 (void) fprintf(fp, "fragments sent: %ld\n",
2659 (u_long)ntohl(ic->numctlfrags));
2660 (void) fprintf(fp, "async messages sent: %ld\n",
2661 (u_long)ntohl(ic->numasyncmsgs));
2662 (void) fprintf(fp, "error msgs sent: %ld\n",
2663 (u_long)ntohl(ic->numctlerrors));
2664 (void) fprintf(fp, "total bad pkts: %ld\n",
2665 (u_long)ntohl(ic->numctlbadpkts));
2666 (void) fprintf(fp, "packet too short: %ld\n",
2667 (u_long)ntohl(ic->numctltooshort));
2668 (void) fprintf(fp, "response on input: %ld\n",
2669 (u_long)ntohl(ic->numctlinputresp));
2670 (void) fprintf(fp, "fragment on input: %ld\n",
2671 (u_long)ntohl(ic->numctlinputfrag));
2672 (void) fprintf(fp, "error set on input: %ld\n",
2673 (u_long)ntohl(ic->numctlinputerr));
2674 (void) fprintf(fp, "bad offset on input: %ld\n",
2675 (u_long)ntohl(ic->numctlbadoffset));
2676 (void) fprintf(fp, "bad version packets: %ld\n",
2677 (u_long)ntohl(ic->numctlbadversion));
2678 (void) fprintf(fp, "data in pkt too short: %ld\n",
2679 (u_long)ntohl(ic->numctldatatooshort));
2680 (void) fprintf(fp, "unknown op codes: %ld\n",
2681 (u_long)ntohl(ic->numctlbadop));
2686 * clockstat - get and print clock status information
2694 struct info_clock *cl;
2695 /* 8 is the maximum number of clocks which will fit in a packet */
2696 u_long clist[min(MAXARGS, 8)];
2702 struct clktype *clk;
2704 for (qitems = 0; qitems < min(pcmd->nargs, 8); qitems++)
2705 clist[qitems] = GET_INADDR(pcmd->argval[qitems].netnum);
2708 res = doquery(impl_ver, REQ_GET_CLOCKINFO, 0, qitems,
2709 sizeof(u_int32), (char *)clist, &items,
2710 &itemsize, (void *)&cl, 0, sizeof(struct info_clock));
2712 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2713 impl_ver = IMPL_XNTPD_OLD;
2720 if (!checkitems(items, fp))
2723 if (!checkitemsize(itemsize, sizeof(struct info_clock)))
2726 while (items-- > 0) {
2727 (void) fprintf(fp, "clock address: %s\n",
2728 numtoa(cl->clockadr));
2729 for (clk = clktypes; clk->code >= 0; clk++)
2730 if (clk->code == cl->type)
2733 (void) fprintf(fp, "clock type: %s\n",
2736 (void) fprintf(fp, "clock type: unknown type (%d)\n",
2738 (void) fprintf(fp, "last event: %d\n",
2740 (void) fprintf(fp, "current status: %d\n",
2742 (void) fprintf(fp, "number of polls: %lu\n",
2743 (u_long)ntohl(cl->polls));
2744 (void) fprintf(fp, "no response to poll: %lu\n",
2745 (u_long)ntohl(cl->noresponse));
2746 (void) fprintf(fp, "bad format responses: %lu\n",
2747 (u_long)ntohl(cl->badformat));
2748 (void) fprintf(fp, "bad data responses: %lu\n",
2749 (u_long)ntohl(cl->baddata));
2750 (void) fprintf(fp, "running time: %lu\n",
2751 (u_long)ntohl(cl->timestarted));
2752 NTOHL_FP(&cl->fudgetime1, &ts);
2753 (void) fprintf(fp, "fudge time 1: %s\n",
2755 NTOHL_FP(&cl->fudgetime2, &ts);
2756 (void) fprintf(fp, "fudge time 2: %s\n",
2758 (void) fprintf(fp, "stratum: %ld\n",
2759 (u_long)ntohl(cl->fudgeval1));
2760 (void) fprintf(fp, "reference ID: %s\n",
2761 refid_string(ntohl(cl->fudgeval2), 0));
2762 (void) fprintf(fp, "fudge flags: 0x%x\n",
2766 (void) fprintf(fp, "\n");
2773 * fudge - set clock fudge factors
2781 struct conf_fudge fudgedata;
2793 memset((char *)&fudgedata, 0, sizeof fudgedata);
2794 fudgedata.clockadr = GET_INADDR(pcmd->argval[0].netnum);
2796 if (STREQ(pcmd->argval[1].string, "time1")) {
2797 fudgedata.which = htonl(FUDGE_TIME1);
2798 if (!atolfp(pcmd->argval[2].string, &ts))
2801 NTOHL_FP(&ts, &fudgedata.fudgetime);
2802 } else if (STREQ(pcmd->argval[1].string, "time2")) {
2803 fudgedata.which = htonl(FUDGE_TIME2);
2804 if (!atolfp(pcmd->argval[2].string, &ts))
2807 NTOHL_FP(&ts, &fudgedata.fudgetime);
2808 } else if (STREQ(pcmd->argval[1].string, "val1")) {
2809 fudgedata.which = htonl(FUDGE_VAL1);
2810 if (!atoint(pcmd->argval[2].string, &val))
2813 fudgedata.fudgeval_flags = htonl(val);
2814 } else if (STREQ(pcmd->argval[1].string, "val2")) {
2815 fudgedata.which = htonl(FUDGE_VAL2);
2816 if (!atoint(pcmd->argval[2].string, &val))
2819 fudgedata.fudgeval_flags = htonl((u_int32)val);
2820 } else if (STREQ(pcmd->argval[1].string, "flags")) {
2821 fudgedata.which = htonl(FUDGE_FLAGS);
2822 if (!hextoint(pcmd->argval[2].string, &u_val))
2825 fudgedata.fudgeval_flags = htonl((u_int32)(u_val & 0xf));
2827 (void) fprintf(stderr, "What fudge is %s?\n",
2828 pcmd->argval[1].string);
2833 (void) fprintf(stderr, "Unknown fudge parameter %s\n",
2834 pcmd->argval[2].string);
2839 res = doquery(impl_ver, REQ_SET_CLKFUDGE, 1, 1,
2840 sizeof(struct conf_fudge), (char *)&fudgedata, &items,
2841 &itemsize, &dummy, 0, sizeof(dummy));
2843 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2844 impl_ver = IMPL_XNTPD_OLD;
2849 (void) fprintf(fp, "done!\n");
2854 * clkbug - get and print clock debugging information
2865 struct info_clkbug *cl;
2866 /* 8 is the maximum number of clocks which will fit in a packet */
2867 u_long clist[min(MAXARGS, 8)];
2876 for (qitems = 0; qitems < min(pcmd->nargs, 8); qitems++)
2877 clist[qitems] = GET_INADDR(pcmd->argval[qitems].netnum);
2880 res = doquery(impl_ver, REQ_GET_CLKBUGINFO, 0, qitems,
2881 sizeof(u_int32), (char *)clist, &items,
2882 &itemsize, (void *)&cl, 0, sizeof(struct info_clkbug));
2884 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2885 impl_ver = IMPL_XNTPD_OLD;
2892 if (!checkitems(items, fp))
2895 if (!checkitemsize(itemsize, sizeof(struct info_clkbug)))
2898 while (items-- > 0) {
2899 (void) fprintf(fp, "clock address: %s\n",
2900 numtoa(cl->clockadr));
2901 n = (int)cl->nvalues;
2902 (void) fprintf(fp, "values: %d", n);
2903 s = ntohs(cl->svalues);
2904 if (n > NUMCBUGVALUES)
2906 for (i = 0; i < n; i++) {
2907 ltemp = ntohl(cl->values[i]);
2908 ltemp &= 0xffffffff; /* HMS: This does nothing now */
2910 (void) fprintf(fp, "\n");
2912 (void) fprintf(fp, "%12ld", (u_long)ltemp);
2914 (void) fprintf(fp, "%12lu", (u_long)ltemp);
2916 (void) fprintf(fp, "\n");
2918 n = (int)cl->ntimes;
2919 (void) fprintf(fp, "times: %d", n);
2920 s = ntohl(cl->stimes);
2921 if (n > NUMCBUGTIMES)
2924 for (i = 0; i < n; i++) {
2925 if ((i & 0x1) == 0) {
2926 (void) fprintf(fp, "\n");
2928 for (;needsp > 0; needsp--)
2931 NTOHL_FP(&cl->times[i], &ts);
2933 (void) fprintf(fp, "%17s",
2937 (void) fprintf(fp, "%37s",
2942 (void) fprintf(fp, "\n");
2945 (void) fprintf(fp, "\n");
2952 * kerninfo - display the kernel pll/pps variables
2960 struct info_kernel *ik;
2965 double tscale = 1e-6;
2968 res = doquery(impl_ver, REQ_GET_KERNEL, 0, 0, 0, (char *)NULL,
2969 &items, &itemsize, (void *)&ik, 0,
2970 sizeof(struct info_kernel));
2972 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2973 impl_ver = IMPL_XNTPD_OLD;
2979 if (!check1item(items, fp))
2981 if (!checkitemsize(itemsize, sizeof(struct info_kernel)))
2984 status = ntohs(ik->status) & 0xffff;
2986 * pll variables. We know more than we should about the NANO bit.
2989 if (status & STA_NANO)
2992 (void)fprintf(fp, "pll offset: %g s\n",
2993 (int32_t)ntohl(ik->offset) * tscale);
2994 (void)fprintf(fp, "pll frequency: %s ppm\n",
2995 fptoa((s_fp)ntohl(ik->freq), 3));
2996 (void)fprintf(fp, "maximum error: %g s\n",
2997 (u_long)ntohl(ik->maxerror) * 1e-6);
2998 (void)fprintf(fp, "estimated error: %g s\n",
2999 (u_long)ntohl(ik->esterror) * 1e-6);
3000 (void)fprintf(fp, "status: %04x ", status);
3002 if (status & STA_PLL) (void)fprintf(fp, " pll");
3005 if (status & STA_PPSFREQ) (void)fprintf(fp, " ppsfreq");
3008 if (status & STA_PPSTIME) (void)fprintf(fp, " ppstime");
3011 if (status & STA_FLL) (void)fprintf(fp, " fll");
3014 if (status & STA_INS) (void)fprintf(fp, " ins");
3017 if (status & STA_DEL) (void)fprintf(fp, " del");
3020 if (status & STA_UNSYNC) (void)fprintf(fp, " unsync");
3023 if (status & STA_FREQHOLD) (void)fprintf(fp, " freqhold");
3025 #ifdef STA_PPSSIGNAL
3026 if (status & STA_PPSSIGNAL) (void)fprintf(fp, " ppssignal");
3028 #ifdef STA_PPSJITTER
3029 if (status & STA_PPSJITTER) (void)fprintf(fp, " ppsjitter");
3031 #ifdef STA_PPSWANDER
3032 if (status & STA_PPSWANDER) (void)fprintf(fp, " ppswander");
3035 if (status & STA_PPSERROR) (void)fprintf(fp, " ppserror");
3038 if (status & STA_CLOCKERR) (void)fprintf(fp, " clockerr");
3041 if (status & STA_NANO) (void)fprintf(fp, " nano");
3044 if (status & STA_MODE) (void)fprintf(fp, " mode=fll");
3047 if (status & STA_CLK) (void)fprintf(fp, " src=B");
3049 (void)fprintf(fp, "\n");
3050 (void)fprintf(fp, "pll time constant: %ld\n",
3051 (u_long)ntohl(ik->constant));
3052 (void)fprintf(fp, "precision: %g s\n",
3053 (u_long)ntohl(ik->precision) * tscale);
3054 (void)fprintf(fp, "frequency tolerance: %s ppm\n",
3055 fptoa((s_fp)ntohl(ik->tolerance), 0));
3058 * For backwards compatibility (ugh), we find the pps variables
3059 * only if the shift member is nonzero.
3067 (void)fprintf(fp, "pps frequency: %s ppm\n",
3068 fptoa((s_fp)ntohl(ik->ppsfreq), 3));
3069 (void)fprintf(fp, "pps stability: %s ppm\n",
3070 fptoa((s_fp)ntohl(ik->stabil), 3));
3071 (void)fprintf(fp, "pps jitter: %g s\n",
3072 (u_long)ntohl(ik->jitter) * tscale);
3073 (void)fprintf(fp, "calibration interval: %d s\n",
3074 1 << ntohs(ik->shift));
3075 (void)fprintf(fp, "calibration cycles: %ld\n",
3076 (u_long)ntohl(ik->calcnt));
3077 (void)fprintf(fp, "jitter exceeded: %ld\n",
3078 (u_long)ntohl(ik->jitcnt));
3079 (void)fprintf(fp, "stability exceeded: %ld\n",
3080 (u_long)ntohl(ik->stbcnt));
3081 (void)fprintf(fp, "calibration errors: %ld\n",
3082 (u_long)ntohl(ik->errcnt));
3085 #define IF_LIST_FMT "%2d %c %48s %c %c %12.12s %03x %3d %2d %5d %5d %5d %2d %2d %3d %7d\n"
3086 #define IF_LIST_FMT_STR "%2s %c %48s %c %c %12.12s %3s %3s %2s %5s %5s %5s %2s %2s %3s %7s\n"
3087 #define IF_LIST_AFMT_STR " %48s %c\n"
3088 #define IF_LIST_LABELS "#", 'A', "Address/Mask/Broadcast", 'T', 'E', "IF name", "Flg", "TL", "#M", "recv", "sent", "drop", "S", "IX", "PC", "uptime"
3089 #define IF_LIST_LINE "=====================================================================================================================\n"
3094 struct info_if_stats *ifs,
3100 static char *actions = "?.+-";
3101 struct sockaddr_storage saddr;
3106 if (!checkitems(items, fp))
3109 if (!checkitemsize(itemsize, sizeof(struct info_if_stats)))
3112 fprintf(fp, IF_LIST_FMT_STR, IF_LIST_LABELS);
3113 fprintf(fp, IF_LIST_LINE);
3116 if (ntohl(ifs->v6_flag)) {
3117 memcpy((char *)&GET_INADDR6(saddr), (char *)&ifs->unaddr.addr6, sizeof(ifs->unaddr.addr6));
3118 saddr.ss_family = AF_INET6;
3120 memcpy((char *)&GET_INADDR(saddr), (char *)&ifs->unaddr.addr, sizeof(ifs->unaddr.addr));
3121 saddr.ss_family = AF_INET;
3123 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
3124 saddr.ss_len = SOCKLEN(&saddr);
3126 fprintf(fp, IF_LIST_FMT,
3128 actions[(ifs->action >= 1 && ifs->action < 4) ? ifs->action : 0],
3129 stoa((&saddr)), 'A',
3130 ifs->ignore_packets ? 'D' : 'E',
3133 ntohl(ifs->last_ttl),
3134 ntohl(ifs->num_mcast),
3135 ntohl(ifs->received),
3137 ntohl(ifs->notsent),
3138 ntohl(ifs->scopeid),
3139 ntohl(ifs->ifindex),
3140 ntohl(ifs->peercnt),
3141 ntohl(ifs->uptime));
3143 if (ntohl(ifs->v6_flag)) {
3144 memcpy((char *)&GET_INADDR6(saddr), (char *)&ifs->unmask.addr6, sizeof(ifs->unmask.addr6));
3145 saddr.ss_family = AF_INET6;
3147 memcpy((char *)&GET_INADDR(saddr), (char *)&ifs->unmask.addr, sizeof(ifs->unmask.addr));
3148 saddr.ss_family = AF_INET;
3150 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
3151 saddr.ss_len = SOCKLEN(&saddr);
3153 fprintf(fp, IF_LIST_AFMT_STR, stoa(&saddr), 'M');
3155 if (!ntohl(ifs->v6_flag) && ntohl(ifs->flags) & (INT_BCASTOPEN)) {
3156 memcpy((char *)&GET_INADDR(saddr), (char *)&ifs->unbcast.addr, sizeof(ifs->unbcast.addr));
3157 saddr.ss_family = AF_INET;
3158 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
3159 saddr.ss_len = SOCKLEN(&saddr);
3161 fprintf(fp, IF_LIST_AFMT_STR, stoa(&saddr), 'B');
3177 struct info_if_stats *ifs;
3182 res = doquery(impl_ver, REQ_IF_STATS, 1, 0, 0, (char *)NULL, &items,
3183 &itemsize, (void *)&ifs, 0,
3184 sizeof(struct info_if_stats));
3185 iflist(fp, ifs, items, itemsize, res);
3195 struct info_if_stats *ifs;
3200 res = doquery(impl_ver, REQ_IF_RELOAD, 1, 0, 0, (char *)NULL, &items,
3201 &itemsize, (void *)&ifs, 0,
3202 sizeof(struct info_if_stats));
3203 iflist(fp, ifs, items, itemsize, res);