?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Ignore machine-check MSRs
[freebsd-src/fkvm-freebsd.git] / contrib / ntp / ntpdc / ntpdc_ops.c
blobe40016b901cde8716aebde5d42640d3fd65380b8
1 /*
2 * ntpdc_ops.c - subroutines which are called to perform operations by xntpdc
3 */
4
5 #ifdef HAVE_CONFIG_H
6 # include <config.h>
7 #endif
8
9 #include <stdio.h>
10 #include <stddef.h>
11
12 #include "ntpdc.h"
13 #include "ntp_control.h"
14 #include "ntp_refclock.h"
15 #include "ntp_stdlib.h"
16
17 #include <ctype.h>
18 #ifdef HAVE_SYS_TIMEX_H
19 # include <sys/timex.h>
20 #endif
21 #if !defined(__bsdi__) && !defined(apollo)
22 #include <netinet/in.h>
23 #endif
24
25 #include <arpa/inet.h>
26
27 /*
28 * Declarations for command handlers in here
29 */
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 *));
83
84 /*
85 * Commands we understand. Ntpdc imports this.
86 */
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 },
107 { "", "", "", "" },
108 "display local server information" },
109 { "sysstats", sysstats, { NO, NO, NO, NO },
110 { "", "", "", "" },
111 "display local server statistics" },
112 { "memstats", memstats, { NO, NO, NO, NO },
113 { "", "", "", "" },
114 "display peer memory usage statistics" },
115 { "iostats", iostats, { NO, NO, NO, NO },
116 { "", "", "", "" },
117 "display I/O subsystem statistics" },
118 { "timerstats", timerstats, { NO, NO, NO, NO },
119 { "", "", "", "" },
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 },
146 { "address", "mask",
147 "ntpport|ignore|noserve|notrust|noquery|nomodify|nopeer|version|kod",
148 "..." },
149 "create restrict entry/add flags to entry" },
150 { "unrestrict", unrestrict, { NTP_ADD, NTP_ADD, NTP_STR, OPT|NTP_STR },
151 { "address", "mask",
152 "ntpport|ignore|noserve|notrust|noquery|nomodify|nopeer|version|kod",
153 "..." },
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 },
168 { "", "", "", "" },
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 },
177 { "", "", "", "" },
178 "display the state of the authentication code" },
179 { "traps", traps, { NO, NO, NO, NO },
180 { "", "", "", "" },
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 },
195 { "", "", "", "" },
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 },
207 { "", "", "", "" },
208 "display the kernel pll/pps variables" },
209 { "ifstats", get_if_stats, { NO, NO, NO, NO },
210 { "", "", "", "" },
211 "list interface statistics" },
212 { "ifreload", do_if_reload, { NO, NO, NO, NO },
213 { "", "", "", "" },
214 "reload interface configuration" },
215 { 0, 0, { NO, NO, NO, NO },
216 { "", "", "", "" }, "" }
217 };
218
219 /*
220 * For quick string comparisons
221 */
222 #define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
223
224
225 /*
226 * checkitems - utility to print a message if no items were returned
227 */
228 static int
229 checkitems(
230 int items,
231 FILE *fp
232 )
233 {
234 if (items == 0) {
235 (void) fprintf(fp, "No data returned in response to query\n");
236 return 0;
237 }
238 return 1;
239 }
240
241
242 /*
243 * checkitemsize - utility to print a message if the item size is wrong
244 */
245 static int
246 checkitemsize(
247 int itemsize,
248 int expected
249 )
250 {
251 if (itemsize != expected) {
252 (void) fprintf(stderr,
253 "***Incorrect item size returned by remote host (%d should be %d)\n",
254 itemsize, expected);
255 return 0;
256 }
257 return 1;
258 }
259
260
261 /*
262 * check1item - check to make sure we have exactly one item
263 */
264 static int
265 check1item(
266 int items,
267 FILE *fp
268 )
269 {
270 if (items == 0) {
271 (void) fprintf(fp, "No data returned in response to query\n");
272 return 0;
273 }
274 if (items > 1) {
275 (void) fprintf(fp, "Expected one item in response, got %d\n",
276 items);
277 return 0;
278 }
279 return 1;
280 }
281
282
283
284 /*
285 * peerlist - get a short list of peers
286 */
287 /*ARGSUSED*/
288 static void
289 peerlist(
290 struct parse *pcmd,
291 FILE *fp
292 )
293 {
294 struct info_peer_list *plist;
295 struct sockaddr_storage paddr;
296 int items;
297 int itemsize;
298 int res;
299
300 again:
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));
304
305 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
306 impl_ver = IMPL_XNTPD_OLD;
307 goto again;
308 }
309
310 if (res != 0)
311 return;
312
313 if (!checkitems(items, fp))
314 return;
315
316 if (!checkitemsize(itemsize, sizeof(struct info_peer_list)) &&
317 !checkitemsize(itemsize, v4sizeof(struct info_peer_list)))
318 return;
319
320 while (items > 0) {
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;
325 } else {
326 GET_INADDR(paddr) = plist->addr;
327 paddr.ss_family = AF_INET;
328 }
329 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
330 paddr.ss_len = SOCKLEN(&paddr);
331 #endif
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),
337 nntohost(&paddr));
338 plist++;
339 items--;
340 }
341 }
342
343
344 /*
345 * peers - show peer summary
346 */
347 static void
348 peers(
349 struct parse *pcmd,
350 FILE *fp
351 )
352 {
353 dopeers(pcmd, fp, 0);
354 }
355
356 /*
357 * dmpeers - show peer summary, Dave Mills style
358 */
359 static void
360 dmpeers(
361 struct parse *pcmd,
362 FILE *fp
363 )
364 {
365 dopeers(pcmd, fp, 1);
366 }
367
368
369 /*
370 * peers - show peer summary
371 */
372 /*ARGSUSED*/
373 static void
374 dopeers(
375 struct parse *pcmd,
376 FILE *fp,
377 int dmstyle
378 )
379 {
380 struct info_peer_summary *plist;
381 struct sockaddr_storage dstadr;
382 struct sockaddr_storage srcadr;
383 int items;
384 int itemsize;
385 int ntp_poll;
386 int res;
387 int c;
388 l_fp tempts;
389
390 again:
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));
394
395 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
396 impl_ver = IMPL_XNTPD_OLD;
397 goto again;
398 }
399
400 if (res != 0)
401 return;
402
403 if (!checkitems(items, fp))
404 return;
405
406 if (!checkitemsize(itemsize, sizeof(struct info_peer_summary)) &&
407 !checkitemsize(itemsize, v4sizeof(struct info_peer_summary)))
408 return;
409
410 (void) fprintf(fp,
411 " remote local st poll reach delay offset disp\n");
412 (void) fprintf(fp,
413 "=======================================================================\n");
414 while (items > 0) {
415 if (!dmstyle) {
416 if (plist->flags & INFO_FLAG_SYSPEER)
417 c = '*';
418 else if (plist->hmode == MODE_ACTIVE)
419 c = '+';
420 else if (plist->hmode == MODE_PASSIVE)
421 c = '-';
422 else if (plist->hmode == MODE_CLIENT)
423 c = '=';
424 else if (plist->hmode == MODE_BROADCAST)
425 c = '^';
426 else if (plist->hmode == MODE_BCLIENT)
427 c = '~';
428 else
429 c = ' ';
430 } else {
431 if (plist->flags & INFO_FLAG_SYSPEER)
432 c = '*';
433 else if (plist->flags & INFO_FLAG_SHORTLIST)
434 c = '+';
435 else if (plist->flags & INFO_FLAG_SEL_CANDIDATE)
436 c = '.';
437 else
438 c = ' ';
439 }
440 NTOHL_FP(&(plist->offset), &tempts);
441 ntp_poll = 1<<max(min3(plist->ppoll, plist->hpoll, NTP_MAXPOLL),
442 NTP_MINPOLL);
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;
450 } else {
451 GET_INADDR(dstadr) = plist->dstadr;
452 GET_INADDR(srcadr) = plist->srcadr;
453 srcadr.ss_family = AF_INET;
454 dstadr.ss_family = AF_INET;
455 }
456 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
457 srcadr.ss_len = SOCKLEN(&srcadr);
458 dstadr.ss_len = SOCKLEN(&dstadr);
459 #endif
460 if ((pcmd->nargs == 0) ||
461 ((pcmd->argval->ival == 6) && (plist->v6_flag != 0)) ||
462 ((pcmd->argval->ival == 4) && (plist->v6_flag == 0)))
463 (void) fprintf(fp,
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),
468 lfptoa(&tempts, 6),
469 ufptoa(NTOHS_FP(plist->dispersion), 5));
470 plist++;
471 items--;
472 }
473 }
474
475 /* Convert a refid & stratum (in host order) to a string */
476 static char*
477 refid_string(
478 u_int32 refid,
479 int stratum
480 )
481 {
482 if (stratum <= 1) {
483 static char junk[5];
484 junk[4] = 0;
485 memmove(junk, (char *)&refid, 4);
486 return junk;
487 }
488
489 return numtoa(refid);
490 }
491
492 static void
493 print_pflag(
494 FILE *fp,
495 u_int32 flags
496 )
497 {
498 const char *str;
499
500 if (flags == 0) {
501 (void) fprintf(fp, " none\n");
502 } else {
503 str = "";
504 if (flags & INFO_FLAG_SYSPEER) {
505 (void) fprintf(fp, " system_peer");
506 str = ",";
507 }
508 if (flags & INFO_FLAG_CONFIG) {
509 (void) fprintf(fp, "%s config", str);
510 str = ",";
511 }
512 if (flags & INFO_FLAG_REFCLOCK) {
513 (void) fprintf(fp, "%s refclock", str);
514 str = ",";
515 }
516 if (flags & INFO_FLAG_AUTHENABLE) {
517 (void) fprintf(fp, "%s auth", str);
518 str = ",";
519 }
520 if (flags & INFO_FLAG_BCLIENT) {
521 (void) fprintf(fp, "%s bclient", str);
522 str = ",";
523 }
524 if (flags & INFO_FLAG_PREFER) {
525 (void) fprintf(fp, "%s prefer", str);
526 str = ",";
527 }
528 if (flags & INFO_FLAG_IBURST) {
529 (void) fprintf(fp, "%s iburst", str);
530 str = ",";
531 }
532 if (flags & INFO_FLAG_BURST) {
533 (void) fprintf(fp, "%s burst", str);
534 }
535 (void) fprintf(fp, "\n");
536 }
537 }
538 /*
539 * printpeer - print detail information for a peer
540 */
541 static void
542 printpeer(
543 register struct info_peer *pp,
544 FILE *fp
545 )
546 {
547 register int i;
548 l_fp tempts;
549 struct sockaddr_storage srcadr, dstadr;
550
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;
558 } else {
559 srcadr.ss_family = AF_INET;
560 dstadr.ss_family = AF_INET;
561 GET_INADDR(srcadr) = pp->srcadr;
562 GET_INADDR(dstadr) = pp->dstadr;
563 }
564 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
565 srcadr.ss_len = SOCKLEN(&srcadr);
566 dstadr.ss_len = SOCKLEN(&dstadr);
567 #endif
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);
573
574 (void) fprintf(fp,
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));
580
581 (void) fprintf(fp,
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));
584
585 (void) fprintf(fp,
586 "reach %03o, unreach %d, flash 0x%04x, ",
587 pp->reach, pp->unreach, pp->flash2);
588
589 (void) fprintf(fp, "boffset %s, ttl/mode %d\n",
590 fptoa(NTOHS_FP(pp->estbdelay), 5), pp->ttl);
591
592 (void) fprintf(fp, "timer %lds, flags", (long)ntohl(pp->timer));
593 print_pflag(fp, pp->flags);
594
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));
607
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 ");
614 }
615 (void) fprintf(fp, "\n");
616
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 ");
623 }
624 (void) fprintf(fp, "\n");
625
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 ");
631 }
632 (void) fprintf(fp, "\n");
633
634
635 NTOHL_FP(&pp->offset, &tempts);
636 (void) fprintf(fp,
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));
641 }
642
643
644 /*
645 * showpeer - show detailed information for a peer
646 */
647 static void
648 showpeer(
649 struct parse *pcmd,
650 FILE *fp
651 )
652 {
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)];
656 int qitems;
657 int items;
658 int itemsize;
659 int res;
660 int sendsize;
661
662 again:
663 if (impl_ver == IMPL_XNTPD)
664 sendsize = sizeof(struct info_peer_list);
665 else
666 sendsize = v4sizeof(struct info_peer_list);
667
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)
672 pl->v6_flag = 0;
673 } else {
674 if (impl_ver == IMPL_XNTPD_OLD) {
675 fprintf(stderr,
676 "***Server doesn't understand IPv6 addresses\n");
677 return;
678 }
679 pl->addr6 = GET_INADDR6(pcmd->argval[qitems].netnum);
680 pl->v6_flag = 1;
681 }
682 pl->port = (u_short)s_port;
683 pl->hmode = pl->flags = 0;
684 pl = (struct info_peer_list *)((char *)pl + sendsize);
685 }
686
687 res = doquery(impl_ver, REQ_PEER_INFO, 0, qitems,
688 sendsize, (char *)plist, &items,
689 &itemsize, (void *)&pp, 0, sizeof(struct info_peer));
690
691 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
692 impl_ver = IMPL_XNTPD_OLD;
693 goto again;
694 }
695
696 if (res != 0)
697 return;
698
699 if (!checkitems(items, fp))
700 return;
701
702 if (!checkitemsize(itemsize, sizeof(struct info_peer)) &&
703 !checkitemsize(itemsize, v4sizeof(struct info_peer)))
704 return;
705
706 while (items-- > 0) {
707 printpeer(pp, fp);
708 if (items > 0)
709 (void) fprintf(fp, "\n");
710 pp++;
711 }
712 }
713
714
715 /*
716 * peerstats - return statistics for a peer
717 */
718 static void
719 peerstats(
720 struct parse *pcmd,
721 FILE *fp
722 )
723 {
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;
728 int qitems;
729 int items;
730 int itemsize;
731 int res;
732 int sendsize;
733
734 again:
735 if (impl_ver == IMPL_XNTPD)
736 sendsize = sizeof(struct info_peer_list);
737 else
738 sendsize = v4sizeof(struct info_peer_list);
739
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)
745 pl->v6_flag = 0;
746 } else {
747 if (impl_ver == IMPL_XNTPD_OLD) {
748 fprintf(stderr,
749 "***Server doesn't understand IPv6 addresses\n");
750 return;
751 }
752 pl->addr6 = GET_INADDR6(pcmd->argval[qitems].netnum);
753 pl->v6_flag = 1;
754 }
755 pl->port = (u_short)s_port;
756 pl->hmode = plist[qitems].flags = 0;
757 pl = (struct info_peer_list *)((char *)pl + sendsize);
758 }
759
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));
764
765 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
766 impl_ver = IMPL_XNTPD_OLD;
767 goto again;
768 }
769
770 if (res != 0)
771 return;
772
773 if (!checkitems(items, fp))
774 return;
775
776 if (!checkitemsize(itemsize, sizeof(struct info_peer_stats)) &&
777 !checkitemsize(itemsize, v4sizeof(struct info_peer_stats)))
778 return;
779
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;
788 } else {
789 GET_INADDR(src) = pp->srcadr;
790 GET_INADDR(dst) = pp->dstadr;
791 src.ss_family = AF_INET;
792 dst.ss_family = AF_INET;
793 }
794 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
795 src.ss_len = SOCKLEN(&src);
796 dst.ss_len = SOCKLEN(&dst);
797 #endif
798 (void) fprintf(fp, "remote host: %s\n",
799 nntohost(&src));
800 (void) fprintf(fp, "local interface: %s\n",
801 stoa(&dst));
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",
823 (int)pp->candidate);
824 if (items > 0)
825 (void) fprintf(fp, "\n");
826 (void) fprintf(fp, "flags: ");
827 print_pflag(fp, ntohs(pp->flags));
828 pp++;
829 }
830 }
831
832
833 /*
834 * loopinfo - show loop filter information
835 */
836 static void
837 loopinfo(
838 struct parse *pcmd,
839 FILE *fp
840 )
841 {
842 struct info_loop *il;
843 int items;
844 int itemsize;
845 int oneline = 0;
846 int res;
847 l_fp tempts;
848
849 if (pcmd->nargs > 0) {
850 if (STREQ(pcmd->argval[0].string, "oneline"))
851 oneline = 1;
852 else if (STREQ(pcmd->argval[0].string, "multiline"))
853 oneline = 0;
854 else {
855 (void) fprintf(stderr, "How many lines?\n");
856 return;
857 }
858 }
859
860 again:
861 res = doquery(impl_ver, REQ_LOOP_INFO, 0, 0, 0, (char *)NULL,
862 &items, &itemsize, (void *)&il, 0,
863 sizeof(struct info_loop));
864
865 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
866 impl_ver = IMPL_XNTPD_OLD;
867 goto again;
868 }
869
870 if (res != 0)
871 return;
872
873 if (!check1item(items, fp))
874 return;
875
876 if (!checkitemsize(itemsize, sizeof(struct info_loop)))
877 return;
878
879 if (oneline) {
880 l_fp temp2ts;
881
882 NTOHL_FP(&il->last_offset, &tempts);
883 NTOHL_FP(&il->drift_comp, &temp2ts);
884
885 (void) fprintf(fp,
886 "offset %s, frequency %s, time_const %ld, watchdog %ld\n",
887 lfptoa(&tempts, 6),
888 lfptoa(&temp2ts, 3),
889 (long)(int32_t)ntohl((u_long)il->compliance),
890 (u_long)ntohl((u_long)il->watchdog_timer));
891 } else {
892 NTOHL_FP(&il->last_offset, &tempts);
893 (void) fprintf(fp, "offset: %s s\n",
894 lfptoa(&tempts, 6));
895 NTOHL_FP(&il->drift_comp, &tempts);
896 (void) fprintf(fp, "frequency: %s ppm\n",
897 lfptoa(&tempts, 3));
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));
902 }
903 }
904
905
906 /*
907 * sysinfo - show current system state
908 */
909 /*ARGSUSED*/
910 static void
911 sysinfo(
912 struct parse *pcmd,
913 FILE *fp
914 )
915 {
916 struct info_sys *is;
917 struct sockaddr_storage peeraddr;
918 int items;
919 int itemsize;
920 int res;
921 l_fp tempts;
922
923 again:
924 res = doquery(impl_ver, REQ_SYS_INFO, 0, 0, 0, (char *)NULL,
925 &items, &itemsize, (void *)&is, 0,
926 sizeof(struct info_sys));
927
928 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
929 impl_ver = IMPL_XNTPD_OLD;
930 goto again;
931 }
932
933 if (res != 0)
934 return;
935
936 if (!check1item(items, fp))
937 return;
938
939 if (!checkitemsize(itemsize, sizeof(struct info_sys)) &&
940 !checkitemsize(itemsize, v4sizeof(struct info_sys)))
941 return;
942
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;
947 } else {
948 GET_INADDR(peeraddr) = is->peer;
949 peeraddr.ss_family = AF_INET;
950 }
951 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
952 peeraddr.ss_len = SOCKLEN(&peeraddr);
953 #endif
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));
969
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");
975 } else {
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");
993 }
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));
1002 }
1003
1004
1005 /*
1006 * sysstats - print system statistics
1007 */
1008 /*ARGSUSED*/
1009 static void
1010 sysstats(
1011 struct parse *pcmd,
1012 FILE *fp
1013 )
1014 {
1015 struct info_sys_stats *ss;
1016 int items;
1017 int itemsize;
1018 int res;
1019
1020 again:
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));
1024
1025 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1026 impl_ver = IMPL_XNTPD_OLD;
1027 goto again;
1028 }
1029
1030 if (res != 0)
1031 return;
1032
1033 if (!check1item(items, fp))
1034 return;
1035
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));
1040 return;
1041 }
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))
1063 return;
1064
1065 fprintf(fp, "rate exceeded: %ld\n",
1066 (u_long)ntohl(ss->limitrejected));
1067 }
1068
1069
1070
1071 /*
1072 * iostats - print I/O statistics
1073 */
1074 /*ARGSUSED*/
1075 static void
1076 iostats(
1077 struct parse *pcmd,
1078 FILE *fp
1079 )
1080 {
1081 struct info_io_stats *io;
1082 int items;
1083 int itemsize;
1084 int res;
1085
1086 again:
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));
1090
1091 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1092 impl_ver = IMPL_XNTPD_OLD;
1093 goto again;
1094 }
1095
1096 if (res != 0)
1097 return;
1098
1099 if (!check1item(items, fp))
1100 return;
1101
1102 if (!checkitemsize(itemsize, sizeof(struct info_io_stats)))
1103 return;
1104
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));
1129 }
1130
1131
1132 /*
1133 * memstats - print peer memory statistics
1134 */
1135 /*ARGSUSED*/
1136 static void
1137 memstats(
1138 struct parse *pcmd,
1139 FILE *fp
1140 )
1141 {
1142 struct info_mem_stats *mem;
1143 int i;
1144 int items;
1145 int itemsize;
1146 int res;
1147
1148 again:
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));
1152
1153 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1154 impl_ver = IMPL_XNTPD_OLD;
1155 goto again;
1156 }
1157
1158 if (res != 0)
1159 return;
1160
1161 if (!check1item(items, fp))
1162 return;
1163
1164 if (!checkitemsize(itemsize, sizeof(struct info_mem_stats)))
1165 return;
1166
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));
1179
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 ");
1185 }
1186 }
1187 (void) fprintf(fp, "\n");
1188 }
1189
1190
1191
1192 /*
1193 * timerstats - print timer statistics
1194 */
1195 /*ARGSUSED*/
1196 static void
1197 timerstats(
1198 struct parse *pcmd,
1199 FILE *fp
1200 )
1201 {
1202 struct info_timer_stats *tim;
1203 int items;
1204 int itemsize;
1205 int res;
1206
1207 again:
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));
1211
1212 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1213 impl_ver = IMPL_XNTPD_OLD;
1214 goto again;
1215 }
1216
1217 if (res != 0)
1218 return;
1219
1220 if (!check1item(items, fp))
1221 return;
1222
1223 if (!checkitemsize(itemsize, sizeof(struct info_timer_stats)))
1224 return;
1225
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));
1234 }
1235
1236
1237 /*
1238 * addpeer - configure an active mode association
1239 */
1240 static void
1241 addpeer(
1242 struct parse *pcmd,
1243 FILE *fp
1244 )
1245 {
1246 doconfig(pcmd, fp, MODE_ACTIVE, 0);
1247 }
1248
1249
1250 /*
1251 * addserver - configure a client mode association
1252 */
1253 static void
1254 addserver(
1255 struct parse *pcmd,
1256 FILE *fp
1257 )
1258 {
1259 doconfig(pcmd, fp, MODE_CLIENT, 0);
1260 }
1261
1262 /*
1263 * addrefclock - configure a reference clock association
1264 */
1265 static void
1266 addrefclock(
1267 struct parse *pcmd,
1268 FILE *fp
1269 )
1270 {
1271 doconfig(pcmd, fp, MODE_CLIENT, 1);
1272 }
1273
1274 /*
1275 * broadcast - configure a broadcast mode association
1276 */
1277 static void
1278 broadcast(
1279 struct parse *pcmd,
1280 FILE *fp
1281 )
1282 {
1283 doconfig(pcmd, fp, MODE_BROADCAST, 0);
1284 }
1285
1286
1287 /*
1288 * config - configure a new peer association
1289 */
1290 static void
1291 doconfig(
1292 struct parse *pcmd,
1293 FILE *fp,
1294 int mode,
1295 int refc
1296 )
1297 {
1298 struct conf_peer cpeer;
1299 int items;
1300 int itemsize;
1301 char *dummy;
1302 u_long keyid;
1303 u_int version;
1304 u_char minpoll;
1305 u_char maxpoll;
1306 u_int flags;
1307 u_char cmode;
1308 int res;
1309 int sendsize;
1310 int numtyp;
1311
1312 again:
1313 keyid = 0;
1314 version = 3;
1315 flags = 0;
1316 res = 0;
1317 cmode = 0;
1318 minpoll = NTP_MINDPOLL;
1319 maxpoll = NTP_MAXDPOLL;
1320 numtyp = 1;
1321 if (refc)
1322 numtyp = 5;
1323
1324 if (impl_ver == IMPL_XNTPD)
1325 sendsize = sizeof(struct conf_peer);
1326 else
1327 sendsize = v4sizeof(struct conf_peer);
1328
1329 items = 1;
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"))
1340 numtyp = 1;
1341 else if (!refc && STREQ(pcmd->argval[items].string, "version"))
1342 numtyp = 2;
1343 else if (STREQ(pcmd->argval[items].string, "minpoll"))
1344 numtyp = 3;
1345 else if (STREQ(pcmd->argval[items].string, "maxpoll"))
1346 numtyp = 4;
1347 else {
1348 long val;
1349 if (!atoint(pcmd->argval[items].string, &val))
1350 numtyp = 0;
1351 switch (numtyp) {
1352 case 1:
1353 keyid = val;
1354 numtyp = 2;
1355 break;
1356
1357 case 2:
1358 version = (u_int) val;
1359 numtyp = 0;
1360 break;
1361
1362 case 3:
1363 minpoll = (u_char)val;
1364 numtyp = 0;
1365 break;
1366
1367 case 4:
1368 maxpoll = (u_char)val;
1369 numtyp = 0;
1370 break;
1371
1372 case 5:
1373 cmode = (u_char)val;
1374 numtyp = 0;
1375 break;
1376
1377 default:
1378 (void) fprintf(fp, "*** '%s' not understood\n",
1379 pcmd->argval[items].string);
1380 res++;
1381 numtyp = 0;
1382 }
1383 if (val < 0) {
1384 (void) fprintf(stderr,
1385 "***Value '%s' should be unsigned\n",
1386 pcmd->argval[items].string);
1387 res++;
1388 }
1389 }
1390 items++;
1391 }
1392 if (keyid > 0)
1393 flags |= CONF_FLAG_AUTHENABLE;
1394 if (version > NTP_VERSION ||
1395 version < NTP_OLDVERSION) {
1396 (void)fprintf(fp, "***invalid version number: %u\n",
1397 version);
1398 res++;
1399 }
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);
1405 res++;
1406 }
1407
1408 if (res)
1409 return;
1410
1411 memset((void *)&cpeer, 0, sizeof(cpeer));
1412
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)
1416 cpeer.v6_flag = 0;
1417 } else {
1418 if (impl_ver == IMPL_XNTPD_OLD) {
1419 fprintf(stderr,
1420 "***Server doesn't understand IPv6 addresses\n");
1421 return;
1422 }
1423 cpeer.peeraddr6 = GET_INADDR6(pcmd->argval[0].netnum);
1424 cpeer.v6_flag = 1;
1425 }
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;
1432 cpeer.ttl = cmode;
1433
1434 res = doquery(impl_ver, REQ_CONFIG, 1, 1,
1435 sendsize, (char *)&cpeer, &items,
1436 &itemsize, &dummy, 0, sizeof(struct conf_peer));
1437
1438 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1439 impl_ver = IMPL_XNTPD_OLD;
1440 goto again;
1441 }
1442
1443 if (res == INFO_ERR_FMT) {
1444 (void) fprintf(fp,
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));
1450 }
1451 if (res == 0)
1452 (void) fprintf(fp, "done!\n");
1453 return;
1454 }
1455
1456
1457 /*
1458 * unconfig - unconfigure some associations
1459 */
1460 static void
1461 unconfig(
1462 struct parse *pcmd,
1463 FILE *fp
1464 )
1465 {
1466 /* 8 is the maximum number of peers which will fit in a packet */
1467 struct conf_unpeer *pl, plist[min(MAXARGS, 8)];
1468 int qitems;
1469 int items;
1470 int itemsize;
1471 char *dummy;
1472 int res;
1473 int sendsize;
1474
1475 again:
1476 if (impl_ver == IMPL_XNTPD)
1477 sendsize = sizeof(struct conf_unpeer);
1478 else
1479 sendsize = v4sizeof(struct conf_unpeer);
1480
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)
1485 pl->v6_flag = 0;
1486 } else {
1487 if (impl_ver == IMPL_XNTPD_OLD) {
1488 fprintf(stderr,
1489 "***Server doesn't understand IPv6 addresses\n");
1490 return;
1491 }
1492 pl->peeraddr6 =
1493 GET_INADDR6(pcmd->argval[qitems].netnum);
1494 pl->v6_flag = 1;
1495 }
1496 pl = (struct conf_unpeer *)((char *)pl + sendsize);
1497 }
1498
1499 res = doquery(impl_ver, REQ_UNCONFIG, 1, qitems,
1500 sendsize, (char *)plist, &items,
1501 &itemsize, &dummy, 0, sizeof(struct conf_unpeer));
1502
1503 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1504 impl_ver = IMPL_XNTPD_OLD;
1505 goto again;
1506 }
1507
1508 if (res == 0)
1509 (void) fprintf(fp, "done!\n");
1510 }
1511
1512
1513 /*
1514 * set - set some system flags
1515 */
1516 static void
1517 set(
1518 struct parse *pcmd,
1519 FILE *fp
1520 )
1521 {
1522 doset(pcmd, fp, REQ_SET_SYS_FLAG);
1523 }
1524
1525
1526 /*
1527 * clear - clear some system flags
1528 */
1529 static void
1530 sys_clear(
1531 struct parse *pcmd,
1532 FILE *fp
1533 )
1534 {
1535 doset(pcmd, fp, REQ_CLR_SYS_FLAG);
1536 }
1537
1538
1539 /*
1540 * doset - set/clear system flags
1541 */
1542 static void
1543 doset(
1544 struct parse *pcmd,
1545 FILE *fp,
1546 int req
1547 )
1548 {
1549 /* 8 is the maximum number of peers which will fit in a packet */
1550 struct conf_sys_flags sys;
1551 int items;
1552 int itemsize;
1553 char *dummy;
1554 int res;
1555
1556 sys.flags = 0;
1557 res = 0;
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;
1575 else {
1576 (void) fprintf(fp, "Unknown flag %s\n",
1577 pcmd->argval[items].string);
1578 res = 1;
1579 }
1580 }
1581
1582 sys.flags = htonl(sys.flags);
1583 if (res || sys.flags == 0)
1584 return;
1585
1586 again:
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));
1590
1591 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1592 impl_ver = IMPL_XNTPD_OLD;
1593 goto again;
1594 }
1595
1596 if (res == 0)
1597 (void) fprintf(fp, "done!\n");
1598 }
1599
1600
1601 /*
1602 * data for printing/interrpreting the restrict flags
1603 */
1604 struct resflags {
1605 const char *str;
1606 int bit;
1607 };
1608
1609 /* XXX: HMS: we apparently don't report set bits we do not recognize. */
1610
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 },
1621 { "", 0 }
1622 };
1623
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 },
1637
1638 { "", 0 }
1639 };
1640
1641 static struct resflags resmflags[] = {
1642 { "ntpport", RESM_NTPONLY },
1643 { "interface", RESM_INTERFACE },
1644 { "", 0 }
1645 };
1646
1647
1648 /*
1649 * reslist - obtain and print the server's restrict list
1650 */
1651 /*ARGSUSED*/
1652 static void
1653 reslist(
1654 struct parse *pcmd,
1655 FILE *fp
1656 )
1657 {
1658 struct info_restrict *rl;
1659 struct sockaddr_storage resaddr;
1660 struct sockaddr_storage maskaddr;
1661 int items;
1662 int itemsize;
1663 int res;
1664 int skip;
1665 char *addr;
1666 char *mask;
1667 struct resflags *rf;
1668 u_int32 count;
1669 u_short flags;
1670 u_short mflags;
1671 char flagstr[300];
1672 static const char *comma = ", ";
1673
1674 again:
1675 res = doquery(impl_ver, REQ_GET_RESTRICT, 0, 0, 0, (char *)NULL,
1676 &items, &itemsize, (void *)&rl, 0,
1677 sizeof(struct info_restrict));
1678
1679 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1680 impl_ver = IMPL_XNTPD_OLD;
1681 goto again;
1682 }
1683
1684 if (res != 0)
1685 return;
1686
1687 if (!checkitems(items, fp))
1688 return;
1689
1690 if (!checkitemsize(itemsize, sizeof(struct info_restrict)) &&
1691 !checkitemsize(itemsize, v4sizeof(struct info_restrict)))
1692 return;
1693
1694 (void) fprintf(fp,
1695 " address mask count flags\n");
1696 (void) fprintf(fp,
1697 "=====================================================================\n");
1698
1699 while (items > 0) {
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);
1709 #endif
1710 addr = nntohost(&resaddr);
1711 } else {
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);
1718 #endif
1719 if ((rl->mask == (u_int32)0xffffffff))
1720 addr = nntohost(&resaddr);
1721 else
1722 addr = stoa(&resaddr);
1723 }
1724 mask = stoa(&maskaddr);
1725 skip = 1;
1726 if ((pcmd->nargs == 0) ||
1727 ((pcmd->argval->ival == 6) && (rl->v6_flag != 0)) ||
1728 ((pcmd->argval->ival == 4) && (rl->v6_flag == 0)))
1729 skip = 0;
1730 count = ntohl(rl->count);
1731 flags = ntohs(rl->flags);
1732 mflags = ntohs(rl->mflags);
1733 flagstr[0] = '\0';
1734
1735 res = 1;
1736 rf = &resmflags[0];
1737 while (rf->bit != 0) {
1738 if (mflags & rf->bit) {
1739 if (!res)
1740 (void) strcat(flagstr, comma);
1741 res = 0;
1742 (void) strcat(flagstr, rf->str);
1743 }
1744 rf++;
1745 }
1746
1747 rf = (impl_ver == IMPL_XNTPD_OLD)
1748 ? &resflagsV2[0]
1749 : &resflagsV3[0]
1750 ;
1751 while (rf->bit != 0) {
1752 if (flags & rf->bit) {
1753 if (!res)
1754 (void) strcat(flagstr, comma);
1755 res = 0;
1756 (void) strcat(flagstr, rf->str);
1757 }
1758 rf++;
1759 }
1760
1761 if (flagstr[0] == '\0')
1762 (void) strcpy(flagstr, "none");
1763
1764 if (!skip)
1765 (void) fprintf(fp, "%-15.15s %-15.15s %9ld %s\n",
1766 addr, mask, (u_long)count, flagstr);
1767 rl++;
1768 items--;
1769 }
1770 }
1771
1772
1773
1774 /*
1775 * new_restrict - create/add a set of restrictions
1776 */
1777 static void
1778 new_restrict(
1779 struct parse *pcmd,
1780 FILE *fp
1781 )
1782 {
1783 do_restrict(pcmd, fp, REQ_RESADDFLAGS);
1784 }
1785
1786
1787 /*
1788 * unrestrict - remove restriction flags from existing entry
1789 */
1790 static void
1791 unrestrict(
1792 struct parse *pcmd,
1793 FILE *fp
1794 )
1795 {
1796 do_restrict(pcmd, fp, REQ_RESSUBFLAGS);
1797 }
1798
1799
1800 /*
1801 * delrestrict - delete an existing restriction
1802 */
1803 static void
1804 delrestrict(
1805 struct parse *pcmd,
1806 FILE *fp
1807 )
1808 {
1809 do_restrict(pcmd, fp, REQ_UNRESTRICT);
1810 }
1811
1812
1813 /*
1814 * do_restrict - decode commandline restrictions and make the request
1815 */
1816 static void
1817 do_restrict(
1818 struct parse *pcmd,
1819 FILE *fp,
1820 int req_code
1821 )
1822 {
1823 struct conf_restrict cres;
1824 int items;
1825 int itemsize;
1826 char *dummy;
1827 u_int32 num;
1828 u_long bit;
1829 int i;
1830 int res;
1831 int err;
1832 int sendsize;
1833
1834 /* Initialize cres */
1835 cres.addr = 0;
1836 cres.mask = 0;
1837 cres.flags = 0;
1838 cres.mflags = 0;
1839 cres.v6_flag = 0;
1840
1841 again:
1842 if (impl_ver == IMPL_XNTPD)
1843 sendsize = sizeof(struct conf_restrict);
1844 else
1845 sendsize = v4sizeof(struct conf_restrict);
1846
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)
1851 cres.v6_flag = 0;
1852 } else {
1853 if (impl_ver == IMPL_XNTPD_OLD) {
1854 fprintf(stderr,
1855 "***Server doesn't understand IPv6 addresses\n");
1856 return;
1857 }
1858 cres.addr6 = GET_INADDR6(pcmd->argval[0].netnum);
1859 cres.v6_flag = 1;
1860 }
1861 cres.flags = 0;
1862 cres.mflags = 0;
1863 err = 0;
1864 for (res = 2; res < pcmd->nargs; res++) {
1865 if (STREQ(pcmd->argval[res].string, "ntpport")) {
1866 cres.mflags |= RESM_NTPONLY;
1867 } else {
1868 for (i = 0; resflagsV3[i].bit != 0; i++) {
1869 if (STREQ(pcmd->argval[res].string,
1870 resflagsV3[i].str))
1871 break;
1872 }
1873 if (resflagsV3[i].bit != 0) {
1874 cres.flags |= resflagsV3[i].bit;
1875 if (req_code == REQ_UNRESTRICT) {
1876 (void) fprintf(fp,
1877 "Flag %s inappropriate\n",
1878 resflagsV3[i].str);
1879 err++;
1880 }
1881 } else {
1882 (void) fprintf(fp, "Unknown flag %s\n",
1883 pcmd->argval[res].string);
1884 err++;
1885 }
1886 }
1887 }
1888 cres.flags = htons(cres.flags);
1889 cres.mflags = htons(cres.mflags);
1890
1891 /*
1892 * Make sure mask for default address is zero. Otherwise,
1893 * make sure mask bits are contiguous.
1894 */
1895 if (pcmd->argval[0].netnum.ss_family == AF_INET) {
1896 if (cres.addr == 0) {
1897 cres.mask = 0;
1898 } else {
1899 num = ntohl(cres.mask);
1900 for (bit = 0x80000000; bit != 0; bit >>= 1)
1901 if ((num & bit) == 0)
1902 break;
1903 for ( ; bit != 0; bit >>= 1)
1904 if ((num & bit) != 0)
1905 break;
1906 if (bit != 0) {
1907 (void) fprintf(fp, "Invalid mask %s\n",
1908 numtoa(cres.mask));
1909 err++;
1910 }
1911 }
1912 } else {
1913 /* XXX IPv6 sanity checking stuff */
1914 }
1915
1916 if (err)
1917 return;
1918
1919 res = doquery(impl_ver, req_code, 1, 1,
1920 sendsize, (char *)&cres, &items,
1921 &itemsize, &dummy, 0, sizeof(struct conf_restrict));
1922
1923 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1924 impl_ver = IMPL_XNTPD_OLD;
1925 goto again;
1926 }
1927
1928 if (res == 0)
1929 (void) fprintf(fp, "done!\n");
1930 return;
1931 }
1932
1933
1934 /*
1935 * monlist - obtain and print the server's monitor data
1936 */
1937 /*ARGSUSED*/
1938 static void
1939 monlist(
1940 struct parse *pcmd,
1941 FILE *fp
1942 )
1943 {
1944 char *struct_star;
1945 struct sockaddr_storage addr;
1946 struct sockaddr_storage dstadr;
1947 int items;
1948 int itemsize;
1949 int res;
1950 int version = -1;
1951
1952 if (pcmd->nargs > 0) {
1953 version = pcmd->argval[0].ival;
1954 }
1955
1956 again:
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));
1963
1964 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
1965 impl_ver = IMPL_XNTPD_OLD;
1966 goto again;
1967 }
1968
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));
1973
1974 if (res != 0)
1975 return;
1976
1977 if (!checkitems(items, fp))
1978 return;
1979
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;
1983
1984 (void) fprintf(fp,
1985 "remote address port local address count m ver code avgint lstint\n");
1986 (void) fprintf(fp,
1987 "===============================================================================\n");
1988 while (items > 0) {
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;
1996 } else {
1997 GET_INADDR(addr) = ml->addr;
1998 addr.ss_family = AF_INET;
1999 GET_INADDR(dstadr) = ml->daddr;
2000 dstadr.ss_family = AF_INET;
2001 }
2002 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2003 addr.ss_len = SOCKLEN(&addr);
2004 dstadr.ss_len = SOCKLEN(&dstadr);
2005 #endif
2006 if ((pcmd->nargs == 0) ||
2007 ((pcmd->argval->ival == 6) && (ml->v6_flag != 0)) ||
2008 ((pcmd->argval->ival == 4) && (ml->v6_flag == 0)))
2009 (void) fprintf(fp,
2010 "%-22.22s %5d %-15s %8ld %1d %1d %6lx %6lu %7lu\n",
2011 nntohost(&addr),
2012 ntohs(ml->port),
2013 stoa(&dstadr),
2014 (u_long)ntohl(ml->count),
2015 ml->mode,
2016 ml->version,
2017 (u_long)ntohl(ml->lastdrop),
2018 (u_long)ntohl(ml->lasttime),
2019 (u_long)ntohl(ml->firsttime));
2020 ml++;
2021 items--;
2022 }
2023 } else if (itemsize == sizeof(struct info_monitor) ||
2024 itemsize == v4sizeof(struct info_monitor)) {
2025 struct info_monitor *ml = (struct info_monitor *) struct_star;
2026
2027 (void) fprintf(fp,
2028 " address port count mode ver code avgint lstint\n");
2029 (void) fprintf(fp,
2030 "===============================================================================\n");
2031 while (items > 0) {
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;
2036 } else {
2037 GET_INADDR(dstadr) = ml->addr;
2038 dstadr.ss_family = AF_INET;
2039 }
2040 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2041 dstadr.ss_len = SOCKLEN(&dstadr);
2042 #endif
2043 if ((pcmd->nargs == 0) ||
2044 ((pcmd->argval->ival == 6) && (ml->v6_flag != 0)) ||
2045 ((pcmd->argval->ival == 4) && (ml->v6_flag == 0)))
2046 (void) fprintf(fp,
2047 "%-25.25s %5d %9ld %4d %2d %9lx %9lu %9lu\n",
2048 nntohost(&dstadr),
2049 ntohs(ml->port),
2050 (u_long)ntohl(ml->count),
2051 ml->mode,
2052 ml->version,
2053 (u_long)ntohl(ml->lastdrop),
2054 (u_long)ntohl(ml->lasttime),
2055 (u_long)ntohl(ml->firsttime));
2056 ml++;
2057 items--;
2058 }
2059 } else if (itemsize == sizeof(struct old_info_monitor)) {
2060 struct old_info_monitor *oml = (struct old_info_monitor *)struct_star;
2061 (void) fprintf(fp,
2062 " address port count mode version lasttime firsttime\n");
2063 (void) fprintf(fp,
2064 "======================================================================\n");
2065 while (items > 0) {
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;
2070 } else {
2071 GET_INADDR(dstadr) = oml->addr;
2072 dstadr.ss_family = AF_INET;
2073 }
2074 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2075 dstadr.ss_len = SOCKLEN(&dstadr);
2076 #endif
2077 (void) fprintf(fp, "%-20.20s %5d %9ld %4d %3d %9lu %9lu\n",
2078 nntohost(&dstadr),
2079 ntohs(oml->port),
2080 (u_long)ntohl(oml->count),
2081 oml->mode,
2082 oml->version,
2083 (u_long)ntohl(oml->lasttime),
2084 (u_long)ntohl(oml->firsttime));
2085 oml++;
2086 items--;
2087 }
2088 } else {
2089 /* issue warning according to new info_monitor size */
2090 checkitemsize(itemsize, sizeof(struct info_monitor));
2091 }
2092 }
2093
2094
2095 /*
2096 * Mapping between command line strings and stat reset flags
2097 */
2098 struct statreset {
2099 const char *str;
2100 int flag;
2101 } sreset[] = {
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 },
2108 { "", 0 }
2109 };
2110
2111 /*
2112 * reset - reset statistic counters
2113 */
2114 static void
2115 reset(
2116 struct parse *pcmd,
2117 FILE *fp
2118 )
2119 {
2120 struct reset_flags rflags;
2121 int items;
2122 int itemsize;
2123 char *dummy;
2124 int i;
2125 int res;
2126 int err;
2127
2128 err = 0;
2129 rflags.flags = 0;
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))
2133 break;
2134 }
2135 if (sreset[i].flag == 0) {
2136 (void) fprintf(fp, "Flag %s unknown\n",
2137 pcmd->argval[res].string);
2138 err++;
2139 } else {
2140 rflags.flags |= sreset[i].flag;
2141 }
2142 }
2143 rflags.flags = htonl(rflags.flags);
2144
2145 if (err) {
2146 (void) fprintf(fp, "Not done due to errors\n");
2147 return;
2148 }
2149
2150 again:
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));
2154
2155 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2156 impl_ver = IMPL_XNTPD_OLD;
2157 goto again;
2158 }
2159
2160 if (res == 0)
2161 (void) fprintf(fp, "done!\n");
2162 return;
2163 }
2164
2165
2166
2167 /*
2168 * preset - reset stat counters for particular peers
2169 */
2170 static void
2171 preset(
2172 struct parse *pcmd,
2173 FILE *fp
2174 )
2175 {
2176 /* 8 is the maximum number of peers which will fit in a packet */
2177 struct conf_unpeer *pl, plist[min(MAXARGS, 8)];
2178 int qitems;
2179 int items;
2180 int itemsize;
2181 char *dummy;
2182 int res;
2183 int sendsize;
2184
2185 again:
2186 if (impl_ver == IMPL_XNTPD)
2187 sendsize = sizeof(struct conf_unpeer);
2188 else
2189 sendsize = v4sizeof(struct conf_unpeer);
2190
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)
2195 pl->v6_flag = 0;
2196 } else {
2197 if (impl_ver == IMPL_XNTPD_OLD) {
2198 fprintf(stderr,
2199 "***Server doesn't understand IPv6 addresses\n");
2200 return;
2201 }
2202 pl->peeraddr6 =
2203 GET_INADDR6(pcmd->argval[qitems].netnum);
2204 pl->v6_flag = 1;
2205 }
2206 pl = (struct conf_unpeer *)((char *)pl + sendsize);
2207 }
2208
2209 res = doquery(impl_ver, REQ_RESET_PEER, 1, qitems,
2210 sendsize, (char *)plist, &items,
2211 &itemsize, &dummy, 0, sizeof(struct conf_unpeer));
2212
2213 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2214 impl_ver = IMPL_XNTPD_OLD;
2215 goto again;
2216 }
2217
2218 if (res == 0)
2219 (void) fprintf(fp, "done!\n");
2220 }
2221
2222
2223 /*
2224 * readkeys - request the server to reread the keys file
2225 */
2226 /*ARGSUSED*/
2227 static void
2228 readkeys(
2229 struct parse *pcmd,
2230 FILE *fp
2231 )
2232 {
2233 int items;
2234 int itemsize;
2235 char *dummy;
2236 int res;
2237
2238 again:
2239 res = doquery(impl_ver, REQ_REREAD_KEYS, 1, 0, 0, (char *)0,
2240 &items, &itemsize, &dummy, 0, sizeof(dummy));
2241
2242 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2243 impl_ver = IMPL_XNTPD_OLD;
2244 goto again;
2245 }
2246
2247 if (res == 0)
2248 (void) fprintf(fp, "done!\n");
2249 return;
2250 }
2251
2252
2253 /*
2254 * trustkey - add some keys to the trusted key list
2255 */
2256 static void
2257 trustkey(
2258 struct parse *pcmd,
2259 FILE *fp
2260 )
2261 {
2262 do_trustkey(pcmd, fp, REQ_TRUSTKEY);
2263 }
2264
2265
2266 /*
2267 * untrustkey - remove some keys from the trusted key list
2268 */
2269 static void
2270 untrustkey(
2271 struct parse *pcmd,
2272 FILE *fp
2273 )
2274 {
2275 do_trustkey(pcmd, fp, REQ_UNTRUSTKEY);
2276 }
2277
2278
2279 /*
2280 * do_trustkey - do grunge work of adding/deleting keys
2281 */
2282 static void
2283 do_trustkey(
2284 struct parse *pcmd,
2285 FILE *fp,
2286 int req
2287 )
2288 {
2289 u_long keyids[MAXARGS];
2290 int i;
2291 int items;
2292 int itemsize;
2293 char *dummy;
2294 int ritems;
2295 int res;
2296
2297 ritems = 0;
2298 for (i = 0; i < pcmd->nargs; i++) {
2299 keyids[ritems++] = pcmd->argval[i].uval;
2300 }
2301
2302 again:
2303 res = doquery(impl_ver, req, 1, ritems, sizeof(u_long),
2304 (char *)keyids, &items, &itemsize, &dummy, 0,
2305 sizeof(dummy));
2306
2307 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2308 impl_ver = IMPL_XNTPD_OLD;
2309 goto again;
2310 }
2311
2312 if (res == 0)
2313 (void) fprintf(fp, "done!\n");
2314 return;
2315 }
2316
2317
2318
2319 /*
2320 * authinfo - obtain and print info about authentication
2321 */
2322 /*ARGSUSED*/
2323 static void
2324 authinfo(
2325 struct parse *pcmd,
2326 FILE *fp
2327 )
2328 {
2329 struct info_auth *ia;
2330 int items;
2331 int itemsize;
2332 int res;
2333
2334 again:
2335 res = doquery(impl_ver, REQ_AUTHINFO, 0, 0, 0, (char *)NULL,
2336 &items, &itemsize, (void *)&ia, 0,
2337 sizeof(struct info_auth));
2338
2339 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2340 impl_ver = IMPL_XNTPD_OLD;
2341 goto again;
2342 }
2343
2344 if (res != 0)
2345 return;
2346
2347 if (!check1item(items, fp))
2348 return;
2349
2350 if (!checkitemsize(itemsize, sizeof(struct info_auth)))
2351 return;
2352
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));
2371 }
2372
2373
2374
2375 /*
2376 * traps - obtain and print a list of traps
2377 */
2378 /*ARGSUSED*/
2379 static void
2380 traps(
2381 struct parse *pcmd,
2382 FILE *fp
2383 )
2384 {
2385 int i;
2386 struct info_trap *it;
2387 struct sockaddr_storage trap_addr, local_addr;
2388 int items;
2389 int itemsize;
2390 int res;
2391
2392 again:
2393 res = doquery(impl_ver, REQ_TRAPS, 0, 0, 0, (char *)NULL,
2394 &items, &itemsize, (void *)&it, 0,
2395 sizeof(struct info_trap));
2396
2397 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2398 impl_ver = IMPL_XNTPD_OLD;
2399 goto again;
2400 }
2401
2402 if (res != 0)
2403 return;
2404
2405 if (!checkitems(items, fp))
2406 return;
2407
2408 if (!checkitemsize(itemsize, sizeof(struct info_trap)) &&
2409 !checkitemsize(itemsize, v4sizeof(struct info_trap)))
2410 return;
2411
2412 for (i = 0; i < items; i++ ) {
2413 if (i != 0)
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;
2422 } else {
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;
2427 }
2428 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2429 trap_addr.ss_len = SOCKLEN(&trap_addr);
2430 local_addr.ss_len = SOCKLEN(&local_addr);
2431 #endif
2432 (void) fprintf(fp, "address %s, port %d\n",
2433 stoa(&trap_addr),
2434 ntohs(it->trap_port));
2435 (void) fprintf(fp, "interface: %s, ",
2436 (it->local_address == 0)
2437 ? "wildcard"
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");
2443 else
2444 (void) fprintf(fp, "normal priority\n");
2445
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));
2452 }
2453 }
2454
2455
2456 /*
2457 * addtrap - configure a trap
2458 */
2459 static void
2460 addtrap(
2461 struct parse *pcmd,
2462 FILE *fp
2463 )
2464 {
2465 do_addclr_trap(pcmd, fp, REQ_ADD_TRAP);
2466 }
2467
2468
2469 /*
2470 * clrtrap - clear a trap from the server
2471 */
2472 static void
2473 clrtrap(
2474 struct parse *pcmd,
2475 FILE *fp
2476 )
2477 {
2478 do_addclr_trap(pcmd, fp, REQ_CLR_TRAP);
2479 }
2480
2481
2482 /*
2483 * do_addclr_trap - do grunge work of adding/deleting traps
2484 */
2485 static void
2486 do_addclr_trap(
2487 struct parse *pcmd,
2488 FILE *fp,
2489 int req
2490 )
2491 {
2492 struct conf_trap ctrap;
2493 int items;
2494 int itemsize;
2495 char *dummy;
2496 int res;
2497 int sendsize;
2498
2499 again:
2500 if (impl_ver == IMPL_XNTPD)
2501 sendsize = sizeof(struct conf_trap);
2502 else
2503 sendsize = v4sizeof(struct conf_trap);
2504
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)
2508 ctrap.v6_flag = 0;
2509 } else {
2510 if (impl_ver == IMPL_XNTPD_OLD) {
2511 fprintf(stderr,
2512 "***Server doesn't understand IPv6 addresses\n");
2513 return;
2514 }
2515 ctrap.trap_address6 = GET_INADDR6(pcmd->argval[0].netnum);
2516 ctrap.v6_flag = 1;
2517 }
2518 ctrap.local_address = 0;
2519 ctrap.trap_port = htons(TRAPPORT);
2520 ctrap.unused = 0;
2521
2522 if (pcmd->nargs > 1) {
2523 ctrap.trap_port
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) {
2528 fprintf(stderr,
2529 "***Cannot mix IPv4 and IPv6 addresses\n");
2530 return;
2531 }
2532 if (pcmd->argval[2].netnum.ss_family == AF_INET)
2533 ctrap.local_address = GET_INADDR(pcmd->argval[2].netnum);
2534 else
2535 ctrap.local_address6 = GET_INADDR6(pcmd->argval[2].netnum);
2536 }
2537 }
2538
2539 res = doquery(impl_ver, req, 1, 1, sendsize,
2540 (char *)&ctrap, &items, &itemsize, &dummy, 0,
2541 sizeof(struct conf_trap));
2542
2543 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2544 impl_ver = IMPL_XNTPD_OLD;
2545 goto again;
2546 }
2547
2548 if (res == 0)
2549 (void) fprintf(fp, "done!\n");
2550 return;
2551 }
2552
2553
2554
2555 /*
2556 * requestkey - change the server's request key (a dangerous request)
2557 */
2558 static void
2559 requestkey(
2560 struct parse *pcmd,
2561 FILE *fp
2562 )
2563 {
2564 do_changekey(pcmd, fp, REQ_REQUEST_KEY);
2565 }
2566
2567
2568 /*
2569 * controlkey - change the server's control key
2570 */
2571 static void
2572 controlkey(
2573 struct parse *pcmd,
2574 FILE *fp
2575 )
2576 {
2577 do_changekey(pcmd, fp, REQ_CONTROL_KEY);
2578 }
2579
2580
2581
2582 /*
2583 * do_changekey - do grunge work of changing keys
2584 */
2585 static void
2586 do_changekey(
2587 struct parse *pcmd,
2588 FILE *fp,
2589 int req
2590 )
2591 {
2592 u_long key;
2593 int items;
2594 int itemsize;
2595 char *dummy;
2596 int res;
2597
2598
2599 key = htonl((u_int32)pcmd->argval[0].uval);
2600
2601 again:
2602 res = doquery(impl_ver, req, 1, 1, sizeof(u_int32),
2603 (char *)&key, &items, &itemsize, &dummy, 0,
2604 sizeof(dummy));
2605
2606 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2607 impl_ver = IMPL_XNTPD_OLD;
2608 goto again;
2609 }
2610
2611 if (res == 0)
2612 (void) fprintf(fp, "done!\n");
2613 return;
2614 }
2615
2616
2617
2618 /*
2619 * ctlstats - obtain and print info about authentication
2620 */
2621 /*ARGSUSED*/
2622 static void
2623 ctlstats(
2624 struct parse *pcmd,
2625 FILE *fp
2626 )
2627 {
2628 struct info_control *ic;
2629 int items;
2630 int itemsize;
2631 int res;
2632
2633 again:
2634 res = doquery(impl_ver, REQ_GET_CTLSTATS, 0, 0, 0, (char *)NULL,
2635 &items, &itemsize, (void *)&ic, 0,
2636 sizeof(struct info_control));
2637
2638 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2639 impl_ver = IMPL_XNTPD_OLD;
2640 goto again;
2641 }
2642
2643 if (res != 0)
2644 return;
2645
2646 if (!check1item(items, fp))
2647 return;
2648
2649 if (!checkitemsize(itemsize, sizeof(struct info_control)))
2650 return;
2651
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));
2682 }
2683
2684
2685 /*
2686 * clockstat - get and print clock status information
2687 */
2688 static void
2689 clockstat(
2690 struct parse *pcmd,
2691 FILE *fp
2692 )
2693 {
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)];
2697 int qitems;
2698 int items;
2699 int itemsize;
2700 int res;
2701 l_fp ts;
2702 struct clktype *clk;
2703
2704 for (qitems = 0; qitems < min(pcmd->nargs, 8); qitems++)
2705 clist[qitems] = GET_INADDR(pcmd->argval[qitems].netnum);
2706
2707 again:
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));
2711
2712 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2713 impl_ver = IMPL_XNTPD_OLD;
2714 goto again;
2715 }
2716
2717 if (res != 0)
2718 return;
2719
2720 if (!checkitems(items, fp))
2721 return;
2722
2723 if (!checkitemsize(itemsize, sizeof(struct info_clock)))
2724 return;
2725
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)
2731 break;
2732 if (clk->code >= 0)
2733 (void) fprintf(fp, "clock type: %s\n",
2734 clk->clocktype);
2735 else
2736 (void) fprintf(fp, "clock type: unknown type (%d)\n",
2737 cl->type);
2738 (void) fprintf(fp, "last event: %d\n",
2739 cl->lastevent);
2740 (void) fprintf(fp, "current status: %d\n",
2741 cl->currentstatus);
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",
2754 lfptoa(&ts, 6));
2755 NTOHL_FP(&cl->fudgetime2, &ts);
2756 (void) fprintf(fp, "fudge time 2: %s\n",
2757 lfptoa(&ts, 6));
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",
2763 cl->flags);
2764
2765 if (items > 0)
2766 (void) fprintf(fp, "\n");
2767 cl++;
2768 }
2769 }
2770
2771
2772 /*
2773 * fudge - set clock fudge factors
2774 */
2775 static void
2776 fudge(
2777 struct parse *pcmd,
2778 FILE *fp
2779 )
2780 {
2781 struct conf_fudge fudgedata;
2782 int items;
2783 int itemsize;
2784 char *dummy;
2785 l_fp ts;
2786 int res;
2787 long val;
2788 u_long u_val;
2789 int err;
2790
2791
2792 err = 0;
2793 memset((char *)&fudgedata, 0, sizeof fudgedata);
2794 fudgedata.clockadr = GET_INADDR(pcmd->argval[0].netnum);
2795
2796 if (STREQ(pcmd->argval[1].string, "time1")) {
2797 fudgedata.which = htonl(FUDGE_TIME1);
2798 if (!atolfp(pcmd->argval[2].string, &ts))
2799 err = 1;
2800 else
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))
2805 err = 1;
2806 else
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))
2811 err = 1;
2812 else
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))
2817 err = 1;
2818 else
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))
2823 err = 1;
2824 else
2825 fudgedata.fudgeval_flags = htonl((u_int32)(u_val & 0xf));
2826 } else {
2827 (void) fprintf(stderr, "What fudge is %s?\n",
2828 pcmd->argval[1].string);
2829 return;
2830 }
2831
2832 if (err) {
2833 (void) fprintf(stderr, "Unknown fudge parameter %s\n",
2834 pcmd->argval[2].string);
2835 return;
2836 }
2837
2838 again:
2839 res = doquery(impl_ver, REQ_SET_CLKFUDGE, 1, 1,
2840 sizeof(struct conf_fudge), (char *)&fudgedata, &items,
2841 &itemsize, &dummy, 0, sizeof(dummy));
2842
2843 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2844 impl_ver = IMPL_XNTPD_OLD;
2845 goto again;
2846 }
2847
2848 if (res == 0)
2849 (void) fprintf(fp, "done!\n");
2850 return;
2851 }
2852
2853 /*
2854 * clkbug - get and print clock debugging information
2855 */
2856 static void
2857 clkbug(
2858 struct parse *pcmd,
2859 FILE *fp
2860 )
2861 {
2862 register int i;
2863 register int n;
2864 register u_int32 s;
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)];
2868 u_int32 ltemp;
2869 int qitems;
2870 int items;
2871 int itemsize;
2872 int res;
2873 int needsp;
2874 l_fp ts;
2875
2876 for (qitems = 0; qitems < min(pcmd->nargs, 8); qitems++)
2877 clist[qitems] = GET_INADDR(pcmd->argval[qitems].netnum);
2878
2879 again:
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));
2883
2884 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2885 impl_ver = IMPL_XNTPD_OLD;
2886 goto again;
2887 }
2888
2889 if (res != 0)
2890 return;
2891
2892 if (!checkitems(items, fp))
2893 return;
2894
2895 if (!checkitemsize(itemsize, sizeof(struct info_clkbug)))
2896 return;
2897
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)
2905 n = NUMCBUGVALUES;
2906 for (i = 0; i < n; i++) {
2907 ltemp = ntohl(cl->values[i]);
2908 ltemp &= 0xffffffff; /* HMS: This does nothing now */
2909 if ((i & 0x3) == 0)
2910 (void) fprintf(fp, "\n");
2911 if (s & (1 << i))
2912 (void) fprintf(fp, "%12ld", (u_long)ltemp);
2913 else
2914 (void) fprintf(fp, "%12lu", (u_long)ltemp);
2915 }
2916 (void) fprintf(fp, "\n");
2917
2918 n = (int)cl->ntimes;
2919 (void) fprintf(fp, "times: %d", n);
2920 s = ntohl(cl->stimes);
2921 if (n > NUMCBUGTIMES)
2922 n = NUMCBUGTIMES;
2923 needsp = 0;
2924 for (i = 0; i < n; i++) {
2925 if ((i & 0x1) == 0) {
2926 (void) fprintf(fp, "\n");
2927 } else {
2928 for (;needsp > 0; needsp--)
2929 putc(' ', fp);
2930 }
2931 NTOHL_FP(&cl->times[i], &ts);
2932 if (s & (1 << i)) {
2933 (void) fprintf(fp, "%17s",
2934 lfptoa(&ts, 6));
2935 needsp = 22;
2936 } else {
2937 (void) fprintf(fp, "%37s",
2938 uglydate(&ts));
2939 needsp = 2;
2940 }
2941 }
2942 (void) fprintf(fp, "\n");
2943 if (items > 0) {
2944 cl++;
2945 (void) fprintf(fp, "\n");
2946 }
2947 }
2948 }
2949
2950
2951 /*
2952 * kerninfo - display the kernel pll/pps variables
2953 */
2954 static void
2955 kerninfo(
2956 struct parse *pcmd,
2957 FILE *fp
2958 )
2959 {
2960 struct info_kernel *ik;
2961 int items;
2962 int itemsize;
2963 int res;
2964 unsigned status;
2965 double tscale = 1e-6;
2966
2967 again:
2968 res = doquery(impl_ver, REQ_GET_KERNEL, 0, 0, 0, (char *)NULL,
2969 &items, &itemsize, (void *)&ik, 0,
2970 sizeof(struct info_kernel));
2971
2972 if (res == INFO_ERR_IMPL && impl_ver == IMPL_XNTPD) {
2973 impl_ver = IMPL_XNTPD_OLD;
2974 goto again;
2975 }
2976
2977 if (res != 0)
2978 return;
2979 if (!check1item(items, fp))
2980 return;
2981 if (!checkitemsize(itemsize, sizeof(struct info_kernel)))
2982 return;
2983
2984 status = ntohs(ik->status) & 0xffff;
2985 /*
2986 * pll variables. We know more than we should about the NANO bit.
2987 */
2988 #ifdef STA_NANO
2989 if (status & STA_NANO)
2990 tscale = 1e-9;
2991 #endif
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);
3001 #ifdef STA_PLL
3002 if (status & STA_PLL) (void)fprintf(fp, " pll");
3003 #endif
3004 #ifdef STA_PPSFREQ
3005 if (status & STA_PPSFREQ) (void)fprintf(fp, " ppsfreq");
3006 #endif
3007 #ifdef STA_PPSTIME
3008 if (status & STA_PPSTIME) (void)fprintf(fp, " ppstime");
3009 #endif
3010 #ifdef STA_FLL
3011 if (status & STA_FLL) (void)fprintf(fp, " fll");
3012 #endif
3013 #ifdef STA_INS
3014 if (status & STA_INS) (void)fprintf(fp, " ins");
3015 #endif
3016 #ifdef STA_DEL
3017 if (status & STA_DEL) (void)fprintf(fp, " del");
3018 #endif
3019 #ifdef STA_UNSYNC
3020 if (status & STA_UNSYNC) (void)fprintf(fp, " unsync");
3021 #endif
3022 #ifdef STA_FREQHOLD
3023 if (status & STA_FREQHOLD) (void)fprintf(fp, " freqhold");
3024 #endif
3025 #ifdef STA_PPSSIGNAL
3026 if (status & STA_PPSSIGNAL) (void)fprintf(fp, " ppssignal");
3027 #endif
3028 #ifdef STA_PPSJITTER
3029 if (status & STA_PPSJITTER) (void)fprintf(fp, " ppsjitter");
3030 #endif
3031 #ifdef STA_PPSWANDER
3032 if (status & STA_PPSWANDER) (void)fprintf(fp, " ppswander");
3033 #endif
3034 #ifdef STA_PPSERROR
3035 if (status & STA_PPSERROR) (void)fprintf(fp, " ppserror");
3036 #endif
3037 #ifdef STA_CLOCKERR
3038 if (status & STA_CLOCKERR) (void)fprintf(fp, " clockerr");
3039 #endif
3040 #ifdef STA_NANO
3041 if (status & STA_NANO) (void)fprintf(fp, " nano");
3042 #endif
3043 #ifdef STA_MODE
3044 if (status & STA_MODE) (void)fprintf(fp, " mode=fll");
3045 #endif
3046 #ifdef STA_CLK
3047 if (status & STA_CLK) (void)fprintf(fp, " src=B");
3048 #endif
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));
3056
3057 /*
3058 * For backwards compatibility (ugh), we find the pps variables
3059 * only if the shift member is nonzero.
3060 */
3061 if (!ik->shift)
3062 return;
3063
3064 /*
3065 * pps variables
3066 */
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));
3083 }
3084
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"
3090
3091 static void
3092 iflist(
3093 FILE *fp,
3094 struct info_if_stats *ifs,
3095 int items,
3096 int itemsize,
3097 int res
3098 )
3099 {
3100 static char *actions = "?.+-";
3101 struct sockaddr_storage saddr;
3102
3103 if (res != 0)
3104 return;
3105
3106 if (!checkitems(items, fp))
3107 return;
3108
3109 if (!checkitemsize(itemsize, sizeof(struct info_if_stats)))
3110 return;
3111
3112 fprintf(fp, IF_LIST_FMT_STR, IF_LIST_LABELS);
3113 fprintf(fp, IF_LIST_LINE);
3114
3115 while (items > 0) {
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;
3119 } else {
3120 memcpy((char *)&GET_INADDR(saddr), (char *)&ifs->unaddr.addr, sizeof(ifs->unaddr.addr));
3121 saddr.ss_family = AF_INET;
3122 }
3123 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
3124 saddr.ss_len = SOCKLEN(&saddr);
3125 #endif
3126 fprintf(fp, IF_LIST_FMT,
3127 ntohl(ifs->ifnum),
3128 actions[(ifs->action >= 1 && ifs->action < 4) ? ifs->action : 0],
3129 stoa((&saddr)), 'A',
3130 ifs->ignore_packets ? 'D' : 'E',
3131 ifs->name,
3132 ntohl(ifs->flags),
3133 ntohl(ifs->last_ttl),
3134 ntohl(ifs->num_mcast),
3135 ntohl(ifs->received),
3136 ntohl(ifs->sent),
3137 ntohl(ifs->notsent),
3138 ntohl(ifs->scopeid),
3139 ntohl(ifs->ifindex),
3140 ntohl(ifs->peercnt),
3141 ntohl(ifs->uptime));
3142
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;
3146 } else {
3147 memcpy((char *)&GET_INADDR(saddr), (char *)&ifs->unmask.addr, sizeof(ifs->unmask.addr));
3148 saddr.ss_family = AF_INET;
3149 }
3150 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
3151 saddr.ss_len = SOCKLEN(&saddr);
3152 #endif
3153 fprintf(fp, IF_LIST_AFMT_STR, stoa(&saddr), 'M');
3154
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);
3160 #endif
3161 fprintf(fp, IF_LIST_AFMT_STR, stoa(&saddr), 'B');
3162
3163 }
3164
3165 ifs++;
3166 items--;
3167 }
3168 }
3169
3170 /*ARGSUSED*/
3171 static void
3172 get_if_stats(
3173 struct parse *pcmd,
3174 FILE *fp
3175 )
3176 {
3177 struct info_if_stats *ifs;
3178 int items;
3179 int itemsize;
3180 int res;
3181
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);
3186 }
3187
3188 /*ARGSUSED*/
3189 static void
3190 do_if_reload(
3191 struct parse *pcmd,
3192 FILE *fp
3193 )
3194 {
3195 struct info_if_stats *ifs;
3196 int items;
3197 int itemsize;
3198 int res;
3199
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);
3204 }
FreeBSD kvm: FreeBSD sources