![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ntpdc_ops.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpdc|
Return to ntpdc_ops.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpdc |
1.1 misho 1: /*
2: * ntpdc_ops.c - subroutines which are called to perform operations by
3: * ntpdc
4: */
5:
6: #ifdef HAVE_CONFIG_H
7: # include <config.h>
8: #endif
9:
10: #include <stdio.h>
11: #include <stddef.h>
12:
13: #include "ntpdc.h"
14: #include "ntp_net.h"
15: #include "ntp_control.h"
16: #include "ntp_refclock.h"
17: #include "ntp_stdlib.h"
18:
19: #include <ctype.h>
20: #ifdef HAVE_SYS_TIMEX_H
21: # include <sys/timex.h>
22: #endif
23: #if !defined(__bsdi__) && !defined(apollo)
24: #ifdef HAVE_NETINET_IN_H
25: #include <netinet/in.h>
26: #endif
27: #endif
28:
29: #include <arpa/inet.h>
30:
31: /*
32: * utility functions
33: */
34: static int checkitems (int, FILE *);
35: static int checkitemsize (int, int);
36: static int check1item (int, FILE *);
37:
38: /*
39: * Declarations for command handlers in here
40: */
41: static void peerlist (struct parse *, FILE *);
42: static void peers (struct parse *, FILE *);
43: static void doconfig (struct parse *pcmd, FILE *fp, int mode, int refc);
44: static void dmpeers (struct parse *, FILE *);
45: static void dopeers (struct parse *, FILE *, int);
46: static void printpeer (struct info_peer *, FILE *);
47: static void showpeer (struct parse *, FILE *);
48: static void peerstats (struct parse *, FILE *);
49: static void loopinfo (struct parse *, FILE *);
50: static void sysinfo (struct parse *, FILE *);
51: static void sysstats (struct parse *, FILE *);
52: static void iostats (struct parse *, FILE *);
53: static void memstats (struct parse *, FILE *);
54: static void timerstats (struct parse *, FILE *);
55: static void addpeer (struct parse *, FILE *);
56: static void addserver (struct parse *, FILE *);
57: static void addrefclock (struct parse *, FILE *);
58: static void broadcast (struct parse *, FILE *);
59: static void doconfig (struct parse *, FILE *, int, int);
60: static void unconfig (struct parse *, FILE *);
61: static void set (struct parse *, FILE *);
62: static void sys_clear (struct parse *, FILE *);
63: static void doset (struct parse *, FILE *, int);
64: static void reslist (struct parse *, FILE *);
65: static void new_restrict (struct parse *, FILE *);
66: static void unrestrict (struct parse *, FILE *);
67: static void delrestrict (struct parse *, FILE *);
68: static void do_restrict (struct parse *, FILE *, int);
69: static void monlist (struct parse *, FILE *);
70: static void reset (struct parse *, FILE *);
71: static void preset (struct parse *, FILE *);
72: static void readkeys (struct parse *, FILE *);
73: static void trustkey (struct parse *, FILE *);
74: static void untrustkey (struct parse *, FILE *);
75: static void do_trustkey (struct parse *, FILE *, int);
76: static void authinfo (struct parse *, FILE *);
77: static void traps (struct parse *, FILE *);
78: static void addtrap (struct parse *, FILE *);
79: static void clrtrap (struct parse *, FILE *);
80: static void do_addclr_trap (struct parse *, FILE *, int);
81: static void requestkey (struct parse *, FILE *);
82: static void controlkey (struct parse *, FILE *);
83: static void do_changekey (struct parse *, FILE *, int);
84: static void ctlstats (struct parse *, FILE *);
85: static void clockstat (struct parse *, FILE *);
86: static void fudge (struct parse *, FILE *);
87: static void clkbug (struct parse *, FILE *);
88: static void kerninfo (struct parse *, FILE *);
89: static void get_if_stats (struct parse *, FILE *);
90: static void do_if_reload (struct parse *, FILE *);
91:
92: /*
93: * Commands we understand. Ntpdc imports this.
94: */
95: struct xcmd opcmds[] = {
96: { "listpeers", peerlist, { OPT|IP_VERSION, NO, NO, NO },
97: { "-4|-6", "", "", "" },
98: "display list of peers the server knows about [IP Version]" },
99: { "peers", peers, { OPT|IP_VERSION, NO, NO, NO },
100: { "-4|-6", "", "", "" },
101: "display peer summary information [IP Version]" },
102: { "dmpeers", dmpeers, { OPT|IP_VERSION, NO, NO, NO },
103: { "-4|-6", "", "", "" },
104: "display peer summary info the way Dave Mills likes it (IP Version)" },
105: { "showpeer", showpeer, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD},
106: { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" },
107: "display detailed information for one or more peers" },
108: { "pstats", peerstats, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD },
109: { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" },
110: "display statistical information for one or more peers" },
111: { "loopinfo", loopinfo, { OPT|NTP_STR, NO, NO, NO },
112: { "oneline|multiline", "", "", "" },
113: "display loop filter information" },
114: { "sysinfo", sysinfo, { NO, NO, NO, NO },
115: { "", "", "", "" },
116: "display local server information" },
117: { "sysstats", sysstats, { NO, NO, NO, NO },
118: { "", "", "", "" },
119: "display local server statistics" },
120: { "memstats", memstats, { NO, NO, NO, NO },
121: { "", "", "", "" },
122: "display peer memory usage statistics" },
123: { "iostats", iostats, { NO, NO, NO, NO },
124: { "", "", "", "" },
125: "display I/O subsystem statistics" },
126: { "timerstats", timerstats, { NO, NO, NO, NO },
127: { "", "", "", "" },
128: "display event timer subsystem statistics" },
129: { "addpeer", addpeer, { NTP_ADD, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
130: { "addr", "keyid", "version", "minpoll#|prefer|burst|iburst|'minpoll N'|'maxpoll N'|'keyid N'|'version N' ..." },
131: "configure a new peer association" },
132: { "addserver", addserver, { NTP_ADD, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
133: { "addr", "keyid", "version", "minpoll#|prefer|burst|iburst|'minpoll N'|'maxpoll N'|'keyid N'|'version N' ..." },
134: "configure a new server" },
135: { "addrefclock",addrefclock, { NTP_ADD, OPT|NTP_UINT, OPT|NTP_STR, OPT|NTP_STR },
136: { "addr", "mode", "minpoll|prefer", "minpoll|prefer" },
137: "configure a new server" },
138: { "broadcast", broadcast, { NTP_ADD, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
139: { "addr", "keyid", "version", "minpoll" },
140: "configure broadcasting time service" },
141: { "unconfig", unconfig, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD },
142: { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" },
143: "unconfigure existing peer assocations" },
144: { "enable", set, { NTP_STR, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
145: { "auth|bclient|monitor|pll|kernel|stats", "...", "...", "..." },
146: "set a system flag (auth, bclient, monitor, pll, kernel, stats)" },
147: { "disable", sys_clear, { NTP_STR, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
148: { "auth|bclient|monitor|pll|kernel|stats", "...", "...", "..." },
149: "clear a system flag (auth, bclient, monitor, pll, kernel, stats)" },
150: { "reslist", reslist, {OPT|IP_VERSION, NO, NO, NO },
151: { "-4|-6", "", "", "" },
152: "display the server's restrict list" },
153: { "restrict", new_restrict, { NTP_ADD, NTP_ADD, NTP_STR, OPT|NTP_STR },
154: { "address", "mask",
155: "ntpport|ignore|noserve|notrust|noquery|nomodify|nopeer|version|kod",
156: "..." },
157: "create restrict entry/add flags to entry" },
158: { "unrestrict", unrestrict, { NTP_ADD, NTP_ADD, NTP_STR, OPT|NTP_STR },
159: { "address", "mask",
160: "ntpport|ignore|noserve|notrust|noquery|nomodify|nopeer|version|kod",
161: "..." },
162: "remove flags from a restrict entry" },
163: { "delrestrict", delrestrict, { NTP_ADD, NTP_ADD, OPT|NTP_STR, NO },
164: { "address", "mask", "ntpport", "" },
165: "delete a restrict entry" },
166: { "monlist", monlist, { OPT|NTP_INT, NO, NO, NO },
167: { "version", "", "", "" },
168: "display data the server's monitor routines have collected" },
169: { "reset", reset, { NTP_STR, OPT|NTP_STR, OPT|NTP_STR, OPT|NTP_STR },
170: { "io|sys|mem|timer|auth|allpeers", "...", "...", "..." },
171: "reset various subsystem statistics counters" },
172: { "preset", preset, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD },
173: { "peer_address", "peer2_addr", "peer3_addr", "peer4_addr" },
174: "reset stat counters associated with particular peer(s)" },
175: { "readkeys", readkeys, { NO, NO, NO, NO },
176: { "", "", "", "" },
177: "request a reread of the keys file and re-init of system keys" },
178: { "trustedkey", trustkey, { NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT },
179: { "keyid", "keyid", "keyid", "keyid" },
180: "add one or more key ID's to the trusted list" },
181: { "untrustedkey", untrustkey, { NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT, OPT|NTP_UINT },
182: { "keyid", "keyid", "keyid", "keyid" },
183: "remove one or more key ID's from the trusted list" },
184: { "authinfo", authinfo, { NO, NO, NO, NO },
185: { "", "", "", "" },
186: "display the state of the authentication code" },
187: { "traps", traps, { NO, NO, NO, NO },
188: { "", "", "", "" },
189: "display the traps set in the server" },
190: { "addtrap", addtrap, { NTP_ADD, OPT|NTP_UINT, OPT|NTP_ADD, NO },
191: { "address", "port", "interface", "" },
192: "configure a trap in the server" },
193: { "clrtrap", clrtrap, { NTP_ADD, OPT|NTP_UINT, OPT|NTP_ADD, NO },
194: { "address", "port", "interface", "" },
195: "remove a trap (configured or otherwise) from the server" },
196: { "requestkey", requestkey, { NTP_UINT, NO, NO, NO },
197: { "keyid", "", "", "" },
198: "change the keyid the server uses to authenticate requests" },
199: { "controlkey", controlkey, { NTP_UINT, NO, NO, NO },
200: { "keyid", "", "", "" },
201: "change the keyid the server uses to authenticate control messages" },
202: { "ctlstats", ctlstats, { NO, NO, NO, NO },
203: { "", "", "", "" },
204: "display packet count statistics from the control module" },
205: { "clockstat", clockstat, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD },
206: { "address", "address", "address", "address" },
207: "display clock status information" },
208: { "fudge", fudge, { NTP_ADD, NTP_STR, NTP_STR, NO },
209: { "address", "time1|time2|val1|val2|flags", "value", "" },
210: "set/change one of a clock's fudge factors" },
211: { "clkbug", clkbug, { NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD, OPT|NTP_ADD },
212: { "address", "address", "address", "address" },
213: "display clock debugging information" },
214: { "kerninfo", kerninfo, { NO, NO, NO, NO },
215: { "", "", "", "" },
216: "display the kernel pll/pps variables" },
217: { "ifstats", get_if_stats, { NO, NO, NO, NO },
218: { "", "", "", "" },
219: "list interface statistics" },
220: { "ifreload", do_if_reload, { NO, NO, NO, NO },
221: { "", "", "", "" },
222: "reload interface configuration" },
223: { 0, 0, { NO, NO, NO, NO },
224: { "", "", "", "" }, "" }
225: };
226:
227: /*
228: * For quick string comparisons
229: */
230: #define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
231:
232: /*
233: * SET_SS_LEN_IF_PRESENT - used by SET_ADDR, SET_ADDRS macros
234: */
235:
236: #ifdef ISC_PLATFORM_HAVESALEN
237: #define SET_SS_LEN_IF_PRESENT(psau) \
238: do { \
239: (psau)->sa.sa_len = SOCKLEN(psau); \
240: } while (0)
241: #else
242: #define SET_SS_LEN_IF_PRESENT(psau) do { } while (0)
243: #endif
244:
245: /*
246: * SET_ADDR - setup address for v4/v6 as needed
247: */
248: #define SET_ADDR(address, v6flag, v4addr, v6addr) \
249: do { \
250: memset(&(address), 0, sizeof(address)); \
251: if (v6flag) { \
252: AF(&(address)) = AF_INET6; \
253: SOCK_ADDR6(&(address)) = (v6addr); \
254: } else { \
255: AF(&(address)) = AF_INET; \
256: NSRCADR(&(address)) = (v4addr); \
257: } \
258: SET_SS_LEN_IF_PRESENT(&(address)); \
259: } while (0)
260:
261:
262: /*
263: * SET_ADDRS - setup source and destination addresses for
264: * v4/v6 as needed
265: */
266: #define SET_ADDRS(a1, a2, info, a1prefix, a2prefix) \
267: do { \
268: memset(&(a1), 0, sizeof(a1)); \
269: memset(&(a2), 0, sizeof(a2)); \
270: if ((info)->v6_flag) { \
271: AF(&(a1)) = AF_INET6; \
272: AF(&(a2)) = AF_INET6; \
273: SOCK_ADDR6(&(a1)) = (info)->a1prefix##6; \
274: SOCK_ADDR6(&(a2)) = (info)->a2prefix##6; \
275: } else { \
276: AF(&(a1)) = AF_INET; \
277: AF(&(a2)) = AF_INET; \
278: NSRCADR(&(a1)) = (info)->a1prefix; \
279: NSRCADR(&(a2)) = (info)->a2prefix; \
280: } \
281: SET_SS_LEN_IF_PRESENT(&(a1)); \
282: SET_SS_LEN_IF_PRESENT(&(a2)); \
283: } while (0)
284:
285:
286: /*
287: * SET_ADDRS - setup source and destination addresses for
288: * v4/v6 as needed
289: */
290: #if 0
291: #define SET_ADDR_MASK(address, addrmask, info) \
292: do { \
293: memset(&(address), 0, sizeof(address)); \
294: memset(&(mask), 0, sizeof(mask)); \
295: if ((info)->v6_flag) { \
296: AF(&(address)) = AF_INET6; \
297: AF(&(addrmask)) = AF_INET6; \
298: SOCK_ADDR6(&(address)) = (info)->addr6; \
299: SOCK_ADDR6(&(addrmask)) = (info)->mask6; \
300: } else { \
301: AF(&(address)) = AF_INET; \
302: AF(&(addrmask)) = AF_INET; \
303: NSRCADR(&(address)) = (info)->addr; \
304: NSRCADR(&(addrmask)) = (info)->mask; \
305: } \
306: SET_SS_LEN_IF_PRESENT(&(address)); \
307: SET_SS_LEN_IF_PRESENT(&(addrmask)); \
308: } while (0)
309: #endif
310:
311: /*
312: * checkitems - utility to print a message if no items were returned
313: */
314: static int
315: checkitems(
316: int items,
317: FILE *fp
318: )
319: {
320: if (items == 0) {
321: (void) fprintf(fp, "No data returned in response to query\n");
322: return 0;
323: }
324: return 1;
325: }
326:
327:
328: /*
329: * checkitemsize - utility to print a message if the item size is wrong
330: */
331: static int
332: checkitemsize(
333: int itemsize,
334: int expected
335: )
336: {
337: if (itemsize != expected) {
338: (void) fprintf(stderr,
339: "***Incorrect item size returned by remote host (%d should be %d)\n",
340: itemsize, expected);
341: return 0;
342: }
343: return 1;
344: }
345:
346:
347: /*
348: * check1item - check to make sure we have exactly one item
349: */
350: static int
351: check1item(
352: int items,
353: FILE *fp
354: )
355: {
356: if (items == 0) {
357: (void) fprintf(fp, "No data returned in response to query\n");
358: return 0;
359: }
360: if (items > 1) {
361: (void) fprintf(fp, "Expected one item in response, got %d\n",
362: items);
363: return 0;
364: }
365: return 1;
366: }
367:
368:
369: /*
370: * peerlist - get a short list of peers
371: */
372: /*ARGSUSED*/
373: static void
374: peerlist(
375: struct parse *pcmd,
376: FILE *fp
377: )
378: {
379: struct info_peer_list *plist;
380: sockaddr_u paddr;
381: int items;
382: int itemsize;
383: int res;
384:
385: again:
386: res = doquery(impl_ver, REQ_PEER_LIST, 0, 0, 0, (char *)NULL, &items,
387: &itemsize, (void *)&plist, 0,
388: sizeof(struct info_peer_list));
389:
390: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
391: impl_ver = IMPL_XNTPD_OLD;
392: goto again;
393: }
394:
395: if (res != 0)
396: return;
397:
398: if (!checkitems(items, fp))
399: return;
400:
401: if (!checkitemsize(itemsize, sizeof(struct info_peer_list)) &&
402: !checkitemsize(itemsize, v4sizeof(struct info_peer_list)))
403: return;
404:
405: while (items > 0) {
406: SET_ADDR(paddr, plist->v6_flag, plist->addr, plist->addr6);
407: if ((pcmd->nargs == 0) ||
408: ((pcmd->argval->ival == 6) && (plist->v6_flag != 0)) ||
409: ((pcmd->argval->ival == 4) && (plist->v6_flag == 0)))
410: (void) fprintf(fp, "%-9s %s\n",
411: modetoa(plist->hmode),
412: nntohost(&paddr));
413: plist++;
414: items--;
415: }
416: }
417:
418:
419: /*
420: * peers - show peer summary
421: */
422: static void
423: peers(
424: struct parse *pcmd,
425: FILE *fp
426: )
427: {
428: dopeers(pcmd, fp, 0);
429: }
430:
431: /*
432: * dmpeers - show peer summary, Dave Mills style
433: */
434: static void
435: dmpeers(
436: struct parse *pcmd,
437: FILE *fp
438: )
439: {
440: dopeers(pcmd, fp, 1);
441: }
442:
443:
444: /*
445: * peers - show peer summary
446: */
447: /*ARGSUSED*/
448: static void
449: dopeers(
450: struct parse *pcmd,
451: FILE *fp,
452: int dmstyle
453: )
454: {
455: struct info_peer_summary *plist;
456: sockaddr_u dstadr;
457: sockaddr_u srcadr;
458: int items;
459: int itemsize;
460: int ntp_poll;
461: int res;
462: int c;
463: l_fp tempts;
464:
465: again:
466: res = doquery(impl_ver, REQ_PEER_LIST_SUM, 0, 0, 0, (char *)NULL,
467: &items, &itemsize, (void *)&plist, 0,
468: sizeof(struct info_peer_summary));
469:
470: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
471: impl_ver = IMPL_XNTPD_OLD;
472: goto again;
473: }
474:
475: if (res != 0)
476: return;
477:
478: if (!checkitems(items, fp))
479: return;
480:
481: if (!checkitemsize(itemsize, sizeof(struct info_peer_summary)) &&
482: !checkitemsize(itemsize, v4sizeof(struct info_peer_summary)))
483: return;
484:
485: (void) fprintf(fp,
486: " remote local st poll reach delay offset disp\n");
487: (void) fprintf(fp,
488: "=======================================================================\n");
489: while (items > 0) {
490: if (!dmstyle) {
491: if (plist->flags & INFO_FLAG_SYSPEER)
492: c = '*';
493: else if (plist->hmode == MODE_ACTIVE)
494: c = '+';
495: else if (plist->hmode == MODE_PASSIVE)
496: c = '-';
497: else if (plist->hmode == MODE_CLIENT)
498: c = '=';
499: else if (plist->hmode == MODE_BROADCAST)
500: c = '^';
501: else if (plist->hmode == MODE_BCLIENT)
502: c = '~';
503: else
504: c = ' ';
505: } else {
506: if (plist->flags & INFO_FLAG_SYSPEER)
507: c = '*';
508: else if (plist->flags & INFO_FLAG_SHORTLIST)
509: c = '+';
510: else if (plist->flags & INFO_FLAG_SEL_CANDIDATE)
511: c = '.';
512: else
513: c = ' ';
514: }
515: NTOHL_FP(&(plist->offset), &tempts);
516: ntp_poll = 1<<max(min3(plist->ppoll, plist->hpoll, NTP_MAXPOLL),
517: NTP_MINPOLL);
518: SET_ADDRS(dstadr, srcadr, plist, dstadr, srcadr);
519: if ((pcmd->nargs == 0) ||
520: ((pcmd->argval->ival == 6) && (plist->v6_flag != 0)) ||
521: ((pcmd->argval->ival == 4) && (plist->v6_flag == 0)))
522: (void) fprintf(fp,
523: "%c%-15.15s %-15.15s %2u %4d %3o %7.7s %9.9s %7.7s\n",
524: c, nntohost(&srcadr), stoa(&dstadr),
525: plist->stratum, ntp_poll, plist->reach,
526: fptoa(NTOHS_FP(plist->delay), 5),
527: lfptoa(&tempts, 6),
528: ufptoa(NTOHS_FP(plist->dispersion), 5));
529: plist++;
530: items--;
531: }
532: }
533:
534: /* Convert a refid & stratum (in host order) to a string */
535: static char*
536: refid_string(
537: u_int32 refid,
538: int stratum
539: )
540: {
541: if (stratum <= 1) {
542: static char junk[5];
543: junk[4] = 0;
544: memmove(junk, (char *)&refid, 4);
545: return junk;
546: }
547:
548: return numtoa(refid);
549: }
550:
551: static void
552: print_pflag(
553: FILE *fp,
554: u_int32 flags
555: )
556: {
557: const char *str;
558:
559: if (flags == 0) {
560: (void) fprintf(fp, " none\n");
561: } else {
562: str = "";
563: if (flags & INFO_FLAG_SYSPEER) {
564: (void) fprintf(fp, " system_peer");
565: str = ",";
566: }
567: if (flags & INFO_FLAG_CONFIG) {
568: (void) fprintf(fp, "%s config", str);
569: str = ",";
570: }
571: if (flags & INFO_FLAG_REFCLOCK) {
572: (void) fprintf(fp, "%s refclock", str);
573: str = ",";
574: }
575: if (flags & INFO_FLAG_AUTHENABLE) {
576: (void) fprintf(fp, "%s auth", str);
577: str = ",";
578: }
579: if (flags & INFO_FLAG_BCLIENT) {
580: (void) fprintf(fp, "%s bclient", str);
581: str = ",";
582: }
583: if (flags & INFO_FLAG_PREFER) {
584: (void) fprintf(fp, "%s prefer", str);
585: str = ",";
586: }
587: if (flags & INFO_FLAG_IBURST) {
588: (void) fprintf(fp, "%s iburst", str);
589: str = ",";
590: }
591: if (flags & INFO_FLAG_BURST) {
592: (void) fprintf(fp, "%s burst", str);
593: }
594: (void) fprintf(fp, "\n");
595: }
596: }
597: /*
598: * printpeer - print detail information for a peer
599: */
600: static void
601: printpeer(
602: register struct info_peer *pp,
603: FILE *fp
604: )
605: {
606: register int i;
607: l_fp tempts;
608: sockaddr_u srcadr, dstadr;
609:
610: SET_ADDRS(dstadr, srcadr, pp, dstadr, srcadr);
611:
612: (void) fprintf(fp, "remote %s, local %s\n",
613: stoa(&srcadr), stoa(&dstadr));
614: (void) fprintf(fp, "hmode %s, pmode %s, stratum %d, precision %d\n",
615: modetoa(pp->hmode), modetoa(pp->pmode),
616: pp->stratum, pp->precision);
617:
618: (void) fprintf(fp,
619: "leap %c%c, refid [%s], rootdistance %s, rootdispersion %s\n",
620: pp->leap & 0x2 ? '1' : '0',
621: pp->leap & 0x1 ? '1' : '0',
622: refid_string(pp->refid, pp->stratum), fptoa(NTOHS_FP(pp->rootdelay), 5),
623: ufptoa(NTOHS_FP(pp->rootdispersion), 5));
624:
625: (void) fprintf(fp,
626: "ppoll %d, hpoll %d, keyid %lu, version %d, association %u\n",
627: pp->ppoll, pp->hpoll, (u_long)pp->keyid, pp->version, ntohs(pp->associd));
628:
629: (void) fprintf(fp,
630: "reach %03o, unreach %d, flash 0x%04x, ",
631: pp->reach, pp->unreach, pp->flash2);
632:
633: (void) fprintf(fp, "boffset %s, ttl/mode %d\n",
634: fptoa(NTOHS_FP(pp->estbdelay), 5), pp->ttl);
635:
636: (void) fprintf(fp, "timer %lds, flags", (long)ntohl(pp->timer));
637: print_pflag(fp, pp->flags);
638:
639: NTOHL_FP(&pp->reftime, &tempts);
640: (void) fprintf(fp, "reference time: %s\n",
641: prettydate(&tempts));
642: NTOHL_FP(&pp->org, &tempts);
643: (void) fprintf(fp, "originate timestamp: %s\n",
644: prettydate(&tempts));
645: NTOHL_FP(&pp->rec, &tempts);
646: (void) fprintf(fp, "receive timestamp: %s\n",
647: prettydate(&tempts));
648: NTOHL_FP(&pp->xmt, &tempts);
649: (void) fprintf(fp, "transmit timestamp: %s\n",
650: prettydate(&tempts));
651:
652: (void) fprintf(fp, "filter delay: ");
653: for (i = 0; i < NTP_SHIFT; i++) {
654: (void) fprintf(fp, " %-8.8s",
655: fptoa(NTOHS_FP(pp->filtdelay[i]), 5));
656: if (i == (NTP_SHIFT>>1)-1)
657: (void) fprintf(fp, "\n ");
658: }
659: (void) fprintf(fp, "\n");
660:
661: (void) fprintf(fp, "filter offset:");
662: for (i = 0; i < NTP_SHIFT; i++) {
663: NTOHL_FP(&pp->filtoffset[i], &tempts);
664: (void) fprintf(fp, " %-8.8s", lfptoa(&tempts, 6));
665: if (i == (NTP_SHIFT>>1)-1)
666: (void) fprintf(fp, "\n ");
667: }
668: (void) fprintf(fp, "\n");
669:
670: (void) fprintf(fp, "filter order: ");
671: for (i = 0; i < NTP_SHIFT; i++) {
672: (void) fprintf(fp, " %-8d", pp->order[i]);
673: if (i == (NTP_SHIFT>>1)-1)
674: (void) fprintf(fp, "\n ");
675: }
676: (void) fprintf(fp, "\n");
677:
678:
679: NTOHL_FP(&pp->offset, &tempts);
680: (void) fprintf(fp,
681: "offset %s, delay %s, error bound %s, filter error %s\n",
682: lfptoa(&tempts, 6), fptoa(NTOHS_FP(pp->delay), 5),
683: ufptoa(NTOHS_FP(pp->dispersion), 5),
684: ufptoa(NTOHS_FP(pp->selectdisp), 5));
685: }
686:
687:
688: /*
689: * showpeer - show detailed information for a peer
690: */
691: static void
692: showpeer(
693: struct parse *pcmd,
694: FILE *fp
695: )
696: {
697: struct info_peer *pp;
698: /* 4 is the maximum number of peers which will fit in a packet */
699: struct info_peer_list *pl, plist[min(MAXARGS, 4)];
700: int qitemlim;
701: int qitems;
702: int items;
703: int itemsize;
704: int res;
705: int sendsize;
706:
707: again:
708: if (impl_ver == IMPL_XNTPD)
709: sendsize = sizeof(struct info_peer_list);
710: else
711: sendsize = v4sizeof(struct info_peer_list);
712:
713: qitemlim = min(pcmd->nargs, COUNTOF(plist));
714: for (qitems = 0, pl = plist; qitems < qitemlim; qitems++) {
715: if (IS_IPV4(&pcmd->argval[qitems].netnum)) {
716: pl->addr = NSRCADR(&pcmd->argval[qitems].netnum);
717: if (impl_ver == IMPL_XNTPD)
718: pl->v6_flag = 0;
719: } else {
720: if (impl_ver == IMPL_XNTPD_OLD) {
721: fprintf(stderr,
722: "***Server doesn't understand IPv6 addresses\n");
723: return;
724: }
725: pl->addr6 = SOCK_ADDR6(&pcmd->argval[qitems].netnum);
726: pl->v6_flag = 1;
727: }
728: pl->port = (u_short)s_port;
729: pl->hmode = pl->flags = 0;
730: pl = (struct info_peer_list *)((char *)pl + sendsize);
731: }
732:
733: res = doquery(impl_ver, REQ_PEER_INFO, 0, qitems,
734: sendsize, (char *)plist, &items,
735: &itemsize, (void *)&pp, 0, sizeof(struct info_peer));
736:
737: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
738: impl_ver = IMPL_XNTPD_OLD;
739: goto again;
740: }
741:
742: if (res != 0)
743: return;
744:
745: if (!checkitems(items, fp))
746: return;
747:
748: if (!checkitemsize(itemsize, sizeof(struct info_peer)) &&
749: !checkitemsize(itemsize, v4sizeof(struct info_peer)))
750: return;
751:
752: while (items-- > 0) {
753: printpeer(pp, fp);
754: if (items > 0)
755: (void) fprintf(fp, "\n");
756: pp++;
757: }
758: }
759:
760:
761: /*
762: * peerstats - return statistics for a peer
763: */
764: static void
765: peerstats(
766: struct parse *pcmd,
767: FILE *fp
768: )
769: {
770: struct info_peer_stats *pp;
771: /* 4 is the maximum number of peers which will fit in a packet */
772: struct info_peer_list *pl, plist[min(MAXARGS, 4)];
773: sockaddr_u src, dst;
774: int qitemlim;
775: int qitems;
776: int items;
777: int itemsize;
778: int res;
779: int sendsize;
780:
781: again:
782: if (impl_ver == IMPL_XNTPD)
783: sendsize = sizeof(struct info_peer_list);
784: else
785: sendsize = v4sizeof(struct info_peer_list);
786:
787: memset(plist, 0, sizeof(plist));
788:
789: qitemlim = min(pcmd->nargs, COUNTOF(plist));
790: for (qitems = 0, pl = plist; qitems < qitemlim; qitems++) {
791: if (IS_IPV4(&pcmd->argval[qitems].netnum)) {
792: pl->addr = NSRCADR(&pcmd->argval[qitems].netnum);
793: if (impl_ver == IMPL_XNTPD)
794: pl->v6_flag = 0;
795: } else {
796: if (impl_ver == IMPL_XNTPD_OLD) {
797: fprintf(stderr,
798: "***Server doesn't understand IPv6 addresses\n");
799: return;
800: }
801: pl->addr6 = SOCK_ADDR6(&pcmd->argval[qitems].netnum);
802: pl->v6_flag = 1;
803: }
804: pl->port = (u_short)s_port;
805: pl->hmode = plist[qitems].flags = 0;
806: pl = (struct info_peer_list *)((char *)pl + sendsize);
807: }
808:
809: res = doquery(impl_ver, REQ_PEER_STATS, 0, qitems,
810: sendsize, (char *)plist, &items,
811: &itemsize, (void *)&pp, 0,
812: sizeof(struct info_peer_stats));
813:
814: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
815: impl_ver = IMPL_XNTPD_OLD;
816: goto again;
817: }
818:
819: if (res != 0)
820: return;
821:
822: if (!checkitems(items, fp))
823: return;
824:
825: if (!checkitemsize(itemsize, sizeof(struct info_peer_stats)) &&
826: !checkitemsize(itemsize, v4sizeof(struct info_peer_stats)))
827: return;
828:
829: while (items-- > 0) {
830: ZERO_SOCK(&dst);
831: ZERO_SOCK(&src);
832: if (pp->v6_flag != 0) {
833: AF(&dst) = AF_INET6;
834: AF(&src) = AF_INET6;
835: SOCK_ADDR6(&dst) = pp->dstadr6;
836: SOCK_ADDR6(&src) = pp->srcadr6;
837: } else {
838: AF(&dst) = AF_INET;
839: AF(&src) = AF_INET;
840: NSRCADR(&dst) = pp->dstadr;
841: NSRCADR(&src) = pp->srcadr;
842: }
843: #ifdef ISC_PLATFORM_HAVESALEN
844: src.sa.sa_len = SOCKLEN(&src);
845: dst.sa.sa_len = SOCKLEN(&dst);
846: #endif
847: fprintf(fp, "remote host: %s\n",
848: nntohost(&src));
849: fprintf(fp, "local interface: %s\n",
850: stoa(&dst));
851: fprintf(fp, "time last received: %lus\n",
852: (u_long)ntohl(pp->timereceived));
853: fprintf(fp, "time until next send: %lus\n",
854: (u_long)ntohl(pp->timetosend));
855: fprintf(fp, "reachability change: %lus\n",
856: (u_long)ntohl(pp->timereachable));
857: fprintf(fp, "packets sent: %lu\n",
858: (u_long)ntohl(pp->sent));
859: fprintf(fp, "packets received: %lu\n",
860: (u_long)ntohl(pp->processed));
861: fprintf(fp, "bad authentication: %lu\n",
862: (u_long)ntohl(pp->badauth));
863: fprintf(fp, "bogus origin: %lu\n",
864: (u_long)ntohl(pp->bogusorg));
865: fprintf(fp, "duplicate: %lu\n",
866: (u_long)ntohl(pp->oldpkt));
867: fprintf(fp, "bad dispersion: %lu\n",
868: (u_long)ntohl(pp->seldisp));
869: fprintf(fp, "bad reference time: %lu\n",
870: (u_long)ntohl(pp->selbroken));
871: fprintf(fp, "candidate order: %u\n",
872: pp->candidate);
873: if (items > 0)
874: fprintf(fp, "\n");
875: fprintf(fp, "flags: ");
876: print_pflag(fp, ntohs(pp->flags));
877: pp++;
878: }
879: }
880:
881:
882: /*
883: * loopinfo - show loop filter information
884: */
885: static void
886: loopinfo(
887: struct parse *pcmd,
888: FILE *fp
889: )
890: {
891: struct info_loop *il;
892: int items;
893: int itemsize;
894: int oneline = 0;
895: int res;
896: l_fp tempts;
897:
898: if (pcmd->nargs > 0) {
899: if (STREQ(pcmd->argval[0].string, "oneline"))
900: oneline = 1;
901: else if (STREQ(pcmd->argval[0].string, "multiline"))
902: oneline = 0;
903: else {
904: (void) fprintf(stderr, "How many lines?\n");
905: return;
906: }
907: }
908:
909: again:
910: res = doquery(impl_ver, REQ_LOOP_INFO, 0, 0, 0, (char *)NULL,
911: &items, &itemsize, (void *)&il, 0,
912: sizeof(struct info_loop));
913:
914: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
915: impl_ver = IMPL_XNTPD_OLD;
916: goto again;
917: }
918:
919: if (res != 0)
920: return;
921:
922: if (!check1item(items, fp))
923: return;
924:
925: if (!checkitemsize(itemsize, sizeof(struct info_loop)))
926: return;
927:
928: if (oneline) {
929: l_fp temp2ts;
930:
931: NTOHL_FP(&il->last_offset, &tempts);
932: NTOHL_FP(&il->drift_comp, &temp2ts);
933:
934: (void) fprintf(fp,
935: "offset %s, frequency %s, time_const %ld, watchdog %ld\n",
936: lfptoa(&tempts, 6),
937: lfptoa(&temp2ts, 3),
938: (long)(int32)ntohl((u_long)il->compliance),
939: (u_long)ntohl((u_long)il->watchdog_timer));
940: } else {
941: NTOHL_FP(&il->last_offset, &tempts);
942: (void) fprintf(fp, "offset: %s s\n",
943: lfptoa(&tempts, 6));
944: NTOHL_FP(&il->drift_comp, &tempts);
945: (void) fprintf(fp, "frequency: %s ppm\n",
946: lfptoa(&tempts, 3));
947: (void) fprintf(fp, "poll adjust: %ld\n",
948: (long)(int32)ntohl(il->compliance));
949: (void) fprintf(fp, "watchdog timer: %ld s\n",
950: (u_long)ntohl(il->watchdog_timer));
951: }
952: }
953:
954:
955: /*
956: * sysinfo - show current system state
957: */
958: /*ARGSUSED*/
959: static void
960: sysinfo(
961: struct parse *pcmd,
962: FILE *fp
963: )
964: {
965: struct info_sys *is;
966: sockaddr_u peeraddr;
967: int items;
968: int itemsize;
969: int res;
970: l_fp tempts;
971:
972: again:
973: res = doquery(impl_ver, REQ_SYS_INFO, 0, 0, 0, (char *)NULL,
974: &items, &itemsize, (void *)&is, 0,
975: sizeof(struct info_sys));
976:
977: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
978: impl_ver = IMPL_XNTPD_OLD;
979: goto again;
980: }
981:
982: if (res != 0)
983: return;
984:
985: if (!check1item(items, fp))
986: return;
987:
988: if (!checkitemsize(itemsize, sizeof(struct info_sys)) &&
989: !checkitemsize(itemsize, v4sizeof(struct info_sys)))
990: return;
991:
992: SET_ADDR(peeraddr, is->v6_flag, is->peer, is->peer6);
993:
994: (void) fprintf(fp, "system peer: %s\n", nntohost(&peeraddr));
995: (void) fprintf(fp, "system peer mode: %s\n", modetoa(is->peer_mode));
996: (void) fprintf(fp, "leap indicator: %c%c\n",
997: is->leap & 0x2 ? '1' : '0',
998: is->leap & 0x1 ? '1' : '0');
999: (void) fprintf(fp, "stratum: %d\n", (int)is->stratum);
1000: (void) fprintf(fp, "precision: %d\n", (int)is->precision);
1001: (void) fprintf(fp, "root distance: %s s\n",
1002: fptoa(NTOHS_FP(is->rootdelay), 5));
1003: (void) fprintf(fp, "root dispersion: %s s\n",
1004: ufptoa(NTOHS_FP(is->rootdispersion), 5));
1005: (void) fprintf(fp, "reference ID: [%s]\n",
1006: refid_string(is->refid, is->stratum));
1007: NTOHL_FP(&is->reftime, &tempts);
1008: (void) fprintf(fp, "reference time: %s\n", prettydate(&tempts));
1009:
1010: (void) fprintf(fp, "system flags: ");
1011: if ((is->flags & (INFO_FLAG_BCLIENT | INFO_FLAG_AUTHENABLE |
1012: INFO_FLAG_NTP | INFO_FLAG_KERNEL| INFO_FLAG_CAL |
1013: INFO_FLAG_PPS_SYNC | INFO_FLAG_MONITOR | INFO_FLAG_FILEGEN)) == 0) {
1014: (void) fprintf(fp, "none\n");
1015: } else {
1016: if (is->flags & INFO_FLAG_BCLIENT)
1017: (void) fprintf(fp, "bclient ");
1018: if (is->flags & INFO_FLAG_AUTHENTICATE)
1019: (void) fprintf(fp, "auth ");
1020: if (is->flags & INFO_FLAG_MONITOR)
1021: (void) fprintf(fp, "monitor ");
1022: if (is->flags & INFO_FLAG_NTP)
1023: (void) fprintf(fp, "ntp ");
1024: if (is->flags & INFO_FLAG_KERNEL)
1025: (void) fprintf(fp, "kernel ");
1026: if (is->flags & INFO_FLAG_FILEGEN)
1027: (void) fprintf(fp, "stats ");
1028: if (is->flags & INFO_FLAG_CAL)
1029: (void) fprintf(fp, "calibrate ");
1030: if (is->flags & INFO_FLAG_PPS_SYNC)
1031: (void) fprintf(fp, "pps ");
1032: (void) fprintf(fp, "\n");
1033: }
1034: (void) fprintf(fp, "jitter: %s s\n",
1035: fptoa(ntohl(is->frequency), 6));
1036: (void) fprintf(fp, "stability: %s ppm\n",
1037: ufptoa(ntohl(is->stability), 3));
1038: (void) fprintf(fp, "broadcastdelay: %s s\n",
1039: fptoa(NTOHS_FP(is->bdelay), 6));
1040: NTOHL_FP(&is->authdelay, &tempts);
1041: (void) fprintf(fp, "authdelay: %s s\n", lfptoa(&tempts, 6));
1042: }
1043:
1044:
1045: /*
1046: * sysstats - print system statistics
1047: */
1048: /*ARGSUSED*/
1049: static void
1050: sysstats(
1051: struct parse *pcmd,
1052: FILE *fp
1053: )
1054: {
1055: struct info_sys_stats *ss;
1056: int items;
1057: int itemsize;
1058: int res;
1059:
1060: again:
1061: res = doquery(impl_ver, REQ_SYS_STATS, 0, 0, 0, (char *)NULL,
1062: &items, &itemsize, (void *)&ss, 0,
1063: sizeof(struct info_sys_stats));
1064:
1065: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1066: impl_ver = IMPL_XNTPD_OLD;
1067: goto again;
1068: }
1069:
1070: if (res != 0)
1071: return;
1072:
1073: if (!check1item(items, fp))
1074: return;
1075:
1076: if (itemsize != sizeof(struct info_sys_stats) &&
1077: itemsize != sizeof(struct old_info_sys_stats)) {
1078: /* issue warning according to new structure size */
1079: checkitemsize(itemsize, sizeof(struct info_sys_stats));
1080: return;
1081: }
1082: fprintf(fp, "time since restart: %lu\n",
1083: (u_long)ntohl(ss->timeup));
1084: fprintf(fp, "time since reset: %lu\n",
1085: (u_long)ntohl(ss->timereset));
1086: fprintf(fp, "packets received: %lu\n",
1087: (u_long)ntohl(ss->received));
1088: fprintf(fp, "packets processed: %lu\n",
1089: (u_long)ntohl(ss->processed));
1090: fprintf(fp, "current version: %lu\n",
1091: (u_long)ntohl(ss->newversionpkt));
1092: fprintf(fp, "previous version: %lu\n",
1093: (u_long)ntohl(ss->oldversionpkt));
1094: fprintf(fp, "declined: %lu\n",
1095: (u_long)ntohl(ss->unknownversion));
1096: fprintf(fp, "access denied: %lu\n",
1097: (u_long)ntohl(ss->denied));
1098: fprintf(fp, "bad length or format: %lu\n",
1099: (u_long)ntohl(ss->badlength));
1100: fprintf(fp, "bad authentication: %lu\n",
1101: (u_long)ntohl(ss->badauth));
1102: if (itemsize != sizeof(struct info_sys_stats))
1103: return;
1104:
1105: fprintf(fp, "rate exceeded: %lu\n",
1106: (u_long)ntohl(ss->limitrejected));
1107: }
1108:
1109:
1110:
1111: /*
1112: * iostats - print I/O statistics
1113: */
1114: /*ARGSUSED*/
1115: static void
1116: iostats(
1117: struct parse *pcmd,
1118: FILE *fp
1119: )
1120: {
1121: struct info_io_stats *io;
1122: int items;
1123: int itemsize;
1124: int res;
1125:
1126: again:
1127: res = doquery(impl_ver, REQ_IO_STATS, 0, 0, 0, NULL, &items,
1128: &itemsize, (void *)&io, 0, sizeof(*io));
1129:
1130: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1131: impl_ver = IMPL_XNTPD_OLD;
1132: goto again;
1133: }
1134:
1135: if (res != 0)
1136: return;
1137:
1138: if (!check1item(items, fp))
1139: return;
1140:
1141: if (!checkitemsize(itemsize, sizeof(*io)))
1142: return;
1143:
1144: fprintf(fp, "time since reset: %lu\n",
1145: (u_long)ntohl(io->timereset));
1146: fprintf(fp, "receive buffers: %u\n",
1147: (u_int)ntohs(io->totalrecvbufs));
1148: fprintf(fp, "free receive buffers: %u\n",
1149: (u_int)ntohs(io->freerecvbufs));
1150: fprintf(fp, "used receive buffers: %u\n",
1151: (u_int)ntohs(io->fullrecvbufs));
1152: fprintf(fp, "low water refills: %u\n",
1153: (u_int)ntohs(io->lowwater));
1154: fprintf(fp, "dropped packets: %lu\n",
1155: (u_long)ntohl(io->dropped));
1156: fprintf(fp, "ignored packets: %lu\n",
1157: (u_long)ntohl(io->ignored));
1158: fprintf(fp, "received packets: %lu\n",
1159: (u_long)ntohl(io->received));
1160: fprintf(fp, "packets sent: %lu\n",
1161: (u_long)ntohl(io->sent));
1162: fprintf(fp, "packets not sent: %lu\n",
1163: (u_long)ntohl(io->notsent));
1164: fprintf(fp, "interrupts handled: %lu\n",
1165: (u_long)ntohl(io->interrupts));
1166: fprintf(fp, "received by int: %lu\n",
1167: (u_long)ntohl(io->int_received));
1168: }
1169:
1170:
1171: /*
1172: * memstats - print peer memory statistics
1173: */
1174: /*ARGSUSED*/
1175: static void
1176: memstats(
1177: struct parse *pcmd,
1178: FILE *fp
1179: )
1180: {
1181: struct info_mem_stats *mem;
1182: int i;
1183: int items;
1184: int itemsize;
1185: int res;
1186:
1187: again:
1188: res = doquery(impl_ver, REQ_MEM_STATS, 0, 0, 0, NULL, &items,
1189: &itemsize, (void *)&mem, 0, sizeof(*mem));
1190:
1191: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1192: impl_ver = IMPL_XNTPD_OLD;
1193: goto again;
1194: }
1195:
1196: if (res != 0)
1197: return;
1198:
1199: if (!check1item(items, fp))
1200: return;
1201:
1202: if (!checkitemsize(itemsize, sizeof(*mem)))
1203: return;
1204:
1205: fprintf(fp, "time since reset: %lu\n",
1206: (u_long)ntohl(mem->timereset));
1207: fprintf(fp, "total peer memory: %u\n",
1208: (u_int)ntohs(mem->totalpeermem));
1209: fprintf(fp, "free peer memory: %u\n",
1210: (u_int)ntohs(mem->freepeermem));
1211: fprintf(fp, "calls to findpeer: %lu\n",
1212: (u_long)ntohl(mem->findpeer_calls));
1213: fprintf(fp, "new peer allocations: %lu\n",
1214: (u_long)ntohl(mem->allocations));
1215: fprintf(fp, "peer demobilizations: %lu\n",
1216: (u_long)ntohl(mem->demobilizations));
1217:
1218: fprintf(fp, "hash table counts: ");
1219: for (i = 0; i < NTP_HASH_SIZE; i++) {
1220: fprintf(fp, "%4d", (int)mem->hashcount[i]);
1221: if ((i % 8) == 7 && i != (NTP_HASH_SIZE-1))
1222: fprintf(fp, "\n ");
1223: }
1224: fprintf(fp, "\n");
1225: }
1226:
1227:
1228:
1229: /*
1230: * timerstats - print timer statistics
1231: */
1232: /*ARGSUSED*/
1233: static void
1234: timerstats(
1235: struct parse *pcmd,
1236: FILE *fp
1237: )
1238: {
1239: struct info_timer_stats *tim;
1240: int items;
1241: int itemsize;
1242: int res;
1243:
1244: again:
1245: res = doquery(impl_ver, REQ_TIMER_STATS, 0, 0, 0, NULL, &items,
1246: &itemsize, (void *)&tim, 0, sizeof(*tim));
1247:
1248: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1249: impl_ver = IMPL_XNTPD_OLD;
1250: goto again;
1251: }
1252:
1253: if (res != 0)
1254: return;
1255:
1256: if (!check1item(items, fp))
1257: return;
1258:
1259: if (!checkitemsize(itemsize, sizeof(*tim)))
1260: return;
1261:
1262: fprintf(fp, "time since reset: %lu\n",
1263: (u_long)ntohl(tim->timereset));
1264: fprintf(fp, "alarms handled: %lu\n",
1265: (u_long)ntohl(tim->alarms));
1266: fprintf(fp, "alarm overruns: %lu\n",
1267: (u_long)ntohl(tim->overflows));
1268: fprintf(fp, "calls to transmit: %lu\n",
1269: (u_long)ntohl(tim->xmtcalls));
1270: }
1271:
1272:
1273: /*
1274: * addpeer - configure an active mode association
1275: */
1276: static void
1277: addpeer(
1278: struct parse *pcmd,
1279: FILE *fp
1280: )
1281: {
1282: doconfig(pcmd, fp, MODE_ACTIVE, 0);
1283: }
1284:
1285:
1286: /*
1287: * addserver - configure a client mode association
1288: */
1289: static void
1290: addserver(
1291: struct parse *pcmd,
1292: FILE *fp
1293: )
1294: {
1295: doconfig(pcmd, fp, MODE_CLIENT, 0);
1296: }
1297:
1298: /*
1299: * addrefclock - configure a reference clock association
1300: */
1301: static void
1302: addrefclock(
1303: struct parse *pcmd,
1304: FILE *fp
1305: )
1306: {
1307: doconfig(pcmd, fp, MODE_CLIENT, 1);
1308: }
1309:
1310: /*
1311: * broadcast - configure a broadcast mode association
1312: */
1313: static void
1314: broadcast(
1315: struct parse *pcmd,
1316: FILE *fp
1317: )
1318: {
1319: doconfig(pcmd, fp, MODE_BROADCAST, 0);
1320: }
1321:
1322:
1323: /*
1324: * config - configure a new peer association
1325: */
1326: static void
1327: doconfig(
1328: struct parse *pcmd,
1329: FILE *fp,
1330: int mode,
1331: int refc
1332: )
1333: {
1334: struct conf_peer cpeer;
1335: int items;
1336: int itemsize;
1337: char *dummy;
1338: u_long keyid;
1339: u_int version;
1340: u_char minpoll;
1341: u_char maxpoll;
1342: u_int flags;
1343: u_char cmode;
1344: int res;
1345: int sendsize;
1346: int numtyp;
1347: long val;
1348:
1349: again:
1350: keyid = 0;
1351: version = 3;
1352: flags = 0;
1353: res = FALSE;
1354: cmode = 0;
1355: minpoll = NTP_MINDPOLL;
1356: maxpoll = NTP_MAXDPOLL;
1357: numtyp = 1;
1358: if (refc)
1359: numtyp = 5;
1360:
1361: if (impl_ver == IMPL_XNTPD)
1362: sendsize = sizeof(struct conf_peer);
1363: else
1364: sendsize = v4sizeof(struct conf_peer);
1365:
1366: items = 1;
1367: while (pcmd->nargs > items) {
1368: if (STREQ(pcmd->argval[items].string, "prefer"))
1369: flags |= CONF_FLAG_PREFER;
1370: else if (STREQ(pcmd->argval[items].string, "burst"))
1371: flags |= CONF_FLAG_BURST;
1372: else if (STREQ(pcmd->argval[items].string, "iburst"))
1373: flags |= CONF_FLAG_IBURST;
1374: else if (!refc && STREQ(pcmd->argval[items].string, "keyid"))
1375: numtyp = 1;
1376: else if (!refc && STREQ(pcmd->argval[items].string, "version"))
1377: numtyp = 2;
1378: else if (STREQ(pcmd->argval[items].string, "minpoll"))
1379: numtyp = 3;
1380: else if (STREQ(pcmd->argval[items].string, "maxpoll"))
1381: numtyp = 4;
1382: else {
1383: if (!atoint(pcmd->argval[items].string, &val))
1384: numtyp = 0;
1385: switch (numtyp) {
1386: case 1:
1387: keyid = val;
1388: numtyp = 2;
1389: break;
1390:
1391: case 2:
1392: version = (u_int)val;
1393: numtyp = 0;
1394: break;
1395:
1396: case 3:
1397: minpoll = (u_char)val;
1398: numtyp = 0;
1399: break;
1400:
1401: case 4:
1402: maxpoll = (u_char)val;
1403: numtyp = 0;
1404: break;
1405:
1406: case 5:
1407: cmode = (u_char)val;
1408: numtyp = 0;
1409: break;
1410:
1411: default:
1412: fprintf(fp, "*** '%s' not understood\n",
1413: pcmd->argval[items].string);
1414: res = TRUE;
1415: numtyp = 0;
1416: }
1417: if (val < 0) {
1418: fprintf(stderr,
1419: "*** Value '%s' should be unsigned\n",
1420: pcmd->argval[items].string);
1421: res = TRUE;
1422: }
1423: }
1424: items++;
1425: }
1426: if (keyid > 0)
1427: flags |= CONF_FLAG_AUTHENABLE;
1428: if (version > NTP_VERSION || version < NTP_OLDVERSION) {
1429: fprintf(fp, "***invalid version number: %u\n",
1430: version);
1431: res = TRUE;
1432: }
1433: if (minpoll < NTP_MINPOLL || minpoll > NTP_MAXPOLL ||
1434: maxpoll < NTP_MINPOLL || maxpoll > NTP_MAXPOLL ||
1435: minpoll > maxpoll) {
1436: fprintf(fp, "***min/max-poll must be within %d..%d\n",
1437: NTP_MINPOLL, NTP_MAXPOLL);
1438: res = TRUE;
1439: }
1440:
1441: if (res)
1442: return;
1443:
1444: memset(&cpeer, 0, sizeof(cpeer));
1445:
1446: if (IS_IPV4(&pcmd->argval[0].netnum)) {
1447: cpeer.peeraddr = NSRCADR(&pcmd->argval[0].netnum);
1448: if (impl_ver == IMPL_XNTPD)
1449: cpeer.v6_flag = 0;
1450: } else {
1451: if (impl_ver == IMPL_XNTPD_OLD) {
1452: fprintf(stderr,
1453: "***Server doesn't understand IPv6 addresses\n");
1454: return;
1455: }
1456: cpeer.peeraddr6 = SOCK_ADDR6(&pcmd->argval[0].netnum);
1457: cpeer.v6_flag = 1;
1458: }
1459: cpeer.hmode = (u_char) mode;
1460: cpeer.keyid = keyid;
1461: cpeer.version = (u_char) version;
1462: cpeer.minpoll = minpoll;
1463: cpeer.maxpoll = maxpoll;
1464: cpeer.flags = (u_char)flags;
1465: cpeer.ttl = cmode;
1466:
1467: res = doquery(impl_ver, REQ_CONFIG, 1, 1,
1468: sendsize, (char *)&cpeer, &items,
1469: &itemsize, &dummy, 0, sizeof(struct conf_peer));
1470:
1471: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1472: impl_ver = IMPL_XNTPD_OLD;
1473: goto again;
1474: }
1475:
1476: if (res == INFO_ERR_FMT) {
1477: (void) fprintf(fp,
1478: "***Retrying command with old conf_peer size\n");
1479: res = doquery(impl_ver, REQ_CONFIG, 1, 1,
1480: sizeof(struct old_conf_peer), (char *)&cpeer,
1481: &items, &itemsize, &dummy, 0,
1482: sizeof(struct conf_peer));
1483: }
1484: if (res == 0)
1485: (void) fprintf(fp, "done!\n");
1486: return;
1487: }
1488:
1489:
1490: /*
1491: * unconfig - unconfigure some associations
1492: */
1493: static void
1494: unconfig(
1495: struct parse *pcmd,
1496: FILE *fp
1497: )
1498: {
1499: /* 8 is the maximum number of peers which will fit in a packet */
1500: struct conf_unpeer *pl, plist[min(MAXARGS, 8)];
1501: int qitemlim;
1502: int qitems;
1503: int items;
1504: int itemsize;
1505: char *dummy;
1506: int res;
1507: int sendsize;
1508:
1509: again:
1510: if (impl_ver == IMPL_XNTPD)
1511: sendsize = sizeof(struct conf_unpeer);
1512: else
1513: sendsize = v4sizeof(struct conf_unpeer);
1514:
1515: qitemlim = min(pcmd->nargs, COUNTOF(plist));
1516: for (qitems = 0, pl = plist; qitems < qitemlim; qitems++) {
1517: if (IS_IPV4(&pcmd->argval[0].netnum)) {
1518: pl->peeraddr = NSRCADR(&pcmd->argval[qitems].netnum);
1519: if (impl_ver == IMPL_XNTPD)
1520: pl->v6_flag = 0;
1521: } else {
1522: if (impl_ver == IMPL_XNTPD_OLD) {
1523: fprintf(stderr,
1524: "***Server doesn't understand IPv6 addresses\n");
1525: return;
1526: }
1527: pl->peeraddr6 =
1528: SOCK_ADDR6(&pcmd->argval[qitems].netnum);
1529: pl->v6_flag = 1;
1530: }
1531: pl = (struct conf_unpeer *)((char *)pl + sendsize);
1532: }
1533:
1534: res = doquery(impl_ver, REQ_UNCONFIG, 1, qitems,
1535: sendsize, (char *)plist, &items,
1536: &itemsize, &dummy, 0, sizeof(struct conf_unpeer));
1537:
1538: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1539: impl_ver = IMPL_XNTPD_OLD;
1540: goto again;
1541: }
1542:
1543: if (res == 0)
1544: (void) fprintf(fp, "done!\n");
1545: }
1546:
1547:
1548: /*
1549: * set - set some system flags
1550: */
1551: static void
1552: set(
1553: struct parse *pcmd,
1554: FILE *fp
1555: )
1556: {
1557: doset(pcmd, fp, REQ_SET_SYS_FLAG);
1558: }
1559:
1560:
1561: /*
1562: * clear - clear some system flags
1563: */
1564: static void
1565: sys_clear(
1566: struct parse *pcmd,
1567: FILE *fp
1568: )
1569: {
1570: doset(pcmd, fp, REQ_CLR_SYS_FLAG);
1571: }
1572:
1573:
1574: /*
1575: * doset - set/clear system flags
1576: */
1577: static void
1578: doset(
1579: struct parse *pcmd,
1580: FILE *fp,
1581: int req
1582: )
1583: {
1584: struct conf_sys_flags sys;
1585: int items;
1586: int itemsize;
1587: char *dummy;
1588: int res;
1589:
1590: sys.flags = 0;
1591: res = 0;
1592: for (items = 0; items < pcmd->nargs; items++) {
1593: if (STREQ(pcmd->argval[items].string, "auth"))
1594: sys.flags |= SYS_FLAG_AUTH;
1595: else if (STREQ(pcmd->argval[items].string, "bclient"))
1596: sys.flags |= SYS_FLAG_BCLIENT;
1597: else if (STREQ(pcmd->argval[items].string, "calibrate"))
1598: sys.flags |= SYS_FLAG_CAL;
1599: else if (STREQ(pcmd->argval[items].string, "kernel"))
1600: sys.flags |= SYS_FLAG_KERNEL;
1601: else if (STREQ(pcmd->argval[items].string, "monitor"))
1602: sys.flags |= SYS_FLAG_MONITOR;
1603: else if (STREQ(pcmd->argval[items].string, "ntp"))
1604: sys.flags |= SYS_FLAG_NTP;
1605: else if (STREQ(pcmd->argval[items].string, "pps"))
1606: sys.flags |= SYS_FLAG_PPS;
1607: else if (STREQ(pcmd->argval[items].string, "stats"))
1608: sys.flags |= SYS_FLAG_FILEGEN;
1609: else {
1610: (void) fprintf(fp, "Unknown flag %s\n",
1611: pcmd->argval[items].string);
1612: res = 1;
1613: }
1614: }
1615:
1616: sys.flags = htonl(sys.flags);
1617: if (res || sys.flags == 0)
1618: return;
1619:
1620: again:
1621: res = doquery(impl_ver, req, 1, 1,
1622: sizeof(struct conf_sys_flags), (char *)&sys, &items,
1623: &itemsize, &dummy, 0, sizeof(struct conf_sys_flags));
1624:
1625: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1626: impl_ver = IMPL_XNTPD_OLD;
1627: goto again;
1628: }
1629:
1630: if (res == 0)
1631: (void) fprintf(fp, "done!\n");
1632: }
1633:
1634:
1635: /*
1636: * data for printing/interrpreting the restrict flags
1637: */
1638: struct resflags {
1639: const char *str;
1640: int bit;
1641: };
1642:
1643: /* XXX: HMS: we apparently don't report set bits we do not recognize. */
1644:
1645: static struct resflags resflagsV2[] = {
1646: { "ignore", 0x001 },
1647: { "noserve", 0x002 },
1648: { "notrust", 0x004 },
1649: { "noquery", 0x008 },
1650: { "nomodify", 0x010 },
1651: { "nopeer", 0x020 },
1652: { "notrap", 0x040 },
1653: { "lptrap", 0x080 },
1654: { "limited", 0x100 },
1655: { "", 0 }
1656: };
1657:
1658: static struct resflags resflagsV3[] = {
1659: { "ignore", RES_IGNORE },
1660: { "noserve", RES_DONTSERVE },
1661: { "notrust", RES_DONTTRUST },
1662: { "noquery", RES_NOQUERY },
1663: { "nomodify", RES_NOMODIFY },
1664: { "nopeer", RES_NOPEER },
1665: { "notrap", RES_NOTRAP },
1666: { "lptrap", RES_LPTRAP },
1667: { "limited", RES_LIMITED },
1668: { "version", RES_VERSION },
1669: { "kod", RES_KOD },
1670: { "timeout", RES_TIMEOUT },
1671:
1672: { "", 0 }
1673: };
1674:
1675: static struct resflags resmflags[] = {
1676: { "ntpport", RESM_NTPONLY },
1677: { "interface", RESM_INTERFACE },
1678: { "", 0 }
1679: };
1680:
1681:
1682: /*
1683: * reslist - obtain and print the server's restrict list
1684: */
1685: /*ARGSUSED*/
1686: static void
1687: reslist(
1688: struct parse *pcmd,
1689: FILE *fp
1690: )
1691: {
1692: struct info_restrict *rl;
1693: sockaddr_u resaddr;
1694: sockaddr_u maskaddr;
1695: int items;
1696: int itemsize;
1697: int res;
1698: int skip;
1699: char *addr;
1700: char *mask;
1701: struct resflags *rf;
1702: u_int32 count;
1703: u_short flags;
1704: u_short mflags;
1705: char flagstr[300];
1706: static const char *comma = ", ";
1707:
1708: again:
1709: res = doquery(impl_ver, REQ_GET_RESTRICT, 0, 0, 0, (char *)NULL,
1710: &items, &itemsize, (void *)&rl, 0,
1711: sizeof(struct info_restrict));
1712:
1713: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1714: impl_ver = IMPL_XNTPD_OLD;
1715: goto again;
1716: }
1717:
1718: if (res != 0)
1719: return;
1720:
1721: if (!checkitems(items, fp))
1722: return;
1723:
1724: if (!checkitemsize(itemsize, sizeof(struct info_restrict)) &&
1725: !checkitemsize(itemsize, v4sizeof(struct info_restrict)))
1726: return;
1727:
1728: (void) fprintf(fp,
1729: " address mask count flags\n");
1730: (void) fprintf(fp,
1731: "=====================================================================\n");
1732:
1733: while (items > 0) {
1734: SET_ADDRS(resaddr, maskaddr, rl, addr, mask);
1735: if (rl->v6_flag != 0) {
1736: addr = nntohost(&resaddr);
1737: } else {
1738: if ((rl->mask == (u_int32)0xffffffff))
1739: addr = nntohost(&resaddr);
1740: else
1741: addr = stoa(&resaddr);
1742: }
1743: mask = stoa(&maskaddr);
1744: skip = 1;
1745: if ((pcmd->nargs == 0) ||
1746: ((pcmd->argval->ival == 6) && (rl->v6_flag != 0)) ||
1747: ((pcmd->argval->ival == 4) && (rl->v6_flag == 0)))
1748: skip = 0;
1749: count = ntohl(rl->count);
1750: flags = ntohs(rl->flags);
1751: mflags = ntohs(rl->mflags);
1752: flagstr[0] = '\0';
1753:
1754: res = 1;
1755: rf = &resmflags[0];
1756: while (rf->bit != 0) {
1757: if (mflags & rf->bit) {
1758: if (!res)
1759: (void) strcat(flagstr, comma);
1760: res = 0;
1761: (void) strcat(flagstr, rf->str);
1762: }
1763: rf++;
1764: }
1765:
1766: rf = (impl_ver == IMPL_XNTPD_OLD)
1767: ? &resflagsV2[0]
1768: : &resflagsV3[0]
1769: ;
1770: while (rf->bit != 0) {
1771: if (flags & rf->bit) {
1772: if (!res)
1773: (void) strcat(flagstr, comma);
1774: res = 0;
1775: (void) strcat(flagstr, rf->str);
1776: }
1777: rf++;
1778: }
1779:
1780: if (flagstr[0] == '\0')
1781: strcpy(flagstr, "none");
1782:
1783: if (!skip)
1784: fprintf(fp, "%-15.15s %-15.15s %9lu %s\n",
1785: addr, mask, (u_long)count, flagstr);
1786: rl++;
1787: items--;
1788: }
1789: }
1790:
1791:
1792:
1793: /*
1794: * new_restrict - create/add a set of restrictions
1795: */
1796: static void
1797: new_restrict(
1798: struct parse *pcmd,
1799: FILE *fp
1800: )
1801: {
1802: do_restrict(pcmd, fp, REQ_RESADDFLAGS);
1803: }
1804:
1805:
1806: /*
1807: * unrestrict - remove restriction flags from existing entry
1808: */
1809: static void
1810: unrestrict(
1811: struct parse *pcmd,
1812: FILE *fp
1813: )
1814: {
1815: do_restrict(pcmd, fp, REQ_RESSUBFLAGS);
1816: }
1817:
1818:
1819: /*
1820: * delrestrict - delete an existing restriction
1821: */
1822: static void
1823: delrestrict(
1824: struct parse *pcmd,
1825: FILE *fp
1826: )
1827: {
1828: do_restrict(pcmd, fp, REQ_UNRESTRICT);
1829: }
1830:
1831:
1832: /*
1833: * do_restrict - decode commandline restrictions and make the request
1834: */
1835: static void
1836: do_restrict(
1837: struct parse *pcmd,
1838: FILE *fp,
1839: int req_code
1840: )
1841: {
1842: struct conf_restrict cres;
1843: int items;
1844: int itemsize;
1845: char *dummy;
1846: u_int32 num;
1847: u_long bit;
1848: int i;
1849: int res;
1850: int err;
1851: int sendsize;
1852:
1853: /* Initialize cres */
1854: cres.addr = 0;
1855: cres.mask = 0;
1856: cres.flags = 0;
1857: cres.mflags = 0;
1858: cres.v6_flag = 0;
1859:
1860: again:
1861: if (impl_ver == IMPL_XNTPD)
1862: sendsize = sizeof(struct conf_restrict);
1863: else
1864: sendsize = v4sizeof(struct conf_restrict);
1865:
1866: if (IS_IPV4(&pcmd->argval[0].netnum)) {
1867: cres.addr = NSRCADR(&pcmd->argval[0].netnum);
1868: cres.mask = NSRCADR(&pcmd->argval[1].netnum);
1869: if (impl_ver == IMPL_XNTPD)
1870: cres.v6_flag = 0;
1871: } else {
1872: if (impl_ver == IMPL_XNTPD_OLD) {
1873: fprintf(stderr,
1874: "***Server doesn't understand IPv6 addresses\n");
1875: return;
1876: }
1877: cres.addr6 = SOCK_ADDR6(&pcmd->argval[0].netnum);
1878: cres.v6_flag = 1;
1879: }
1880: cres.flags = 0;
1881: cres.mflags = 0;
1882: err = FALSE;
1883: for (res = 2; res < pcmd->nargs; res++) {
1884: if (STREQ(pcmd->argval[res].string, "ntpport")) {
1885: cres.mflags |= RESM_NTPONLY;
1886: } else {
1887: for (i = 0; resflagsV3[i].bit != 0; i++) {
1888: if (STREQ(pcmd->argval[res].string,
1889: resflagsV3[i].str))
1890: break;
1891: }
1892: if (resflagsV3[i].bit != 0) {
1893: cres.flags |= resflagsV3[i].bit;
1894: if (req_code == REQ_UNRESTRICT) {
1895: fprintf(fp,
1896: "Flag %s inappropriate\n",
1897: resflagsV3[i].str);
1898: err = TRUE;
1899: }
1900: } else {
1901: fprintf(fp, "Unknown flag %s\n",
1902: pcmd->argval[res].string);
1903: err = TRUE;
1904: }
1905: }
1906: }
1907: cres.flags = htons(cres.flags);
1908: cres.mflags = htons(cres.mflags);
1909:
1910: /*
1911: * Make sure mask for default address is zero. Otherwise,
1912: * make sure mask bits are contiguous.
1913: */
1914: if (IS_IPV4(&pcmd->argval[0].netnum)) {
1915: if (cres.addr == 0) {
1916: cres.mask = 0;
1917: } else {
1918: num = ntohl(cres.mask);
1919: for (bit = 0x80000000; bit != 0; bit >>= 1)
1920: if ((num & bit) == 0)
1921: break;
1922: for ( ; bit != 0; bit >>= 1)
1923: if ((num & bit) != 0)
1924: break;
1925: if (bit != 0) {
1926: fprintf(fp, "Invalid mask %s\n",
1927: numtoa(cres.mask));
1928: err = TRUE;
1929: }
1930: }
1931: } else {
1932: /* XXX IPv6 sanity checking stuff */
1933: }
1934:
1935: if (err)
1936: return;
1937:
1938: res = doquery(impl_ver, req_code, 1, 1, sendsize, (char *)&cres,
1939: &items, &itemsize, &dummy, 0, sizeof(cres));
1940:
1941: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1942: impl_ver = IMPL_XNTPD_OLD;
1943: goto again;
1944: }
1945:
1946: if (res == 0)
1947: (void) fprintf(fp, "done!\n");
1948: return;
1949: }
1950:
1951:
1952: /*
1953: * monlist - obtain and print the server's monitor data
1954: */
1955: /*ARGSUSED*/
1956: static void
1957: monlist(
1958: struct parse *pcmd,
1959: FILE *fp
1960: )
1961: {
1962: char *struct_star;
1963: sockaddr_u addr;
1964: sockaddr_u dstadr;
1965: int items;
1966: int itemsize;
1967: int res;
1968: int version = -1;
1969:
1970: if (pcmd->nargs > 0) {
1971: version = pcmd->argval[0].ival;
1972: }
1973:
1974: again:
1975: res = doquery(impl_ver,
1976: (version == 1 || version == -1) ? REQ_MON_GETLIST_1 :
1977: REQ_MON_GETLIST, 0, 0, 0, (char *)NULL,
1978: &items, &itemsize, &struct_star,
1979: (version < 0) ? (1 << INFO_ERR_REQ) : 0,
1980: sizeof(struct info_monitor_1));
1981:
1982: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1983: impl_ver = IMPL_XNTPD_OLD;
1984: goto again;
1985: }
1986:
1987: if (res == INFO_ERR_REQ && version < 0)
1988: res = doquery(impl_ver, REQ_MON_GETLIST, 0, 0, 0, (char *)NULL,
1989: &items, &itemsize, &struct_star, 0,
1990: sizeof(struct info_monitor));
1991:
1992: if (res != 0)
1993: return;
1994:
1995: if (!checkitems(items, fp))
1996: return;
1997:
1998: if (itemsize == sizeof(struct info_monitor_1) ||
1999: itemsize == v4sizeof(struct info_monitor_1)) {
2000: struct info_monitor_1 *ml = (struct info_monitor_1 *) struct_star;
2001:
2002: (void) fprintf(fp,
2003: "remote address port local address count m ver rstr avgint lstint\n");
2004: (void) fprintf(fp,
2005: "===============================================================================\n");
2006: while (items > 0) {
2007: SET_ADDRS(dstadr, addr, ml, daddr, addr);
2008: if ((pcmd->nargs == 0) ||
2009: ((pcmd->argval->ival == 6) && (ml->v6_flag != 0)) ||
2010: ((pcmd->argval->ival == 4) && (ml->v6_flag == 0)))
2011: fprintf(fp,
2012: "%-22.22s %5d %-15s %8lu %1u %1u %6lx %6lu %7lu\n",
2013: nntohost(&addr),
2014: ntohs(ml->port),
2015: stoa(&dstadr),
2016: (u_long)ntohl(ml->count),
2017: ml->mode,
2018: ml->version,
2019: (u_long)ntohl(ml->restr),
2020: (u_long)ntohl(ml->lasttime),
2021: (u_long)ntohl(ml->firsttime));
2022: ml++;
2023: items--;
2024: }
2025: } else if (itemsize == sizeof(struct info_monitor) ||
2026: itemsize == v4sizeof(struct info_monitor)) {
2027: struct info_monitor *ml = (struct info_monitor *) struct_star;
2028:
2029: (void) fprintf(fp,
2030: " address port count mode ver rstr avgint lstint\n");
2031: (void) fprintf(fp,
2032: "===============================================================================\n");
2033: while (items > 0) {
2034: SET_ADDR(dstadr, ml->v6_flag, ml->addr, ml->addr6);
2035: if ((pcmd->nargs == 0) ||
2036: ((pcmd->argval->ival == 6) && (ml->v6_flag != 0)) ||
2037: ((pcmd->argval->ival == 4) && (ml->v6_flag == 0)))
2038: (void) fprintf(fp,
2039: "%-25.25s %5u %9lu %4u %2u %9lx %9lu %9lu\n",
2040: nntohost(&dstadr),
2041: ntohs(ml->port),
2042: (u_long)ntohl(ml->count),
2043: ml->mode,
2044: ml->version,
2045: (u_long)ntohl(ml->restr),
2046: (u_long)ntohl(ml->lasttime),
2047: (u_long)ntohl(ml->firsttime));
2048: ml++;
2049: items--;
2050: }
2051: } else if (itemsize == sizeof(struct old_info_monitor)) {
2052: struct old_info_monitor *oml = (struct old_info_monitor *)struct_star;
2053: (void) fprintf(fp,
2054: " address port count mode version lasttime firsttime\n");
2055: (void) fprintf(fp,
2056: "======================================================================\n");
2057: while (items > 0) {
2058: SET_ADDR(dstadr, oml->v6_flag, oml->addr, oml->addr6);
2059: (void) fprintf(fp, "%-20.20s %5u %9lu %4u %3u %9lu %9lu\n",
2060: nntohost(&dstadr),
2061: ntohs(oml->port),
2062: (u_long)ntohl(oml->count),
2063: oml->mode,
2064: oml->version,
2065: (u_long)ntohl(oml->lasttime),
2066: (u_long)ntohl(oml->firsttime));
2067: oml++;
2068: items--;
2069: }
2070: } else {
2071: /* issue warning according to new info_monitor size */
2072: checkitemsize(itemsize, sizeof(struct info_monitor));
2073: }
2074: }
2075:
2076:
2077: /*
2078: * Mapping between command line strings and stat reset flags
2079: */
2080: struct statreset {
2081: const char *str;
2082: int flag;
2083: } sreset[] = {
2084: { "io", RESET_FLAG_IO },
2085: { "sys", RESET_FLAG_SYS },
2086: { "mem", RESET_FLAG_MEM },
2087: { "timer", RESET_FLAG_TIMER },
2088: { "auth", RESET_FLAG_AUTH },
2089: { "allpeers", RESET_FLAG_ALLPEERS },
2090: { "", 0 }
2091: };
2092:
2093: /*
2094: * reset - reset statistic counters
2095: */
2096: static void
2097: reset(
2098: struct parse *pcmd,
2099: FILE *fp
2100: )
2101: {
2102: struct reset_flags rflags;
2103: int items;
2104: int itemsize;
2105: char *dummy;
2106: int i;
2107: int res;
2108: int err;
2109:
2110: err = 0;
2111: rflags.flags = 0;
2112: for (res = 0; res < pcmd->nargs; res++) {
2113: for (i = 0; sreset[i].flag != 0; i++) {
2114: if (STREQ(pcmd->argval[res].string, sreset[i].str))
2115: break;
2116: }
2117: if (sreset[i].flag == 0) {
2118: (void) fprintf(fp, "Flag %s unknown\n",
2119: pcmd->argval[res].string);
2120: err++;
2121: } else {
2122: rflags.flags |= sreset[i].flag;
2123: }
2124: }
2125: rflags.flags = htonl(rflags.flags);
2126:
2127: if (err) {
2128: (void) fprintf(fp, "Not done due to errors\n");
2129: return;
2130: }
2131:
2132: again:
2133: res = doquery(impl_ver, REQ_RESET_STATS, 1, 1,
2134: sizeof(struct reset_flags), (char *)&rflags, &items,
2135: &itemsize, &dummy, 0, sizeof(struct reset_flags));
2136:
2137: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2138: impl_ver = IMPL_XNTPD_OLD;
2139: goto again;
2140: }
2141:
2142: if (res == 0)
2143: (void) fprintf(fp, "done!\n");
2144: return;
2145: }
2146:
2147:
2148:
2149: /*
2150: * preset - reset stat counters for particular peers
2151: */
2152: static void
2153: preset(
2154: struct parse *pcmd,
2155: FILE *fp
2156: )
2157: {
2158: /* 8 is the maximum number of peers which will fit in a packet */
2159: struct conf_unpeer *pl, plist[min(MAXARGS, 8)];
2160: int qitemlim;
2161: int qitems;
2162: int items;
2163: int itemsize;
2164: char *dummy;
2165: int res;
2166: int sendsize;
2167:
2168: again:
2169: if (impl_ver == IMPL_XNTPD)
2170: sendsize = sizeof(struct conf_unpeer);
2171: else
2172: sendsize = v4sizeof(struct conf_unpeer);
2173:
2174: qitemlim = min(pcmd->nargs, COUNTOF(plist));
2175: for (qitems = 0, pl = plist; qitems < qitemlim; qitems++) {
2176: if (IS_IPV4(&pcmd->argval[qitems].netnum)) {
2177: pl->peeraddr = NSRCADR(&pcmd->argval[qitems].netnum);
2178: if (impl_ver == IMPL_XNTPD)
2179: pl->v6_flag = 0;
2180: } else {
2181: if (impl_ver == IMPL_XNTPD_OLD) {
2182: fprintf(stderr,
2183: "***Server doesn't understand IPv6 addresses\n");
2184: return;
2185: }
2186: pl->peeraddr6 =
2187: SOCK_ADDR6(&pcmd->argval[qitems].netnum);
2188: pl->v6_flag = 1;
2189: }
2190: pl = (struct conf_unpeer *)((char *)pl + sendsize);
2191: }
2192:
2193: res = doquery(impl_ver, REQ_RESET_PEER, 1, qitems,
2194: sendsize, (char *)plist, &items,
2195: &itemsize, &dummy, 0, sizeof(struct conf_unpeer));
2196:
2197: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2198: impl_ver = IMPL_XNTPD_OLD;
2199: goto again;
2200: }
2201:
2202: if (res == 0)
2203: (void) fprintf(fp, "done!\n");
2204: }
2205:
2206:
2207: /*
2208: * readkeys - request the server to reread the keys file
2209: */
2210: /*ARGSUSED*/
2211: static void
2212: readkeys(
2213: struct parse *pcmd,
2214: FILE *fp
2215: )
2216: {
2217: int items;
2218: int itemsize;
2219: char *dummy;
2220: int res;
2221:
2222: again:
2223: res = doquery(impl_ver, REQ_REREAD_KEYS, 1, 0, 0, (char *)0,
2224: &items, &itemsize, &dummy, 0, sizeof(dummy));
2225:
2226: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2227: impl_ver = IMPL_XNTPD_OLD;
2228: goto again;
2229: }
2230:
2231: if (res == 0)
2232: (void) fprintf(fp, "done!\n");
2233: return;
2234: }
2235:
2236:
2237: /*
2238: * trustkey - add some keys to the trusted key list
2239: */
2240: static void
2241: trustkey(
2242: struct parse *pcmd,
2243: FILE *fp
2244: )
2245: {
2246: do_trustkey(pcmd, fp, REQ_TRUSTKEY);
2247: }
2248:
2249:
2250: /*
2251: * untrustkey - remove some keys from the trusted key list
2252: */
2253: static void
2254: untrustkey(
2255: struct parse *pcmd,
2256: FILE *fp
2257: )
2258: {
2259: do_trustkey(pcmd, fp, REQ_UNTRUSTKEY);
2260: }
2261:
2262:
2263: /*
2264: * do_trustkey - do grunge work of adding/deleting keys
2265: */
2266: static void
2267: do_trustkey(
2268: struct parse *pcmd,
2269: FILE *fp,
2270: int req
2271: )
2272: {
2273: u_long keyids[MAXARGS];
2274: int i;
2275: int items;
2276: int itemsize;
2277: char *dummy;
2278: int ritems;
2279: int res;
2280:
2281: ritems = 0;
2282: for (i = 0; i < pcmd->nargs; i++) {
2283: keyids[ritems++] = pcmd->argval[i].uval;
2284: }
2285:
2286: again:
2287: res = doquery(impl_ver, req, 1, ritems, sizeof(u_long),
2288: (char *)keyids, &items, &itemsize, &dummy, 0,
2289: sizeof(dummy));
2290:
2291: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2292: impl_ver = IMPL_XNTPD_OLD;
2293: goto again;
2294: }
2295:
2296: if (res == 0)
2297: (void) fprintf(fp, "done!\n");
2298: return;
2299: }
2300:
2301:
2302:
2303: /*
2304: * authinfo - obtain and print info about authentication
2305: */
2306: /*ARGSUSED*/
2307: static void
2308: authinfo(
2309: struct parse *pcmd,
2310: FILE *fp
2311: )
2312: {
2313: struct info_auth *ia;
2314: int items;
2315: int itemsize;
2316: int res;
2317:
2318: again:
2319: res = doquery(impl_ver, REQ_AUTHINFO, 0, 0, 0, NULL, &items,
2320: &itemsize, (void *)&ia, 0, sizeof(*ia));
2321:
2322: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2323: impl_ver = IMPL_XNTPD_OLD;
2324: goto again;
2325: }
2326:
2327: if (res != 0)
2328: return;
2329:
2330: if (!check1item(items, fp))
2331: return;
2332:
2333: if (!checkitemsize(itemsize, sizeof(*ia)))
2334: return;
2335:
2336: fprintf(fp, "time since reset: %lu\n",
2337: (u_long)ntohl(ia->timereset));
2338: fprintf(fp, "stored keys: %lu\n",
2339: (u_long)ntohl(ia->numkeys));
2340: fprintf(fp, "free keys: %lu\n",
2341: (u_long)ntohl(ia->numfreekeys));
2342: fprintf(fp, "key lookups: %lu\n",
2343: (u_long)ntohl(ia->keylookups));
2344: fprintf(fp, "keys not found: %lu\n",
2345: (u_long)ntohl(ia->keynotfound));
2346: fprintf(fp, "uncached keys: %lu\n",
2347: (u_long)ntohl(ia->keyuncached));
2348: fprintf(fp, "encryptions: %lu\n",
2349: (u_long)ntohl(ia->encryptions));
2350: fprintf(fp, "decryptions: %lu\n",
2351: (u_long)ntohl(ia->decryptions));
2352: fprintf(fp, "expired keys: %lu\n",
2353: (u_long)ntohl(ia->expired));
2354: }
2355:
2356:
2357:
2358: /*
2359: * traps - obtain and print a list of traps
2360: */
2361: /*ARGSUSED*/
2362: static void
2363: traps(
2364: struct parse *pcmd,
2365: FILE *fp
2366: )
2367: {
2368: int i;
2369: struct info_trap *it;
2370: sockaddr_u trap_addr, local_addr;
2371: int items;
2372: int itemsize;
2373: int res;
2374:
2375: again:
2376: res = doquery(impl_ver, REQ_TRAPS, 0, 0, 0, (char *)NULL,
2377: &items, &itemsize, (void *)&it, 0,
2378: sizeof(struct info_trap));
2379:
2380: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2381: impl_ver = IMPL_XNTPD_OLD;
2382: goto again;
2383: }
2384:
2385: if (res != 0)
2386: return;
2387:
2388: if (!checkitems(items, fp))
2389: return;
2390:
2391: if (!checkitemsize(itemsize, sizeof(struct info_trap)) &&
2392: !checkitemsize(itemsize, v4sizeof(struct info_trap)))
2393: return;
2394:
2395: for (i = 0; i < items; i++ ) {
2396: if (i != 0)
2397: (void) fprintf(fp, "\n");
2398: SET_ADDRS(trap_addr, local_addr, it, trap_address, local_address);
2399: (void) fprintf(fp, "address %s, port %d\n",
2400: stoa(&trap_addr),
2401: ntohs(it->trap_port));
2402: (void) fprintf(fp, "interface: %s, ",
2403: (it->local_address == 0)
2404: ? "wildcard"
2405: : stoa(&local_addr));
2406: if (ntohl(it->flags) & TRAP_CONFIGURED)
2407: (void) fprintf(fp, "configured\n");
2408: else if (ntohl(it->flags) & TRAP_NONPRIO)
2409: (void) fprintf(fp, "low priority\n");
2410: else
2411: (void) fprintf(fp, "normal priority\n");
2412:
2413: (void) fprintf(fp, "set for %ld secs, last set %ld secs ago\n",
2414: (long)ntohl(it->origtime),
2415: (long)ntohl(it->settime));
2416: (void) fprintf(fp, "sequence %d, number of resets %ld\n",
2417: ntohs(it->sequence),
2418: (long)ntohl(it->resets));
2419: }
2420: }
2421:
2422:
2423: /*
2424: * addtrap - configure a trap
2425: */
2426: static void
2427: addtrap(
2428: struct parse *pcmd,
2429: FILE *fp
2430: )
2431: {
2432: do_addclr_trap(pcmd, fp, REQ_ADD_TRAP);
2433: }
2434:
2435:
2436: /*
2437: * clrtrap - clear a trap from the server
2438: */
2439: static void
2440: clrtrap(
2441: struct parse *pcmd,
2442: FILE *fp
2443: )
2444: {
2445: do_addclr_trap(pcmd, fp, REQ_CLR_TRAP);
2446: }
2447:
2448:
2449: /*
2450: * do_addclr_trap - do grunge work of adding/deleting traps
2451: */
2452: static void
2453: do_addclr_trap(
2454: struct parse *pcmd,
2455: FILE *fp,
2456: int req
2457: )
2458: {
2459: struct conf_trap ctrap;
2460: int items;
2461: int itemsize;
2462: char *dummy;
2463: int res;
2464: int sendsize;
2465:
2466: again:
2467: if (impl_ver == IMPL_XNTPD)
2468: sendsize = sizeof(struct conf_trap);
2469: else
2470: sendsize = v4sizeof(struct conf_trap);
2471:
2472: if (IS_IPV4(&pcmd->argval[0].netnum)) {
2473: ctrap.trap_address = NSRCADR(&pcmd->argval[0].netnum);
2474: if (impl_ver == IMPL_XNTPD)
2475: ctrap.v6_flag = 0;
2476: } else {
2477: if (impl_ver == IMPL_XNTPD_OLD) {
2478: fprintf(stderr,
2479: "***Server doesn't understand IPv6 addresses\n");
2480: return;
2481: }
2482: ctrap.trap_address6 = SOCK_ADDR6(&pcmd->argval[0].netnum);
2483: ctrap.v6_flag = 1;
2484: }
2485: ctrap.local_address = 0;
2486: ctrap.trap_port = htons(TRAPPORT);
2487: ctrap.unused = 0;
2488:
2489: if (pcmd->nargs > 1) {
2490: ctrap.trap_port = htons((u_short)pcmd->argval[1].uval);
2491: if (pcmd->nargs > 2) {
2492: if (AF(&pcmd->argval[2].netnum) !=
2493: AF(&pcmd->argval[0].netnum)) {
2494: fprintf(stderr,
2495: "***Cannot mix IPv4 and IPv6 addresses\n");
2496: return;
2497: }
2498: if (IS_IPV4(&pcmd->argval[2].netnum))
2499: ctrap.local_address = NSRCADR(&pcmd->argval[2].netnum);
2500: else
2501: ctrap.local_address6 = SOCK_ADDR6(&pcmd->argval[2].netnum);
2502: }
2503: }
2504:
2505: res = doquery(impl_ver, req, 1, 1, sendsize,
2506: (char *)&ctrap, &items, &itemsize, &dummy, 0,
2507: sizeof(struct conf_trap));
2508:
2509: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2510: impl_ver = IMPL_XNTPD_OLD;
2511: goto again;
2512: }
2513:
2514: if (res == 0)
2515: (void) fprintf(fp, "done!\n");
2516: return;
2517: }
2518:
2519:
2520:
2521: /*
2522: * requestkey - change the server's request key (a dangerous request)
2523: */
2524: static void
2525: requestkey(
2526: struct parse *pcmd,
2527: FILE *fp
2528: )
2529: {
2530: do_changekey(pcmd, fp, REQ_REQUEST_KEY);
2531: }
2532:
2533:
2534: /*
2535: * controlkey - change the server's control key
2536: */
2537: static void
2538: controlkey(
2539: struct parse *pcmd,
2540: FILE *fp
2541: )
2542: {
2543: do_changekey(pcmd, fp, REQ_CONTROL_KEY);
2544: }
2545:
2546:
2547:
2548: /*
2549: * do_changekey - do grunge work of changing keys
2550: */
2551: static void
2552: do_changekey(
2553: struct parse *pcmd,
2554: FILE *fp,
2555: int req
2556: )
2557: {
2558: u_long key;
2559: int items;
2560: int itemsize;
2561: char *dummy;
2562: int res;
2563:
2564:
2565: key = htonl((u_int32)pcmd->argval[0].uval);
2566:
2567: again:
2568: res = doquery(impl_ver, req, 1, 1, sizeof(u_int32),
2569: (char *)&key, &items, &itemsize, &dummy, 0,
2570: sizeof(dummy));
2571:
2572: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2573: impl_ver = IMPL_XNTPD_OLD;
2574: goto again;
2575: }
2576:
2577: if (res == 0)
2578: (void) fprintf(fp, "done!\n");
2579: return;
2580: }
2581:
2582:
2583:
2584: /*
2585: * ctlstats - obtain and print info about authentication
2586: */
2587: /*ARGSUSED*/
2588: static void
2589: ctlstats(
2590: struct parse *pcmd,
2591: FILE *fp
2592: )
2593: {
2594: struct info_control *ic;
2595: int items;
2596: int itemsize;
2597: int res;
2598:
2599: again:
2600: res = doquery(impl_ver, REQ_GET_CTLSTATS, 0, 0, 0, NULL, &items,
2601: &itemsize, (void *)&ic, 0, sizeof(*ic));
2602:
2603: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2604: impl_ver = IMPL_XNTPD_OLD;
2605: goto again;
2606: }
2607:
2608: if (res != 0)
2609: return;
2610:
2611: if (!check1item(items, fp))
2612: return;
2613:
2614: if (!checkitemsize(itemsize, sizeof(*ic)))
2615: return;
2616:
2617: fprintf(fp, "time since reset: %lu\n",
2618: (u_long)ntohl(ic->ctltimereset));
2619: fprintf(fp, "requests received: %lu\n",
2620: (u_long)ntohl(ic->numctlreq));
2621: fprintf(fp, "responses sent: %lu\n",
2622: (u_long)ntohl(ic->numctlresponses));
2623: fprintf(fp, "fragments sent: %lu\n",
2624: (u_long)ntohl(ic->numctlfrags));
2625: fprintf(fp, "async messages sent: %lu\n",
2626: (u_long)ntohl(ic->numasyncmsgs));
2627: fprintf(fp, "error msgs sent: %lu\n",
2628: (u_long)ntohl(ic->numctlerrors));
2629: fprintf(fp, "total bad pkts: %lu\n",
2630: (u_long)ntohl(ic->numctlbadpkts));
2631: fprintf(fp, "packet too short: %lu\n",
2632: (u_long)ntohl(ic->numctltooshort));
2633: fprintf(fp, "response on input: %lu\n",
2634: (u_long)ntohl(ic->numctlinputresp));
2635: fprintf(fp, "fragment on input: %lu\n",
2636: (u_long)ntohl(ic->numctlinputfrag));
2637: fprintf(fp, "error set on input: %lu\n",
2638: (u_long)ntohl(ic->numctlinputerr));
2639: fprintf(fp, "bad offset on input: %lu\n",
2640: (u_long)ntohl(ic->numctlbadoffset));
2641: fprintf(fp, "bad version packets: %lu\n",
2642: (u_long)ntohl(ic->numctlbadversion));
2643: fprintf(fp, "data in pkt too short: %lu\n",
2644: (u_long)ntohl(ic->numctldatatooshort));
2645: fprintf(fp, "unknown op codes: %lu\n",
2646: (u_long)ntohl(ic->numctlbadop));
2647: }
2648:
2649:
2650: /*
2651: * clockstat - get and print clock status information
2652: */
2653: static void
2654: clockstat(
2655: struct parse *pcmd,
2656: FILE *fp
2657: )
2658: {
2659: struct info_clock *cl;
2660: /* 8 is the maximum number of clocks which will fit in a packet */
2661: u_long clist[min(MAXARGS, 8)];
2662: int qitemlim;
2663: int qitems;
2664: int items;
2665: int itemsize;
2666: int res;
2667: l_fp ts;
2668: struct clktype *clk;
2669:
2670: qitemlim = min(pcmd->nargs, COUNTOF(clist));
2671: for (qitems = 0; qitems < qitemlim; qitems++)
2672: clist[qitems] = NSRCADR(&pcmd->argval[qitems].netnum);
2673:
2674: again:
2675: res = doquery(impl_ver, REQ_GET_CLOCKINFO, 0, qitems,
2676: sizeof(u_int32), (char *)clist, &items,
2677: &itemsize, (void *)&cl, 0, sizeof(struct info_clock));
2678:
2679: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2680: impl_ver = IMPL_XNTPD_OLD;
2681: goto again;
2682: }
2683:
2684: if (res != 0)
2685: return;
2686:
2687: if (!checkitems(items, fp))
2688: return;
2689:
2690: if (!checkitemsize(itemsize, sizeof(struct info_clock)))
2691: return;
2692:
2693: while (items-- > 0) {
2694: (void) fprintf(fp, "clock address: %s\n",
2695: numtoa(cl->clockadr));
2696: for (clk = clktypes; clk->code >= 0; clk++)
2697: if (clk->code == cl->type)
2698: break;
2699: if (clk->code >= 0)
2700: (void) fprintf(fp, "clock type: %s\n",
2701: clk->clocktype);
2702: else
2703: (void) fprintf(fp, "clock type: unknown type (%d)\n",
2704: cl->type);
2705: (void) fprintf(fp, "last event: %d\n",
2706: cl->lastevent);
2707: (void) fprintf(fp, "current status: %d\n",
2708: cl->currentstatus);
2709: (void) fprintf(fp, "number of polls: %lu\n",
2710: (u_long)ntohl(cl->polls));
2711: (void) fprintf(fp, "no response to poll: %lu\n",
2712: (u_long)ntohl(cl->noresponse));
2713: (void) fprintf(fp, "bad format responses: %lu\n",
2714: (u_long)ntohl(cl->badformat));
2715: (void) fprintf(fp, "bad data responses: %lu\n",
2716: (u_long)ntohl(cl->baddata));
2717: (void) fprintf(fp, "running time: %lu\n",
2718: (u_long)ntohl(cl->timestarted));
2719: NTOHL_FP(&cl->fudgetime1, &ts);
2720: (void) fprintf(fp, "fudge time 1: %s\n",
2721: lfptoa(&ts, 6));
2722: NTOHL_FP(&cl->fudgetime2, &ts);
2723: (void) fprintf(fp, "fudge time 2: %s\n",
2724: lfptoa(&ts, 6));
2725: (void) fprintf(fp, "stratum: %ld\n",
2726: (u_long)ntohl(cl->fudgeval1));
2727: (void) fprintf(fp, "reference ID: %s\n",
2728: refid_string(ntohl(cl->fudgeval2), 0));
2729: (void) fprintf(fp, "fudge flags: 0x%x\n",
2730: cl->flags);
2731:
2732: if (items > 0)
2733: (void) fprintf(fp, "\n");
2734: cl++;
2735: }
2736: }
2737:
2738:
2739: /*
2740: * fudge - set clock fudge factors
2741: */
2742: static void
2743: fudge(
2744: struct parse *pcmd,
2745: FILE *fp
2746: )
2747: {
2748: struct conf_fudge fudgedata;
2749: int items;
2750: int itemsize;
2751: char *dummy;
2752: l_fp ts;
2753: int res;
2754: long val;
2755: u_long u_val;
2756: int err;
2757:
2758:
2759: err = 0;
2760: memset((char *)&fudgedata, 0, sizeof fudgedata);
2761: fudgedata.clockadr = NSRCADR(&pcmd->argval[0].netnum);
2762:
2763: if (STREQ(pcmd->argval[1].string, "time1")) {
2764: fudgedata.which = htonl(FUDGE_TIME1);
2765: if (!atolfp(pcmd->argval[2].string, &ts))
2766: err = 1;
2767: else
2768: NTOHL_FP(&ts, &fudgedata.fudgetime);
2769: } else if (STREQ(pcmd->argval[1].string, "time2")) {
2770: fudgedata.which = htonl(FUDGE_TIME2);
2771: if (!atolfp(pcmd->argval[2].string, &ts))
2772: err = 1;
2773: else
2774: NTOHL_FP(&ts, &fudgedata.fudgetime);
2775: } else if (STREQ(pcmd->argval[1].string, "val1")) {
2776: fudgedata.which = htonl(FUDGE_VAL1);
2777: if (!atoint(pcmd->argval[2].string, &val))
2778: err = 1;
2779: else
2780: fudgedata.fudgeval_flags = htonl(val);
2781: } else if (STREQ(pcmd->argval[1].string, "val2")) {
2782: fudgedata.which = htonl(FUDGE_VAL2);
2783: if (!atoint(pcmd->argval[2].string, &val))
2784: err = 1;
2785: else
2786: fudgedata.fudgeval_flags = htonl((u_int32)val);
2787: } else if (STREQ(pcmd->argval[1].string, "flags")) {
2788: fudgedata.which = htonl(FUDGE_FLAGS);
2789: if (!hextoint(pcmd->argval[2].string, &u_val))
2790: err = 1;
2791: else
2792: fudgedata.fudgeval_flags = htonl((u_int32)(u_val & 0xf));
2793: } else {
2794: (void) fprintf(stderr, "What fudge is %s?\n",
2795: pcmd->argval[1].string);
2796: return;
2797: }
2798:
2799: if (err) {
2800: (void) fprintf(stderr, "Unknown fudge parameter %s\n",
2801: pcmd->argval[2].string);
2802: return;
2803: }
2804:
2805: again:
2806: res = doquery(impl_ver, REQ_SET_CLKFUDGE, 1, 1,
2807: sizeof(struct conf_fudge), (char *)&fudgedata, &items,
2808: &itemsize, &dummy, 0, sizeof(dummy));
2809:
2810: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2811: impl_ver = IMPL_XNTPD_OLD;
2812: goto again;
2813: }
2814:
2815: if (res == 0)
2816: (void) fprintf(fp, "done!\n");
2817: return;
2818: }
2819:
2820: /*
2821: * clkbug - get and print clock debugging information
2822: */
2823: static void
2824: clkbug(
2825: struct parse *pcmd,
2826: FILE *fp
2827: )
2828: {
2829: register int i;
2830: register int n;
2831: register u_int32 s;
2832: struct info_clkbug *cl;
2833: /* 8 is the maximum number of clocks which will fit in a packet */
2834: u_long clist[min(MAXARGS, 8)];
2835: u_int32 ltemp;
2836: int qitemlim;
2837: int qitems;
2838: int items;
2839: int itemsize;
2840: int res;
2841: int needsp;
2842: l_fp ts;
2843:
2844: qitemlim = min(pcmd->nargs, COUNTOF(clist));
2845: for (qitems = 0; qitems < qitemlim; qitems++)
2846: clist[qitems] = NSRCADR(&pcmd->argval[qitems].netnum);
2847:
2848: again:
2849: res = doquery(impl_ver, REQ_GET_CLKBUGINFO, 0, qitems,
2850: sizeof(u_int32), (char *)clist, &items,
2851: &itemsize, (void *)&cl, 0, sizeof(struct info_clkbug));
2852:
2853: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2854: impl_ver = IMPL_XNTPD_OLD;
2855: goto again;
2856: }
2857:
2858: if (res != 0)
2859: return;
2860:
2861: if (!checkitems(items, fp))
2862: return;
2863:
2864: if (!checkitemsize(itemsize, sizeof(struct info_clkbug)))
2865: return;
2866:
2867: while (items-- > 0) {
2868: (void) fprintf(fp, "clock address: %s\n",
2869: numtoa(cl->clockadr));
2870: n = (int)cl->nvalues;
2871: (void) fprintf(fp, "values: %d", n);
2872: s = ntohs(cl->svalues);
2873: if (n > NUMCBUGVALUES)
2874: n = NUMCBUGVALUES;
2875: for (i = 0; i < n; i++) {
2876: ltemp = ntohl(cl->values[i]);
2877: ltemp &= 0xffffffff; /* HMS: This does nothing now */
2878: if ((i & 0x3) == 0)
2879: (void) fprintf(fp, "\n");
2880: if (s & (1 << i))
2881: (void) fprintf(fp, "%12ld", (u_long)ltemp);
2882: else
2883: (void) fprintf(fp, "%12lu", (u_long)ltemp);
2884: }
2885: (void) fprintf(fp, "\n");
2886:
2887: n = (int)cl->ntimes;
2888: (void) fprintf(fp, "times: %d", n);
2889: s = ntohl(cl->stimes);
2890: if (n > NUMCBUGTIMES)
2891: n = NUMCBUGTIMES;
2892: needsp = 0;
2893: for (i = 0; i < n; i++) {
2894: if ((i & 0x1) == 0) {
2895: (void) fprintf(fp, "\n");
2896: } else {
2897: for (;needsp > 0; needsp--)
2898: putc(' ', fp);
2899: }
2900: NTOHL_FP(&cl->times[i], &ts);
2901: if (s & (1 << i)) {
2902: (void) fprintf(fp, "%17s",
2903: lfptoa(&ts, 6));
2904: needsp = 22;
2905: } else {
2906: (void) fprintf(fp, "%37s",
2907: uglydate(&ts));
2908: needsp = 2;
2909: }
2910: }
2911: (void) fprintf(fp, "\n");
2912: if (items > 0) {
2913: cl++;
2914: (void) fprintf(fp, "\n");
2915: }
2916: }
2917: }
2918:
2919:
2920: /*
2921: * kerninfo - display the kernel pll/pps variables
2922: */
2923: static void
2924: kerninfo(
2925: struct parse *pcmd,
2926: FILE *fp
2927: )
2928: {
2929: struct info_kernel *ik;
2930: int items;
2931: int itemsize;
2932: int res;
2933: unsigned status;
2934: double tscale = 1e-6;
2935:
2936: again:
2937: res = doquery(impl_ver, REQ_GET_KERNEL, 0, 0, 0, (char *)NULL,
2938: &items, &itemsize, (void *)&ik, 0,
2939: sizeof(struct info_kernel));
2940:
2941: if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2942: impl_ver = IMPL_XNTPD_OLD;
2943: goto again;
2944: }
2945:
2946: if (res != 0)
2947: return;
2948: if (!check1item(items, fp))
2949: return;
2950: if (!checkitemsize(itemsize, sizeof(struct info_kernel)))
2951: return;
2952:
2953: status = ntohs(ik->status) & 0xffff;
2954: /*
2955: * pll variables. We know more than we should about the NANO bit.
2956: */
2957: #ifdef STA_NANO
2958: if (status & STA_NANO)
2959: tscale = 1e-9;
2960: #endif
2961: (void)fprintf(fp, "pll offset: %g s\n",
2962: (int32)ntohl(ik->offset) * tscale);
2963: (void)fprintf(fp, "pll frequency: %s ppm\n",
2964: fptoa((s_fp)ntohl(ik->freq), 3));
2965: (void)fprintf(fp, "maximum error: %g s\n",
2966: (u_long)ntohl(ik->maxerror) * 1e-6);
2967: (void)fprintf(fp, "estimated error: %g s\n",
2968: (u_long)ntohl(ik->esterror) * 1e-6);
2969: (void)fprintf(fp, "status: %04x ", status);
2970: #ifdef STA_PLL
2971: if (status & STA_PLL) (void)fprintf(fp, " pll");
2972: #endif
2973: #ifdef STA_PPSFREQ
2974: if (status & STA_PPSFREQ) (void)fprintf(fp, " ppsfreq");
2975: #endif
2976: #ifdef STA_PPSTIME
2977: if (status & STA_PPSTIME) (void)fprintf(fp, " ppstime");
2978: #endif
2979: #ifdef STA_FLL
2980: if (status & STA_FLL) (void)fprintf(fp, " fll");
2981: #endif
2982: #ifdef STA_INS
2983: if (status & STA_INS) (void)fprintf(fp, " ins");
2984: #endif
2985: #ifdef STA_DEL
2986: if (status & STA_DEL) (void)fprintf(fp, " del");
2987: #endif
2988: #ifdef STA_UNSYNC
2989: if (status & STA_UNSYNC) (void)fprintf(fp, " unsync");
2990: #endif
2991: #ifdef STA_FREQHOLD
2992: if (status & STA_FREQHOLD) (void)fprintf(fp, " freqhold");
2993: #endif
2994: #ifdef STA_PPSSIGNAL
2995: if (status & STA_PPSSIGNAL) (void)fprintf(fp, " ppssignal");
2996: #endif
2997: #ifdef STA_PPSJITTER
2998: if (status & STA_PPSJITTER) (void)fprintf(fp, " ppsjitter");
2999: #endif
3000: #ifdef STA_PPSWANDER
3001: if (status & STA_PPSWANDER) (void)fprintf(fp, " ppswander");
3002: #endif
3003: #ifdef STA_PPSERROR
3004: if (status & STA_PPSERROR) (void)fprintf(fp, " ppserror");
3005: #endif
3006: #ifdef STA_CLOCKERR
3007: if (status & STA_CLOCKERR) (void)fprintf(fp, " clockerr");
3008: #endif
3009: #ifdef STA_NANO
3010: if (status & STA_NANO) (void)fprintf(fp, " nano");
3011: #endif
3012: #ifdef STA_MODE
3013: if (status & STA_MODE) (void)fprintf(fp, " mode=fll");
3014: #endif
3015: #ifdef STA_CLK
3016: if (status & STA_CLK) (void)fprintf(fp, " src=B");
3017: #endif
3018: (void)fprintf(fp, "\n");
3019: (void)fprintf(fp, "pll time constant: %ld\n",
3020: (u_long)ntohl(ik->constant));
3021: (void)fprintf(fp, "precision: %g s\n",
3022: (u_long)ntohl(ik->precision) * tscale);
3023: (void)fprintf(fp, "frequency tolerance: %s ppm\n",
3024: fptoa((s_fp)ntohl(ik->tolerance), 0));
3025:
3026: /*
3027: * For backwards compatibility (ugh), we find the pps variables
3028: * only if the shift member is nonzero.
3029: */
3030: if (!ik->shift)
3031: return;
3032:
3033: /*
3034: * pps variables
3035: */
3036: (void)fprintf(fp, "pps frequency: %s ppm\n",
3037: fptoa((s_fp)ntohl(ik->ppsfreq), 3));
3038: (void)fprintf(fp, "pps stability: %s ppm\n",
3039: fptoa((s_fp)ntohl(ik->stabil), 3));
3040: (void)fprintf(fp, "pps jitter: %g s\n",
3041: (u_long)ntohl(ik->jitter) * tscale);
3042: (void)fprintf(fp, "calibration interval: %d s\n",
3043: 1 << ntohs(ik->shift));
3044: (void)fprintf(fp, "calibration cycles: %ld\n",
3045: (u_long)ntohl(ik->calcnt));
3046: (void)fprintf(fp, "jitter exceeded: %ld\n",
3047: (u_long)ntohl(ik->jitcnt));
3048: (void)fprintf(fp, "stability exceeded: %ld\n",
3049: (u_long)ntohl(ik->stbcnt));
3050: (void)fprintf(fp, "calibration errors: %ld\n",
3051: (u_long)ntohl(ik->errcnt));
3052: }
3053:
3054: #define IF_LIST_FMT "%2d %c %48s %c %c %12.12s %03lx %3lu %2lu %5lu %5lu %5lu %2lu %3lu %7lu\n"
3055: #define IF_LIST_FMT_STR "%2s %c %48s %c %c %12.12s %3s %3s %2s %5s %5s %5s %2s %3s %7s\n"
3056: #define IF_LIST_AFMT_STR " %48s %c\n"
3057: #define IF_LIST_LABELS "#", 'A', "Address/Mask/Broadcast", 'T', 'E', "IF name", "Flg", "TL", "#M", "recv", "sent", "drop", "S", "PC", "uptime"
3058: #define IF_LIST_LINE "==================================================================================================================\n"
3059:
3060: static void
3061: iflist(
3062: FILE *fp,
3063: struct info_if_stats *ifs,
3064: int items,
3065: int itemsize,
3066: int res
3067: )
3068: {
3069: static char *actions = "?.+-";
3070: sockaddr_u saddr;
3071:
3072: if (res != 0)
3073: return;
3074:
3075: if (!checkitems(items, fp))
3076: return;
3077:
3078: if (!checkitemsize(itemsize, sizeof(struct info_if_stats)))
3079: return;
3080:
3081: fprintf(fp, IF_LIST_FMT_STR, IF_LIST_LABELS);
3082: fprintf(fp, IF_LIST_LINE);
3083:
3084: while (items > 0) {
3085: SET_ADDR(saddr, ntohl(ifs->v6_flag),
3086: ifs->unaddr.addr.s_addr, ifs->unaddr.addr6);
3087: fprintf(fp, IF_LIST_FMT,
3088: ntohl(ifs->ifnum),
3089: actions[(ifs->action >= 1 && ifs->action < 4) ? ifs->action : 0],
3090: stoa((&saddr)), 'A',
3091: ifs->ignore_packets ? 'D' : 'E',
3092: ifs->name,
3093: (u_long)ntohl(ifs->flags),
3094: (u_long)ntohl(ifs->last_ttl),
3095: (u_long)ntohl(ifs->num_mcast),
3096: (u_long)ntohl(ifs->received),
3097: (u_long)ntohl(ifs->sent),
3098: (u_long)ntohl(ifs->notsent),
3099: (u_long)ntohl(ifs->scopeid),
3100: (u_long)ntohl(ifs->peercnt),
3101: (u_long)ntohl(ifs->uptime));
3102:
3103: SET_ADDR(saddr, ntohl(ifs->v6_flag),
3104: ifs->unmask.addr.s_addr, ifs->unmask.addr6);
3105: fprintf(fp, IF_LIST_AFMT_STR, stoa(&saddr), 'M');
3106:
3107: if (!ntohl(ifs->v6_flag) && ntohl(ifs->flags) & (INT_BCASTOPEN)) {
3108: SET_ADDR(saddr, ntohl(ifs->v6_flag),
3109: ifs->unbcast.addr.s_addr, ifs->unbcast.addr6);
3110: fprintf(fp, IF_LIST_AFMT_STR, stoa(&saddr), 'B');
3111:
3112: }
3113:
3114: ifs++;
3115: items--;
3116: }
3117: }
3118:
3119: /*ARGSUSED*/
3120: static void
3121: get_if_stats(
3122: struct parse *pcmd,
3123: FILE *fp
3124: )
3125: {
3126: struct info_if_stats *ifs;
3127: int items;
3128: int itemsize;
3129: int res;
3130:
3131: res = doquery(impl_ver, REQ_IF_STATS, 1, 0, 0, (char *)NULL, &items,
3132: &itemsize, (void *)&ifs, 0,
3133: sizeof(struct info_if_stats));
3134: iflist(fp, ifs, items, itemsize, res);
3135: }
3136:
3137: /*ARGSUSED*/
3138: static void
3139: do_if_reload(
3140: struct parse *pcmd,
3141: FILE *fp
3142: )
3143: {
3144: struct info_if_stats *ifs;
3145: int items;
3146: int itemsize;
3147: int res;
3148:
3149: res = doquery(impl_ver, REQ_IF_RELOAD, 1, 0, 0, (char *)NULL, &items,
3150: &itemsize, (void *)&ifs, 0,
3151: sizeof(struct info_if_stats));
3152: iflist(fp, ifs, items, itemsize, res);
3153: }