2 * ntp_request.c - respond to information requests
10 #include "ntp_request.h"
11 #include "ntp_control.h"
12 #include "ntp_refclock.h"
14 #include "ntp_stdlib.h"
18 #include <netinet/in.h>
19 #include <arpa/inet.h>
24 #include "ntp_syscall.h"
25 #endif /* KERNEL_PLL */
28 * Structure to hold request procedure information
33 #define NO_REQUEST (-1)
36 short request_code; /* defined request code */
37 short needs_auth; /* true when authentication needed */
38 short sizeofitem; /* size of request data item */
39 void (*handler) P((struct sockaddr_in *, struct interface *,
40 struct req_pkt *)); /* routine to handle request */
44 * Universal request codes
46 static struct req_proc univ_codes[] = {
47 { NO_REQUEST, NOAUTH, 0, 0 }
50 static void req_ack P((struct sockaddr_in *, struct interface *, struct req_pkt *, int));
51 static char * prepare_pkt P((struct sockaddr_in *, struct interface *, struct req_pkt *, u_int));
52 static char * more_pkt P((void));
53 static void flush_pkt P((void));
54 static void peer_list P((struct sockaddr_in *, struct interface *, struct req_pkt *));
55 static void peer_list_sum P((struct sockaddr_in *, struct interface *, struct req_pkt *));
56 static void peer_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
57 static void peer_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
58 static void sys_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
59 static void sys_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
60 static void mem_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
61 static void io_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
62 static void timer_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
63 static void loop_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
64 static void dns_a P((struct sockaddr_in *, struct interface *, struct req_pkt *));
65 static void do_conf P((struct sockaddr_in *, struct interface *, struct req_pkt *));
66 static void do_unconf P((struct sockaddr_in *, struct interface *, struct req_pkt *));
67 static void set_sys_flag P((struct sockaddr_in *, struct interface *, struct req_pkt *));
68 static void clr_sys_flag P((struct sockaddr_in *, struct interface *, struct req_pkt *));
69 static void setclr_flags P((struct sockaddr_in *, struct interface *, struct req_pkt *, u_long));
70 static void list_restrict P((struct sockaddr_in *, struct interface *, struct req_pkt *));
71 static void do_resaddflags P((struct sockaddr_in *, struct interface *, struct req_pkt *));
72 static void do_ressubflags P((struct sockaddr_in *, struct interface *, struct req_pkt *));
73 static void do_unrestrict P((struct sockaddr_in *, struct interface *, struct req_pkt *));
74 static void do_restrict P((struct sockaddr_in *, struct interface *, struct req_pkt *, int));
75 static void mon_getlist_0 P((struct sockaddr_in *, struct interface *, struct req_pkt *));
76 static void mon_getlist_1 P((struct sockaddr_in *, struct interface *, struct req_pkt *));
77 static void reset_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
78 static void reset_peer P((struct sockaddr_in *, struct interface *, struct req_pkt *));
79 static void do_key_reread P((struct sockaddr_in *, struct interface *, struct req_pkt *));
80 static void trust_key P((struct sockaddr_in *, struct interface *, struct req_pkt *));
81 static void untrust_key P((struct sockaddr_in *, struct interface *, struct req_pkt *));
82 static void do_trustkey P((struct sockaddr_in *, struct interface *, struct req_pkt *, u_long));
83 static void get_auth_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
84 static void reset_auth_stats P((void));
85 static void req_get_traps P((struct sockaddr_in *, struct interface *, struct req_pkt *));
86 static void req_set_trap P((struct sockaddr_in *, struct interface *, struct req_pkt *));
87 static void req_clr_trap P((struct sockaddr_in *, struct interface *, struct req_pkt *));
88 static void do_setclr_trap P((struct sockaddr_in *, struct interface *, struct req_pkt *, int));
89 static void set_request_keyid P((struct sockaddr_in *, struct interface *, struct req_pkt *));
90 static void set_control_keyid P((struct sockaddr_in *, struct interface *, struct req_pkt *));
91 static void get_ctl_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
93 static void get_kernel_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
94 #endif /* KERNEL_PLL */
96 static void get_clock_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
97 static void set_clock_fudge P((struct sockaddr_in *, struct interface *, struct req_pkt *));
100 static void get_clkbug_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
101 #endif /* REFCLOCK */
106 static struct req_proc ntp_codes[] = {
107 { REQ_PEER_LIST, NOAUTH, 0, peer_list },
108 { REQ_PEER_LIST_SUM, NOAUTH, 0, peer_list_sum },
109 { REQ_PEER_INFO, NOAUTH, sizeof(struct info_peer_list), peer_info },
110 { REQ_PEER_STATS, NOAUTH, sizeof(struct info_peer_list), peer_stats },
111 { REQ_SYS_INFO, NOAUTH, 0, sys_info },
112 { REQ_SYS_STATS, NOAUTH, 0, sys_stats },
113 { REQ_IO_STATS, NOAUTH, 0, io_stats },
114 { REQ_MEM_STATS, NOAUTH, 0, mem_stats },
115 { REQ_LOOP_INFO, NOAUTH, 0, loop_info },
116 { REQ_TIMER_STATS, NOAUTH, 0, timer_stats },
117 { REQ_HOSTNAME_ASSOCID, AUTH, sizeof(struct info_dns_assoc), dns_a },
118 { REQ_CONFIG, AUTH, sizeof(struct conf_peer), do_conf },
119 { REQ_UNCONFIG, AUTH, sizeof(struct conf_unpeer), do_unconf },
120 { REQ_SET_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags), set_sys_flag },
121 { REQ_CLR_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags), clr_sys_flag },
122 { REQ_GET_RESTRICT, NOAUTH, 0, list_restrict },
123 { REQ_RESADDFLAGS, AUTH, sizeof(struct conf_restrict), do_resaddflags },
124 { REQ_RESSUBFLAGS, AUTH, sizeof(struct conf_restrict), do_ressubflags },
125 { REQ_UNRESTRICT, AUTH, sizeof(struct conf_restrict), do_unrestrict },
126 { REQ_MON_GETLIST, NOAUTH, 0, mon_getlist_0 },
127 { REQ_MON_GETLIST_1, NOAUTH, 0, mon_getlist_1 },
128 { REQ_RESET_STATS, AUTH, sizeof(struct reset_flags), reset_stats },
129 { REQ_RESET_PEER, AUTH, sizeof(struct conf_unpeer), reset_peer },
130 { REQ_REREAD_KEYS, AUTH, 0, do_key_reread },
131 { REQ_TRUSTKEY, AUTH, sizeof(u_long), trust_key },
132 { REQ_UNTRUSTKEY, AUTH, sizeof(u_long), untrust_key },
133 { REQ_AUTHINFO, NOAUTH, 0, get_auth_info },
134 { REQ_TRAPS, NOAUTH, 0, req_get_traps },
135 { REQ_ADD_TRAP, AUTH, sizeof(struct conf_trap), req_set_trap },
136 { REQ_CLR_TRAP, AUTH, sizeof(struct conf_trap), req_clr_trap },
137 { REQ_REQUEST_KEY, AUTH, sizeof(u_long), set_request_keyid },
138 { REQ_CONTROL_KEY, AUTH, sizeof(u_long), set_control_keyid },
139 { REQ_GET_CTLSTATS, NOAUTH, 0, get_ctl_stats },
141 { REQ_GET_KERNEL, NOAUTH, 0, get_kernel_info },
144 { REQ_GET_CLOCKINFO, NOAUTH, sizeof(u_int32), get_clock_info },
145 { REQ_SET_CLKFUDGE, AUTH, sizeof(struct conf_fudge), set_clock_fudge },
146 { REQ_GET_CLKBUGINFO, NOAUTH, sizeof(u_int32), get_clkbug_info },
148 { NO_REQUEST, NOAUTH, 0, 0 }
153 * Authentication keyid used to authenticate requests. Zero means we
154 * don't allow writing anything.
156 keyid_t info_auth_keyid;
159 * Statistic counters to keep track of requests and responses.
161 u_long numrequests; /* number of requests we've received */
162 u_long numresppkts; /* number of resp packets sent with data */
164 u_long errorcounter[INFO_ERR_AUTH+1]; /* lazy way to count errors, indexed */
165 /* by the error code */
168 * A hack. To keep the authentication module clear of ntp-ism's, we
169 * include a time reset variable for its stats here.
171 static u_long auth_timereset;
174 * Response packet used by these routines. Also some state information
175 * so that we can handle packet formatting within a common set of
176 * subroutines. Note we try to enter data in place whenever possible,
177 * but the need to set the more bit correctly means we occasionally
178 * use the extra buffer and copy.
180 static struct resp_pkt rpkt;
185 static int databytes;
186 static char exbuf[RESP_DATA_SIZE];
187 static int usingexbuf;
188 static struct sockaddr_in *toaddr;
189 static struct interface *frominter;
192 * init_request - initialize request data
202 info_auth_keyid = 0; /* by default, can't do this */
204 for (i = 0; i < sizeof(errorcounter)/sizeof(errorcounter[0]); i++)
210 * req_ack - acknowledge request with no data
214 struct sockaddr_in *srcadr,
215 struct interface *inter,
216 struct req_pkt *inpkt,
223 rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, 0, reqver);
224 rpkt.auth_seq = AUTH_SEQ(0, 0);
225 rpkt.implementation = inpkt->implementation;
226 rpkt.request = inpkt->request;
227 rpkt.err_nitems = ERR_NITEMS(errcode, 0);
228 rpkt.mbz_itemsize = MBZ_ITEMSIZE(0);
231 * send packet and bump counters
233 sendpkt(srcadr, inter, -1, (struct pkt *)&rpkt, RESP_HEADER_SIZE);
234 errorcounter[errcode]++;
239 * prepare_pkt - prepare response packet for transmission, return pointer
240 * to storage for data item.
244 struct sockaddr_in *srcadr,
245 struct interface *inter,
252 printf("request: preparing pkt\n");
256 * Fill in the implementation, reqest and itemsize fields
257 * since these won't change.
259 rpkt.implementation = pkt->implementation;
260 rpkt.request = pkt->request;
261 rpkt.mbz_itemsize = MBZ_ITEMSIZE(structsize);
264 * Compute the static data needed to carry on.
270 itemsize = structsize;
275 * return the beginning of the packet buffer.
277 return &rpkt.data[0];
282 * more_pkt - return a data pointer for a new item.
288 * If we were using the extra buffer, send the packet.
293 printf("request: sending pkt\n");
295 rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, MORE_BIT, reqver);
296 rpkt.auth_seq = AUTH_SEQ(0, seqno);
297 rpkt.err_nitems = htons((u_short)nitems);
298 sendpkt(toaddr, frominter, -1, (struct pkt *)&rpkt,
299 RESP_HEADER_SIZE+databytes);
303 * Copy data out of exbuf into the packet.
305 memmove(&rpkt.data[0], exbuf, (unsigned)itemsize);
312 databytes += itemsize;
314 if (databytes + itemsize <= RESP_DATA_SIZE) {
317 printf("request: giving him more data\n");
320 * More room in packet. Give him the
323 return &rpkt.data[databytes];
326 * No room in packet. Give him the extra
327 * buffer unless this was the last in the sequence.
331 printf("request: into extra buffer\n");
344 * flush_pkt - we're done, return remaining information.
351 printf("request: flushing packet, %d items\n", nitems);
354 * Must send the last packet. If nothing in here and nothing
355 * has been sent, send an error saying no data to be found.
357 if (seqno == 0 && nitems == 0)
358 req_ack(toaddr, frominter, (struct req_pkt *)&rpkt,
361 rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, 0, reqver);
362 rpkt.auth_seq = AUTH_SEQ(0, seqno);
363 rpkt.err_nitems = htons((u_short)nitems);
364 sendpkt(toaddr, frominter, -1, (struct pkt *)&rpkt,
365 RESP_HEADER_SIZE+databytes);
373 * process_private - process private mode (7) packets
377 struct recvbuf *rbufp,
381 struct req_pkt *inpkt;
382 struct sockaddr_in *srcadr;
383 struct interface *inter;
384 struct req_proc *proc;
388 * Initialize pointers, for convenience
390 inpkt = (struct req_pkt *)&rbufp->recv_pkt;
391 srcadr = &rbufp->recv_srcadr;
392 inter = rbufp->dstadr;
396 printf("process_private: impl %d req %d\n",
397 inpkt->implementation, inpkt->request);
401 * Do some sanity checks on the packet. Return a format
405 if ( (++ec, ISRESPONSE(inpkt->rm_vn_mode))
406 || (++ec, ISMORE(inpkt->rm_vn_mode))
407 || (++ec, INFO_VERSION(inpkt->rm_vn_mode) > NTP_VERSION)
408 || (++ec, INFO_VERSION(inpkt->rm_vn_mode) < NTP_OLDVERSION)
409 || (++ec, INFO_SEQ(inpkt->auth_seq) != 0)
410 || (++ec, INFO_ERR(inpkt->err_nitems) != 0)
411 || (++ec, INFO_MBZ(inpkt->mbz_itemsize) != 0)
412 || (++ec, rbufp->recv_length > REQ_LEN_MAC)
413 || (++ec, rbufp->recv_length < REQ_LEN_NOMAC)
415 msyslog(LOG_ERR, "process_private: INFO_ERR_FMT: test %d failed", ec);
416 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
420 reqver = INFO_VERSION(inpkt->rm_vn_mode);
423 * Get the appropriate procedure list to search.
425 if (inpkt->implementation == IMPL_UNIV)
427 else if (inpkt->implementation == IMPL_XNTPD)
430 req_ack(srcadr, inter, inpkt, INFO_ERR_IMPL);
435 * Search the list for the request codes. If it isn't one
436 * we know, return an error.
438 while (proc->request_code != NO_REQUEST) {
439 if (proc->request_code == (short) inpkt->request)
443 if (proc->request_code == NO_REQUEST) {
444 req_ack(srcadr, inter, inpkt, INFO_ERR_REQ);
450 printf("found request in tables\n");
454 * If we need to authenticate, do so. Note that an
455 * authenticatable packet must include a mac field, must
456 * have used key info_auth_keyid and must have included
457 * a time stamp in the appropriate field. The time stamp
458 * must be within INFO_TS_MAXSKEW of the receive
461 if (proc->needs_auth && sys_authenticate) {
466 * If this guy is restricted from doing this, don't let him
467 * If wrong key was used, or packet doesn't have mac, return.
469 if (!INFO_IS_AUTH(inpkt->auth_seq) || info_auth_keyid == 0
470 || ntohl(inpkt->keyid) != info_auth_keyid) {
473 printf("failed auth %d info_auth_keyid %lu pkt keyid %lu\n",
474 INFO_IS_AUTH(inpkt->auth_seq),
475 (u_long)info_auth_keyid,
476 (u_long)ntohl(inpkt->keyid));
478 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
481 if (rbufp->recv_length > REQ_LEN_MAC) {
484 printf("bad pkt length %d\n",
487 msyslog(LOG_ERR, "process_private: bad pkt length %d",
489 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
492 if (!mod_okay || !authhavekey(info_auth_keyid)) {
495 printf("failed auth mod_okay %d\n", mod_okay);
497 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
502 * calculate absolute time difference between xmit time stamp
503 * and receive time stamp. If too large, too bad.
505 NTOHL_FP(&inpkt->tstamp, &ftmp);
506 L_SUB(&ftmp, &rbufp->recv_time);
507 LFPTOD(&ftmp, dtemp);
508 if (fabs(dtemp) >= INFO_TS_MAXSKEW) {
510 * He's a loser. Tell him.
512 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
517 * So far so good. See if decryption works out okay.
519 if (!authdecrypt(info_auth_keyid, (u_int32 *)inpkt,
520 REQ_LEN_NOMAC, (int)(rbufp->recv_length - REQ_LEN_NOMAC))) {
521 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
527 * If we need data, check to see if we have some. If we
528 * don't, check to see that there is none (picky, picky).
530 if (INFO_ITEMSIZE(inpkt->mbz_itemsize) != proc->sizeofitem) {
531 msyslog(LOG_ERR, "INFO_ITEMSIZE(inpkt->mbz_itemsize) != proc->sizeofitem: %d != %d",
532 INFO_ITEMSIZE(inpkt->mbz_itemsize), proc->sizeofitem);
533 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
536 if (proc->sizeofitem != 0)
537 if (proc->sizeofitem*INFO_NITEMS(inpkt->err_nitems)
538 > sizeof(inpkt->data)) {
539 msyslog(LOG_ERR, "sizeofitem(%d)*NITEMS(%d) > data: %d > %ld",
540 proc->sizeofitem, INFO_NITEMS(inpkt->err_nitems),
541 proc->sizeofitem*INFO_NITEMS(inpkt->err_nitems),
542 (long)sizeof(inpkt->data));
543 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
548 printf("process_private: all okay, into handler\n");
552 * Packet is okay. Call the handler to send him data.
554 (proc->handler)(srcadr, inter, inpkt);
559 * peer_list - send a list of the peers
563 struct sockaddr_in *srcadr,
564 struct interface *inter,
565 struct req_pkt *inpkt
568 register struct info_peer_list *ip;
569 register struct peer *pp;
572 ip = (struct info_peer_list *)prepare_pkt(srcadr, inter, inpkt,
573 sizeof(struct info_peer_list));
574 for (i = 0; i < HASH_SIZE && ip != 0; i++) {
576 while (pp != 0 && ip != 0) {
577 ip->address = pp->srcadr.sin_addr.s_addr;
578 ip->port = pp->srcadr.sin_port;
579 ip->hmode = pp->hmode;
581 if (pp->flags & FLAG_CONFIG)
582 ip->flags |= INFO_FLAG_CONFIG;
584 ip->flags |= INFO_FLAG_SYSPEER;
585 if (pp->status == CTL_PST_SEL_SYNCCAND)
586 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
587 if (pp->status >= CTL_PST_SEL_SYSPEER)
588 ip->flags |= INFO_FLAG_SHORTLIST;
589 ip = (struct info_peer_list *)more_pkt();
598 * peer_list_sum - return extended peer list
602 struct sockaddr_in *srcadr,
603 struct interface *inter,
604 struct req_pkt *inpkt
607 register struct info_peer_summary *ips;
608 register struct peer *pp;
614 printf("wants peer list summary\n");
617 ips = (struct info_peer_summary *)prepare_pkt(srcadr, inter, inpkt,
618 sizeof(struct info_peer_summary));
619 for (i = 0; i < HASH_SIZE && ips != 0; i++) {
621 while (pp != 0 && ips != 0) {
624 printf("sum: got one\n");
628 ? pp->cast_flags == MDF_BCAST
629 ? pp->dstadr->bcast.sin_addr.s_addr
631 ? pp->dstadr->sin.sin_addr.s_addr
632 ? pp->dstadr->sin.sin_addr.s_addr
633 : pp->dstadr->bcast.sin_addr.s_addr
636 ips->srcadr = pp->srcadr.sin_addr.s_addr;
637 ips->srcport = pp->srcadr.sin_port;
638 ips->stratum = pp->stratum;
639 ips->hpoll = pp->hpoll;
640 ips->ppoll = pp->ppoll;
641 ips->reach = pp->reach;
644 ips->flags |= INFO_FLAG_SYSPEER;
645 if (pp->flags & FLAG_CONFIG)
646 ips->flags |= INFO_FLAG_CONFIG;
647 if (pp->flags & FLAG_REFCLOCK)
648 ips->flags |= INFO_FLAG_REFCLOCK;
649 if (pp->flags & FLAG_AUTHENABLE)
650 ips->flags |= INFO_FLAG_AUTHENABLE;
651 if (pp->flags & FLAG_PREFER)
652 ips->flags |= INFO_FLAG_PREFER;
653 if (pp->flags & FLAG_BURST)
654 ips->flags |= INFO_FLAG_BURST;
655 if (pp->status == CTL_PST_SEL_SYNCCAND)
656 ips->flags |= INFO_FLAG_SEL_CANDIDATE;
657 if (pp->status >= CTL_PST_SEL_SYSPEER)
658 ips->flags |= INFO_FLAG_SHORTLIST;
659 ips->hmode = pp->hmode;
660 ips->delay = HTONS_FP(DTOFP(pp->delay));
661 DTOLFP(pp->offset, <mp);
662 HTONL_FP(<mp, &ips->offset);
663 ips->dispersion = HTONS_FP(DTOUFP(pp->disp));
666 ips = (struct info_peer_summary *)more_pkt();
674 * peer_info - send information for one or more peers
678 struct sockaddr_in *srcadr,
679 struct interface *inter,
680 struct req_pkt *inpkt
683 register struct info_peer_list *ipl;
684 register struct peer *pp;
685 register struct info_peer *ip;
688 struct sockaddr_in addr;
689 extern struct peer *sys_peer;
692 memset((char *)&addr, 0, sizeof addr);
693 addr.sin_family = AF_INET;
694 items = INFO_NITEMS(inpkt->err_nitems);
695 ipl = (struct info_peer_list *) inpkt->data;
696 ip = (struct info_peer *)prepare_pkt(srcadr, inter, inpkt,
697 sizeof(struct info_peer));
698 while (items-- > 0 && ip != 0) {
699 addr.sin_port = ipl->port;
700 addr.sin_addr.s_addr = ipl->address;
702 if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0)
706 ? pp->cast_flags == MDF_BCAST
707 ? pp->dstadr->bcast.sin_addr.s_addr
709 ? pp->dstadr->sin.sin_addr.s_addr
710 ? pp->dstadr->sin.sin_addr.s_addr
711 : pp->dstadr->bcast.sin_addr.s_addr
714 ip->srcadr = NSRCADR(&pp->srcadr);
715 ip->srcport = NSRCPORT(&pp->srcadr);
718 ip->flags |= INFO_FLAG_SYSPEER;
719 if (pp->flags & FLAG_CONFIG)
720 ip->flags |= INFO_FLAG_CONFIG;
721 if (pp->flags & FLAG_REFCLOCK)
722 ip->flags |= INFO_FLAG_REFCLOCK;
723 if (pp->flags & FLAG_AUTHENABLE)
724 ip->flags |= INFO_FLAG_AUTHENABLE;
725 if (pp->flags & FLAG_PREFER)
726 ip->flags |= INFO_FLAG_PREFER;
727 if (pp->flags & FLAG_BURST)
728 ip->flags |= INFO_FLAG_BURST;
729 if (pp->status == CTL_PST_SEL_SYNCCAND)
730 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
731 if (pp->status >= CTL_PST_SEL_SYSPEER)
732 ip->flags |= INFO_FLAG_SHORTLIST;
734 ip->hmode = pp->hmode;
735 ip->keyid = pp->keyid;
736 ip->stratum = pp->stratum;
737 ip->ppoll = pp->ppoll;
738 ip->hpoll = pp->hpoll;
739 ip->precision = pp->precision;
740 ip->version = pp->version;
741 ip->reach = pp->reach;
742 ip->unreach = pp->unreach;
743 ip->flash = (u_char)pp->flash;
744 ip->flash2 = pp->flash;
745 ip->estbdelay = HTONS_FP(DTOFP(pp->estbdelay));
747 ip->associd = htons(pp->associd);
748 ip->rootdelay = HTONS_FP(DTOUFP(pp->rootdelay));
749 ip->rootdispersion = HTONS_FP(DTOUFP(pp->rootdispersion));
750 ip->refid = pp->refid;
751 HTONL_FP(&pp->reftime, &ip->reftime);
752 HTONL_FP(&pp->org, &ip->org);
753 HTONL_FP(&pp->rec, &ip->rec);
754 HTONL_FP(&pp->xmt, &ip->xmt);
755 j = pp->filter_nextpt - 1;
756 for (i = 0; i < NTP_SHIFT; i++, j--) {
759 ip->filtdelay[i] = HTONS_FP(DTOFP(pp->filter_delay[j]));
760 DTOLFP(pp->filter_offset[j], <mp);
761 HTONL_FP(<mp, &ip->filtoffset[i]);
762 ip->order[i] = (pp->filter_nextpt+NTP_SHIFT-1)
763 - pp->filter_order[i];
764 if (ip->order[i] >= NTP_SHIFT)
765 ip->order[i] -= NTP_SHIFT;
767 DTOLFP(pp->offset, <mp);
768 HTONL_FP(<mp, &ip->offset);
769 ip->delay = HTONS_FP(DTOFP(pp->delay));
770 ip->dispersion = HTONS_FP(DTOUFP(SQRT(pp->disp)));
771 ip->selectdisp = HTONS_FP(DTOUFP(SQRT(pp->jitter)));
772 ip = (struct info_peer *)more_pkt();
779 * peer_stats - send statistics for one or more peers
783 struct sockaddr_in *srcadr,
784 struct interface *inter,
785 struct req_pkt *inpkt
788 register struct info_peer_list *ipl;
789 register struct peer *pp;
790 register struct info_peer_stats *ip;
792 struct sockaddr_in addr;
793 extern struct peer *sys_peer;
795 memset((char *)&addr, 0, sizeof addr);
796 addr.sin_family = AF_INET;
797 items = INFO_NITEMS(inpkt->err_nitems);
798 ipl = (struct info_peer_list *) inpkt->data;
799 ip = (struct info_peer_stats *)prepare_pkt(srcadr, inter, inpkt,
800 sizeof(struct info_peer_stats));
801 while (items-- > 0 && ip != 0) {
802 addr.sin_port = ipl->port;
803 addr.sin_addr.s_addr = ipl->address;
805 if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0)
809 ? pp->cast_flags == MDF_BCAST
810 ? pp->dstadr->bcast.sin_addr.s_addr
812 ? pp->dstadr->sin.sin_addr.s_addr
813 ? pp->dstadr->sin.sin_addr.s_addr
814 : pp->dstadr->bcast.sin_addr.s_addr
817 ip->srcadr = NSRCADR(&pp->srcadr);
818 ip->srcport = NSRCPORT(&pp->srcadr);
821 ip->flags |= INFO_FLAG_SYSPEER;
822 if (pp->flags & FLAG_CONFIG)
823 ip->flags |= INFO_FLAG_CONFIG;
824 if (pp->flags & FLAG_REFCLOCK)
825 ip->flags |= INFO_FLAG_REFCLOCK;
826 if (pp->flags & FLAG_AUTHENABLE)
827 ip->flags |= INFO_FLAG_AUTHENABLE;
828 if (pp->flags & FLAG_PREFER)
829 ip->flags |= INFO_FLAG_PREFER;
830 if (pp->flags & FLAG_BURST)
831 ip->flags |= INFO_FLAG_BURST;
832 if (pp->status == CTL_PST_SEL_SYNCCAND)
833 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
834 if (pp->status >= CTL_PST_SEL_SYSPEER)
835 ip->flags |= INFO_FLAG_SHORTLIST;
836 ip->timereceived = htonl((u_int32)(current_time - pp->timereceived));
837 ip->timetosend = htonl(pp->nextdate - current_time);
838 ip->timereachable = htonl((u_int32)(current_time - pp->timereachable));
839 ip->sent = htonl((u_int32)(pp->sent));
840 ip->processed = htonl((u_int32)(pp->processed));
841 ip->badauth = htonl((u_int32)(pp->badauth));
842 ip->bogusorg = htonl((u_int32)(pp->bogusorg));
843 ip->oldpkt = htonl((u_int32)(pp->oldpkt));
844 ip->seldisp = htonl((u_int32)(pp->seldisptoolarge));
845 ip->selbroken = htonl((u_int32)(pp->selbroken));
846 ip->candidate = pp->status;
847 ip = (struct info_peer_stats *)more_pkt();
854 * sys_info - return system info
858 struct sockaddr_in *srcadr,
859 struct interface *inter,
860 struct req_pkt *inpkt
863 register struct info_sys *is;
866 * Importations from the protocol module
868 extern u_char sys_leap;
869 extern u_char sys_stratum;
870 extern s_char sys_precision;
871 extern double sys_rootdelay;
872 extern double sys_rootdispersion;
873 extern u_int32 sys_refid;
874 extern l_fp sys_reftime;
875 extern u_char sys_poll;
876 extern struct peer *sys_peer;
877 extern int sys_bclient;
878 extern double sys_bdelay;
879 extern l_fp sys_authdelay;
880 extern double clock_stability;
881 extern double sys_jitter;
883 is = (struct info_sys *)prepare_pkt(srcadr, inter, inpkt,
884 sizeof(struct info_sys));
887 is->peer = NSRCADR(&sys_peer->srcadr);
888 is->peer_mode = sys_peer->hmode;
894 is->stratum = sys_stratum;
895 is->precision = sys_precision;
896 is->rootdelay = htonl(DTOFP(sys_rootdelay));
897 is->rootdispersion = htonl(DTOUFP(sys_rootdispersion));
898 is->frequency = htonl(DTOFP(sys_jitter));
899 is->stability = htonl(DTOUFP(clock_stability * 1e6));
900 is->refid = sys_refid;
901 HTONL_FP(&sys_reftime, &is->reftime);
907 is->flags |= INFO_FLAG_BCLIENT;
908 if (sys_authenticate)
909 is->flags |= INFO_FLAG_AUTHENTICATE;
911 is->flags |= INFO_FLAG_KERNEL;
913 is->flags |= INFO_FLAG_NTP;
915 is->flags |= INFO_FLAG_PLL_SYNC;
917 is->flags |= INFO_FLAG_PPS_SYNC;
918 if (mon_enabled != MON_OFF)
919 is->flags |= INFO_FLAG_MONITOR;
921 is->flags |= INFO_FLAG_FILEGEN;
922 is->bdelay = HTONS_FP(DTOFP(sys_bdelay));
923 HTONL_UF(sys_authdelay.l_f, &is->authdelay);
931 * sys_stats - return system statistics
935 struct sockaddr_in *srcadr,
936 struct interface *inter,
937 struct req_pkt *inpkt
940 register struct info_sys_stats *ss;
943 * Importations from the protocol module
945 extern u_long sys_stattime;
946 extern u_long sys_badstratum;
947 extern u_long sys_oldversionpkt;
948 extern u_long sys_newversionpkt;
949 extern u_long sys_unknownversion;
950 extern u_long sys_badlength;
951 extern u_long sys_processed;
952 extern u_long sys_badauth;
953 extern u_long sys_limitrejected;
955 ss = (struct info_sys_stats *)prepare_pkt(srcadr, inter, inpkt,
956 sizeof(struct info_sys_stats));
958 ss->timeup = htonl((u_int32)current_time);
959 ss->timereset = htonl((u_int32)(current_time - sys_stattime));
960 ss->badstratum = htonl((u_int32)sys_badstratum);
961 ss->oldversionpkt = htonl((u_int32)sys_oldversionpkt);
962 ss->newversionpkt = htonl((u_int32)sys_newversionpkt);
963 ss->unknownversion = htonl((u_int32)sys_unknownversion);
964 ss->badlength = htonl((u_int32)sys_badlength);
965 ss->processed = htonl((u_int32)sys_processed);
966 ss->badauth = htonl((u_int32)sys_badauth);
967 ss->limitrejected = htonl((u_int32)sys_limitrejected);
974 * mem_stats - return memory statistics
978 struct sockaddr_in *srcadr,
979 struct interface *inter,
980 struct req_pkt *inpkt
983 register struct info_mem_stats *ms;
987 * Importations from the peer module
989 extern int peer_hash_count[HASH_SIZE];
990 extern int peer_free_count;
991 extern u_long peer_timereset;
992 extern u_long findpeer_calls;
993 extern u_long peer_allocations;
994 extern u_long peer_demobilizations;
995 extern int total_peer_structs;
997 ms = (struct info_mem_stats *)prepare_pkt(srcadr, inter, inpkt,
998 sizeof(struct info_mem_stats));
1000 ms->timereset = htonl((u_int32)(current_time - peer_timereset));
1001 ms->totalpeermem = htons((u_short)total_peer_structs);
1002 ms->freepeermem = htons((u_short)peer_free_count);
1003 ms->findpeer_calls = htonl((u_int32)findpeer_calls);
1004 ms->allocations = htonl((u_int32)peer_allocations);
1005 ms->demobilizations = htonl((u_int32)peer_demobilizations);
1007 for (i = 0; i < HASH_SIZE; i++) {
1008 if (peer_hash_count[i] > 255)
1009 ms->hashcount[i] = 255;
1011 ms->hashcount[i] = (u_char)peer_hash_count[i];
1020 * io_stats - return io statistics
1024 struct sockaddr_in *srcadr,
1025 struct interface *inter,
1026 struct req_pkt *inpkt
1029 register struct info_io_stats *io;
1032 * Importations from the io module
1034 extern u_long io_timereset;
1036 io = (struct info_io_stats *)prepare_pkt(srcadr, inter, inpkt,
1037 sizeof(struct info_io_stats));
1039 io->timereset = htonl((u_int32)(current_time - io_timereset));
1040 io->totalrecvbufs = htons((u_short) total_recvbuffs());
1041 io->freerecvbufs = htons((u_short) free_recvbuffs());
1042 io->fullrecvbufs = htons((u_short) full_recvbuffs());
1043 io->lowwater = htons((u_short) lowater_additions());
1044 io->dropped = htonl((u_int32)packets_dropped);
1045 io->ignored = htonl((u_int32)packets_ignored);
1046 io->received = htonl((u_int32)packets_received);
1047 io->sent = htonl((u_int32)packets_sent);
1048 io->notsent = htonl((u_int32)packets_notsent);
1049 io->interrupts = htonl((u_int32)handler_calls);
1050 io->int_received = htonl((u_int32)handler_pkts);
1058 * timer_stats - return timer statistics
1062 struct sockaddr_in *srcadr,
1063 struct interface *inter,
1064 struct req_pkt *inpkt
1067 register struct info_timer_stats *ts;
1070 * Importations from the timer module
1072 extern u_long timer_timereset;
1073 extern u_long timer_overflows;
1074 extern u_long timer_xmtcalls;
1076 ts = (struct info_timer_stats *)prepare_pkt(srcadr, inter, inpkt,
1077 sizeof(struct info_timer_stats));
1079 ts->timereset = htonl((u_int32)(current_time - timer_timereset));
1080 ts->alarms = htonl((u_int32)alarm_overflow);
1081 ts->overflows = htonl((u_int32)timer_overflows);
1082 ts->xmtcalls = htonl((u_int32)timer_xmtcalls);
1090 * loop_info - return the current state of the loop filter
1094 struct sockaddr_in *srcadr,
1095 struct interface *inter,
1096 struct req_pkt *inpkt
1099 register struct info_loop *li;
1103 * Importations from the loop filter module
1105 extern double last_offset;
1106 extern double drift_comp;
1107 extern int tc_counter;
1108 extern u_long last_time;
1110 li = (struct info_loop *)prepare_pkt(srcadr, inter, inpkt,
1111 sizeof(struct info_loop));
1113 DTOLFP(last_offset, <mp);
1114 HTONL_FP(<mp, &li->last_offset);
1115 DTOLFP(drift_comp * 1e6, <mp);
1116 HTONL_FP(<mp, &li->drift_comp);
1117 li->compliance = htonl((u_int32)(tc_counter));
1118 li->watchdog_timer = htonl((u_int32)(current_time - last_time));
1126 * do_conf - add a peer to the configuration list
1130 struct sockaddr_in *srcadr,
1131 struct interface *inter,
1132 struct req_pkt *inpkt
1136 register struct conf_peer *cp;
1138 struct sockaddr_in peeraddr;
1141 * Do a check of everything to see that it looks
1142 * okay. If not, complain about it. Note we are
1145 items = INFO_NITEMS(inpkt->err_nitems);
1146 cp = (struct conf_peer *)inpkt->data;
1149 while (items-- > 0 && !fl) {
1150 if (((cp->version) > NTP_VERSION)
1151 || ((cp->version) < NTP_OLDVERSION))
1153 if (cp->hmode != MODE_ACTIVE
1154 && cp->hmode != MODE_CLIENT
1155 && cp->hmode != MODE_BROADCAST)
1157 if (cp->flags & ~(CONF_FLAG_AUTHENABLE | CONF_FLAG_PREFER |
1158 CONF_FLAG_NOSELECT | CONF_FLAG_BURST | CONF_FLAG_IBURST |
1165 msyslog(LOG_ERR, "do_conf: fl is nonzero!");
1166 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1171 * Looks okay, try it out
1173 items = INFO_NITEMS(inpkt->err_nitems);
1174 cp = (struct conf_peer *)inpkt->data;
1175 memset((char *)&peeraddr, 0, sizeof(struct sockaddr_in));
1176 peeraddr.sin_family = AF_INET;
1177 peeraddr.sin_port = htons(NTP_PORT);
1180 * Make sure the address is valid
1184 !ISREFCLOCKADR(&peeraddr) &&
1186 ISBADADR(&peeraddr)) {
1188 msyslog(LOG_ERR, "do_conf: !ISREFCLOCK && ISBADADR");
1190 msyslog(LOG_ERR, "do_conf: ISBADADR");
1192 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1196 while (items-- > 0) {
1198 if (cp->flags & CONF_FLAG_AUTHENABLE)
1199 fl |= FLAG_AUTHENABLE;
1200 if (cp->flags & CONF_FLAG_PREFER)
1202 if (cp->flags & CONF_FLAG_NOSELECT)
1203 fl |= FLAG_NOSELECT;
1204 if (cp->flags & CONF_FLAG_BURST)
1206 if (cp->flags & CONF_FLAG_IBURST)
1208 if (cp->flags & CONF_FLAG_SKEY)
1210 peeraddr.sin_addr.s_addr = cp->peeraddr;
1211 /* XXX W2DO? minpoll/maxpoll arguments ??? */
1212 if (peer_config(&peeraddr, any_interface, cp->hmode,
1213 cp->version, cp->minpoll, cp->maxpoll, fl, cp->ttl,
1214 cp->keyid, cp->keystr) == 0) {
1215 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1221 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1226 * dns_a - Snarf DNS info for an association ID
1230 struct sockaddr_in *srcadr,
1231 struct interface *inter,
1232 struct req_pkt *inpkt
1235 register struct info_dns_assoc *dp;
1237 struct sockaddr_in peeraddr;
1240 * Do a check of everything to see that it looks
1241 * okay. If not, complain about it. Note we are
1244 items = INFO_NITEMS(inpkt->err_nitems);
1245 dp = (struct info_dns_assoc *)inpkt->data;
1248 * Looks okay, try it out
1250 items = INFO_NITEMS(inpkt->err_nitems);
1251 dp = (struct info_dns_assoc *)inpkt->data;
1252 memset((char *)&peeraddr, 0, sizeof(struct sockaddr_in));
1253 peeraddr.sin_family = AF_INET;
1254 peeraddr.sin_port = htons(NTP_PORT);
1257 * Make sure the address is valid
1261 !ISREFCLOCKADR(&peeraddr) &&
1263 ISBADADR(&peeraddr)) {
1265 msyslog(LOG_ERR, "dns_a: !ISREFCLOCK && ISBADADR");
1267 msyslog(LOG_ERR, "dns_a: ISBADADR");
1269 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1273 while (items-- > 0) {
1279 associd = dp->associd;
1280 peer = findpeerbyassoc(associd);
1281 if (peer == 0 || peer->flags & FLAG_REFCLOCK) {
1282 msyslog(LOG_ERR, "dns_a: %s",
1285 : "peer->flags & FLAG_REFCLOCK");
1288 peeraddr.sin_addr.s_addr = dp->peeraddr;
1289 for (hnl = 0; dp->hostname[hnl] && hnl < sizeof dp->hostname; ++hnl) ;
1290 if (hnl >= sizeof dp->hostname) {
1291 msyslog(LOG_ERR, "dns_a: hnl (%ld) >= %ld",
1292 (long)hnl, (long)sizeof dp->hostname);
1296 msyslog(LOG_INFO, "dns_a: <%s> for %s, AssocID %d, bogon %d",
1297 dp->hostname, inet_ntoa(peeraddr.sin_addr), associd,
1301 /* If it didn't work */
1302 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1307 crypto_public(peer, dp->hostname);
1315 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1320 * do_unconf - remove a peer from the configuration list
1324 struct sockaddr_in *srcadr,
1325 struct interface *inter,
1326 struct req_pkt *inpkt
1329 register struct conf_unpeer *cp;
1331 register struct peer *peer;
1332 struct sockaddr_in peeraddr;
1336 * This is a bit unstructured, but I like to be careful.
1337 * We check to see that every peer exists and is actually
1338 * configured. If so, we remove them. If not, we return
1341 peeraddr.sin_family = AF_INET;
1342 peeraddr.sin_port = htons(NTP_PORT);
1344 items = INFO_NITEMS(inpkt->err_nitems);
1345 cp = (struct conf_unpeer *)inpkt->data;
1348 while (items-- > 0 && !bad) {
1349 peeraddr.sin_addr.s_addr = cp->peeraddr;
1351 peer = (struct peer *)0;
1353 peer = findexistingpeer(&peeraddr, peer, -1);
1354 if (peer == (struct peer *)0)
1356 if (peer->flags & FLAG_CONFIG)
1365 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1370 * Now do it in earnest.
1373 items = INFO_NITEMS(inpkt->err_nitems);
1374 cp = (struct conf_unpeer *)inpkt->data;
1375 while (items-- > 0) {
1376 peeraddr.sin_addr.s_addr = cp->peeraddr;
1377 peer_unconfig(&peeraddr, (struct interface *)0, -1);
1381 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1386 * set_sys_flag - set system flags
1390 struct sockaddr_in *srcadr,
1391 struct interface *inter,
1392 struct req_pkt *inpkt
1395 setclr_flags(srcadr, inter, inpkt, 1);
1400 * clr_sys_flag - clear system flags
1404 struct sockaddr_in *srcadr,
1405 struct interface *inter,
1406 struct req_pkt *inpkt
1409 setclr_flags(srcadr, inter, inpkt, 0);
1414 * setclr_flags - do the grunge work of flag setting/clearing
1418 struct sockaddr_in *srcadr,
1419 struct interface *inter,
1420 struct req_pkt *inpkt,
1424 register u_int flags;
1426 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
1427 msyslog(LOG_ERR, "setclr_flags: err_nitems > 1");
1428 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1432 flags = ((struct conf_sys_flags *)inpkt->data)->flags;
1434 if (flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
1435 SYS_FLAG_NTP | SYS_FLAG_KERNEL | SYS_FLAG_MONITOR |
1436 SYS_FLAG_FILEGEN)) {
1437 msyslog(LOG_ERR, "setclr_flags: extra flags: %#x",
1438 flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
1439 SYS_FLAG_NTP | SYS_FLAG_KERNEL |
1440 SYS_FLAG_MONITOR | SYS_FLAG_FILEGEN));
1441 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1445 if (flags & SYS_FLAG_BCLIENT)
1446 proto_config(PROTO_BROADCLIENT, set, 0.);
1447 if (flags & SYS_FLAG_PPS)
1448 proto_config(PROTO_PPS, set, 0.);
1449 if (flags & SYS_FLAG_NTP)
1450 proto_config(PROTO_NTP, set, 0.);
1451 if (flags & SYS_FLAG_KERNEL)
1452 proto_config(PROTO_KERNEL, set, 0.);
1453 if (flags & SYS_FLAG_MONITOR)
1454 proto_config(PROTO_MONITOR, set, 0.);
1455 if (flags & SYS_FLAG_FILEGEN)
1456 proto_config(PROTO_FILEGEN, set, 0.);
1457 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1462 * list_restrict - return the restrict list
1466 struct sockaddr_in *srcadr,
1467 struct interface *inter,
1468 struct req_pkt *inpkt
1471 register struct info_restrict *ir;
1472 register struct restrictlist *rl;
1473 extern struct restrictlist *restrictlist;
1477 printf("wants peer list summary\n");
1480 ir = (struct info_restrict *)prepare_pkt(srcadr, inter, inpkt,
1481 sizeof(struct info_restrict));
1482 for (rl = restrictlist; rl != 0 && ir != 0; rl = rl->next) {
1483 ir->addr = htonl(rl->addr);
1484 ir->mask = htonl(rl->mask);
1485 ir->count = htonl((u_int32)rl->count);
1486 ir->flags = htons(rl->flags);
1487 ir->mflags = htons(rl->mflags);
1488 ir = (struct info_restrict *)more_pkt();
1496 * do_resaddflags - add flags to a restrict entry (or create one)
1500 struct sockaddr_in *srcadr,
1501 struct interface *inter,
1502 struct req_pkt *inpkt
1505 do_restrict(srcadr, inter, inpkt, RESTRICT_FLAGS);
1511 * do_ressubflags - remove flags from a restrict entry
1515 struct sockaddr_in *srcadr,
1516 struct interface *inter,
1517 struct req_pkt *inpkt
1520 do_restrict(srcadr, inter, inpkt, RESTRICT_UNFLAG);
1525 * do_unrestrict - remove a restrict entry from the list
1529 struct sockaddr_in *srcadr,
1530 struct interface *inter,
1531 struct req_pkt *inpkt
1534 do_restrict(srcadr, inter, inpkt, RESTRICT_REMOVE);
1542 * do_restrict - do the dirty stuff of dealing with restrictions
1546 struct sockaddr_in *srcadr,
1547 struct interface *inter,
1548 struct req_pkt *inpkt,
1552 register struct conf_restrict *cr;
1554 struct sockaddr_in matchaddr;
1555 struct sockaddr_in matchmask;
1559 * Do a check of the flags to make sure that only
1560 * the NTPPORT flag is set, if any. If not, complain
1561 * about it. Note we are very picky here.
1563 items = INFO_NITEMS(inpkt->err_nitems);
1564 cr = (struct conf_restrict *)inpkt->data;
1567 while (items-- > 0 && !bad) {
1568 if (cr->mflags & ~(RESM_NTPONLY))
1570 if (cr->flags & ~(RES_ALLFLAGS))
1572 if (cr->addr == htonl(INADDR_ANY) && cr->mask != htonl(INADDR_ANY))
1578 msyslog(LOG_ERR, "do_restrict: bad = %#x", bad);
1579 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1584 * Looks okay, try it out
1586 items = INFO_NITEMS(inpkt->err_nitems);
1587 cr = (struct conf_restrict *)inpkt->data;
1588 memset((char *)&matchaddr, 0, sizeof(struct sockaddr_in));
1589 memset((char *)&matchmask, 0, sizeof(struct sockaddr_in));
1590 matchaddr.sin_family = AF_INET;
1591 matchmask.sin_family = AF_INET;
1593 while (items-- > 0) {
1594 matchaddr.sin_addr.s_addr = cr->addr;
1595 matchmask.sin_addr.s_addr = cr->mask;
1596 hack_restrict(op, &matchaddr, &matchmask, cr->mflags,
1601 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1606 * mon_getlist - return monitor data
1610 struct sockaddr_in *srcadr,
1611 struct interface *inter,
1612 struct req_pkt *inpkt
1615 register struct info_monitor *im;
1616 register struct mon_data *md;
1617 extern struct mon_data mon_mru_list;
1618 extern int mon_enabled;
1622 printf("wants monitor 0 list\n");
1625 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1629 im = (struct info_monitor *)prepare_pkt(srcadr, inter, inpkt,
1630 sizeof(struct info_monitor));
1631 for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0;
1632 md = md->mru_next) {
1633 im->lasttime = htonl((u_int32)(current_time - md->lasttime));
1634 im->firsttime = htonl((u_int32)(current_time - md->firsttime));
1636 im->lastdrop = htonl((u_int32)(current_time - md->lastdrop));
1639 im->count = htonl((u_int32)(md->count));
1640 im->addr = md->rmtadr;
1641 im->port = md->rmtport;
1642 im->mode = md->mode;
1643 im->version = md->version;
1644 im = (struct info_monitor *)more_pkt();
1650 * mon_getlist - return monitor data
1654 struct sockaddr_in *srcadr,
1655 struct interface *inter,
1656 struct req_pkt *inpkt
1659 register struct info_monitor_1 *im;
1660 register struct mon_data *md;
1661 extern struct mon_data mon_mru_list;
1662 extern int mon_enabled;
1666 printf("wants monitor 1 list\n");
1669 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1673 im = (struct info_monitor_1 *)prepare_pkt(srcadr, inter, inpkt,
1674 sizeof(struct info_monitor_1));
1675 for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0;
1676 md = md->mru_next) {
1677 im->lasttime = htonl((u_int32)(current_time - md->lasttime));
1678 im->firsttime = htonl((u_int32)(current_time - md->firsttime));
1680 im->lastdrop = htonl((u_int32)(current_time - md->lastdrop));
1683 im->count = htonl((u_int32)md->count);
1684 im->addr = md->rmtadr;
1686 (md->cast_flags == MDF_BCAST)
1687 ? md->interface->bcast.sin_addr.s_addr
1689 ? (md->interface->sin.sin_addr.s_addr
1690 ? md->interface->sin.sin_addr.s_addr
1691 : md->interface->bcast.sin_addr.s_addr
1694 im->flags = md->cast_flags;
1695 im->port = md->rmtport;
1696 im->mode = md->mode;
1697 im->version = md->version;
1698 im = (struct info_monitor_1 *)more_pkt();
1704 * Module entry points and the flags they correspond with
1706 struct reset_entry {
1707 int flag; /* flag this corresponds to */
1708 void (*handler) P((void)); /* routine to handle request */
1711 struct reset_entry reset_entries[] = {
1712 { RESET_FLAG_ALLPEERS, peer_all_reset },
1713 { RESET_FLAG_IO, io_clr_stats },
1714 { RESET_FLAG_SYS, proto_clr_stats },
1715 { RESET_FLAG_MEM, peer_clr_stats },
1716 { RESET_FLAG_TIMER, timer_clr_stats },
1717 { RESET_FLAG_AUTH, reset_auth_stats },
1718 { RESET_FLAG_CTL, ctl_clr_stats },
1723 * reset_stats - reset statistic counters here and there
1727 struct sockaddr_in *srcadr,
1728 struct interface *inter,
1729 struct req_pkt *inpkt
1733 struct reset_entry *rent;
1735 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
1736 msyslog(LOG_ERR, "reset_stats: err_nitems > 1");
1737 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1741 flags = ((struct reset_flags *)inpkt->data)->flags;
1743 if (flags & ~RESET_ALLFLAGS) {
1744 msyslog(LOG_ERR, "reset_stats: reset leaves %#lx",
1745 flags & ~RESET_ALLFLAGS);
1746 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1750 for (rent = reset_entries; rent->flag != 0; rent++) {
1751 if (flags & rent->flag)
1754 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1759 * reset_peer - clear a peer's statistics
1763 struct sockaddr_in *srcadr,
1764 struct interface *inter,
1765 struct req_pkt *inpkt
1768 register struct conf_unpeer *cp;
1770 register struct peer *peer;
1771 struct sockaddr_in peeraddr;
1775 * We check first to see that every peer exists. If not,
1776 * we return an error.
1778 peeraddr.sin_family = AF_INET;
1779 peeraddr.sin_port = htons(NTP_PORT);
1781 items = INFO_NITEMS(inpkt->err_nitems);
1782 cp = (struct conf_unpeer *)inpkt->data;
1785 while (items-- > 0 && !bad) {
1786 peeraddr.sin_addr.s_addr = cp->peeraddr;
1787 peer = findexistingpeer(&peeraddr, (struct peer *)0, -1);
1788 if (peer == (struct peer *)0)
1794 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1799 * Now do it in earnest.
1802 items = INFO_NITEMS(inpkt->err_nitems);
1803 cp = (struct conf_unpeer *)inpkt->data;
1804 while (items-- > 0) {
1805 peeraddr.sin_addr.s_addr = cp->peeraddr;
1806 peer = findexistingpeer(&peeraddr, (struct peer *)0, -1);
1809 peer = findexistingpeer(&peeraddr, (struct peer *)peer, -1);
1814 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1819 * do_key_reread - reread the encryption key file
1823 struct sockaddr_in *srcadr,
1824 struct interface *inter,
1825 struct req_pkt *inpkt
1829 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1834 * trust_key - make one or more keys trusted
1838 struct sockaddr_in *srcadr,
1839 struct interface *inter,
1840 struct req_pkt *inpkt
1843 do_trustkey(srcadr, inter, inpkt, 1);
1848 * untrust_key - make one or more keys untrusted
1852 struct sockaddr_in *srcadr,
1853 struct interface *inter,
1854 struct req_pkt *inpkt
1857 do_trustkey(srcadr, inter, inpkt, 0);
1862 * do_trustkey - make keys either trustable or untrustable
1866 struct sockaddr_in *srcadr,
1867 struct interface *inter,
1868 struct req_pkt *inpkt,
1872 register u_long *kp;
1875 items = INFO_NITEMS(inpkt->err_nitems);
1876 kp = (u_long *)inpkt->data;
1877 while (items-- > 0) {
1878 authtrust(*kp, trust);
1882 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1887 * get_auth_info - return some stats concerning the authentication module
1891 struct sockaddr_in *srcadr,
1892 struct interface *inter,
1893 struct req_pkt *inpkt
1896 register struct info_auth *ia;
1899 * Importations from the authentication module
1901 extern u_long authnumkeys;
1902 extern int authnumfreekeys;
1903 extern u_long authkeylookups;
1904 extern u_long authkeynotfound;
1905 extern u_long authencryptions;
1906 extern u_long authdecryptions;
1907 extern u_long authkeyuncached;
1908 extern u_long authkeyexpired;
1910 ia = (struct info_auth *)prepare_pkt(srcadr, inter, inpkt,
1911 sizeof(struct info_auth));
1913 ia->numkeys = htonl((u_int32)authnumkeys);
1914 ia->numfreekeys = htonl((u_int32)authnumfreekeys);
1915 ia->keylookups = htonl((u_int32)authkeylookups);
1916 ia->keynotfound = htonl((u_int32)authkeynotfound);
1917 ia->encryptions = htonl((u_int32)authencryptions);
1918 ia->decryptions = htonl((u_int32)authdecryptions);
1919 ia->keyuncached = htonl((u_int32)authkeyuncached);
1920 ia->expired = htonl((u_int32)authkeyexpired);
1921 ia->timereset = htonl((u_int32)(current_time - auth_timereset));
1930 * reset_auth_stats - reset the authentication stat counters. Done here
1931 * to keep ntp-isms out of the authentication module
1934 reset_auth_stats(void)
1937 * Importations from the authentication module
1939 extern u_long authkeylookups;
1940 extern u_long authkeynotfound;
1941 extern u_long authencryptions;
1942 extern u_long authdecryptions;
1943 extern u_long authkeyuncached;
1946 authkeynotfound = 0;
1947 authencryptions = 0;
1948 authdecryptions = 0;
1949 authkeyuncached = 0;
1950 auth_timereset = current_time;
1955 * req_get_traps - return information about current trap holders
1959 struct sockaddr_in *srcadr,
1960 struct interface *inter,
1961 struct req_pkt *inpkt
1964 register struct info_trap *it;
1965 register struct ctl_trap *tr;
1969 * Imported from the control module
1971 extern struct ctl_trap ctl_trap[];
1972 extern int num_ctl_traps;
1974 if (num_ctl_traps == 0) {
1975 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1979 it = (struct info_trap *)prepare_pkt(srcadr, inter, inpkt,
1980 sizeof(struct info_trap));
1982 for (i = 0, tr = ctl_trap; i < CTL_MAXTRAPS; i++, tr++) {
1983 if (tr->tr_flags & TRAP_INUSE) {
1984 if (tr->tr_localaddr == any_interface)
1985 it->local_address = 0;
1988 = NSRCADR(&tr->tr_localaddr->sin);
1989 it->trap_address = NSRCADR(&tr->tr_addr);
1990 it->trap_port = NSRCPORT(&tr->tr_addr);
1991 it->sequence = htons(tr->tr_sequence);
1992 it->settime = htonl((u_int32)(current_time - tr->tr_settime));
1993 it->origtime = htonl((u_int32)(current_time - tr->tr_origtime));
1994 it->resets = htonl((u_int32)tr->tr_resets);
1995 it->flags = htonl((u_int32)tr->tr_flags);
1996 it = (struct info_trap *)more_pkt();
2004 * req_set_trap - configure a trap
2008 struct sockaddr_in *srcadr,
2009 struct interface *inter,
2010 struct req_pkt *inpkt
2013 do_setclr_trap(srcadr, inter, inpkt, 1);
2019 * req_clr_trap - unconfigure a trap
2023 struct sockaddr_in *srcadr,
2024 struct interface *inter,
2025 struct req_pkt *inpkt
2028 do_setclr_trap(srcadr, inter, inpkt, 0);
2034 * do_setclr_trap - do the grunge work of (un)configuring a trap
2038 struct sockaddr_in *srcadr,
2039 struct interface *inter,
2040 struct req_pkt *inpkt,
2044 register struct conf_trap *ct;
2045 register struct interface *linter;
2047 struct sockaddr_in laddr;
2050 * Prepare sockaddr_in structure
2052 memset((char *)&laddr, 0, sizeof laddr);
2053 laddr.sin_family = AF_INET;
2054 laddr.sin_port = ntohs(NTP_PORT);
2057 * Restrict ourselves to one item only. This eliminates
2058 * the error reporting problem.
2060 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2061 msyslog(LOG_ERR, "do_setclr_trap: err_nitems > 1");
2062 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2065 ct = (struct conf_trap *)inpkt->data;
2068 * Look for the local interface. If none, use the default.
2070 if (ct->local_address == 0) {
2071 linter = any_interface;
2073 laddr.sin_addr.s_addr = ct->local_address;
2074 linter = findinterface(&laddr);
2075 if (linter == NULL) {
2076 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2081 laddr.sin_addr.s_addr = ct->trap_address;
2082 if (ct->trap_port != 0)
2083 laddr.sin_port = ct->trap_port;
2085 laddr.sin_port = htons(TRAPPORT);
2088 res = ctlsettrap(&laddr, linter, 0,
2089 INFO_VERSION(inpkt->rm_vn_mode));
2091 res = ctlclrtrap(&laddr, linter, 0);
2095 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2097 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2105 * set_request_keyid - set the keyid used to authenticate requests
2109 struct sockaddr_in *srcadr,
2110 struct interface *inter,
2111 struct req_pkt *inpkt
2117 * Restrict ourselves to one item only.
2119 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2120 msyslog(LOG_ERR, "set_request_keyid: err_nitems > 1");
2121 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2125 keyid = ntohl(*((u_int32 *)(inpkt->data)));
2126 info_auth_keyid = keyid;
2127 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2133 * set_control_keyid - set the keyid used to authenticate requests
2137 struct sockaddr_in *srcadr,
2138 struct interface *inter,
2139 struct req_pkt *inpkt
2143 extern keyid_t ctl_auth_keyid;
2146 * Restrict ourselves to one item only.
2148 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2149 msyslog(LOG_ERR, "set_control_keyid: err_nitems > 1");
2150 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2154 keyid = ntohl(*((u_int32 *)(inpkt->data)));
2155 ctl_auth_keyid = keyid;
2156 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2162 * get_ctl_stats - return some stats concerning the control message module
2166 struct sockaddr_in *srcadr,
2167 struct interface *inter,
2168 struct req_pkt *inpkt
2171 register struct info_control *ic;
2174 * Importations from the control module
2176 extern u_long ctltimereset;
2177 extern u_long numctlreq;
2178 extern u_long numctlbadpkts;
2179 extern u_long numctlresponses;
2180 extern u_long numctlfrags;
2181 extern u_long numctlerrors;
2182 extern u_long numctltooshort;
2183 extern u_long numctlinputresp;
2184 extern u_long numctlinputfrag;
2185 extern u_long numctlinputerr;
2186 extern u_long numctlbadoffset;
2187 extern u_long numctlbadversion;
2188 extern u_long numctldatatooshort;
2189 extern u_long numctlbadop;
2190 extern u_long numasyncmsgs;
2192 ic = (struct info_control *)prepare_pkt(srcadr, inter, inpkt,
2193 sizeof(struct info_control));
2195 ic->ctltimereset = htonl((u_int32)(current_time - ctltimereset));
2196 ic->numctlreq = htonl((u_int32)numctlreq);
2197 ic->numctlbadpkts = htonl((u_int32)numctlbadpkts);
2198 ic->numctlresponses = htonl((u_int32)numctlresponses);
2199 ic->numctlfrags = htonl((u_int32)numctlfrags);
2200 ic->numctlerrors = htonl((u_int32)numctlerrors);
2201 ic->numctltooshort = htonl((u_int32)numctltooshort);
2202 ic->numctlinputresp = htonl((u_int32)numctlinputresp);
2203 ic->numctlinputfrag = htonl((u_int32)numctlinputfrag);
2204 ic->numctlinputerr = htonl((u_int32)numctlinputerr);
2205 ic->numctlbadoffset = htonl((u_int32)numctlbadoffset);
2206 ic->numctlbadversion = htonl((u_int32)numctlbadversion);
2207 ic->numctldatatooshort = htonl((u_int32)numctldatatooshort);
2208 ic->numctlbadop = htonl((u_int32)numctlbadop);
2209 ic->numasyncmsgs = htonl((u_int32)numasyncmsgs);
2218 * get_kernel_info - get kernel pll/pps information
2222 struct sockaddr_in *srcadr,
2223 struct interface *inter,
2224 struct req_pkt *inpkt
2227 register struct info_kernel *ik;
2231 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2235 memset((char *)&ntx, 0, sizeof(ntx));
2236 if (ntp_adjtime(&ntx) < 0)
2237 msyslog(LOG_ERR, "get_kernel_info: ntp_adjtime() failed: %m");
2238 ik = (struct info_kernel *)prepare_pkt(srcadr, inter, inpkt,
2239 sizeof(struct info_kernel));
2244 ik->offset = htonl((u_int32)ntx.offset);
2245 ik->freq = htonl((u_int32)ntx.freq);
2246 ik->maxerror = htonl((u_int32)ntx.maxerror);
2247 ik->esterror = htonl((u_int32)ntx.esterror);
2248 ik->status = htons(ntx.status);
2249 ik->constant = htonl((u_int32)ntx.constant);
2250 ik->precision = htonl((u_int32)ntx.precision);
2251 ik->tolerance = htonl((u_int32)ntx.tolerance);
2256 ik->ppsfreq = htonl((u_int32)ntx.ppsfreq);
2257 ik->jitter = htonl((u_int32)ntx.jitter);
2258 ik->shift = htons(ntx.shift);
2259 ik->stabil = htonl((u_int32)ntx.stabil);
2260 ik->jitcnt = htonl((u_int32)ntx.jitcnt);
2261 ik->calcnt = htonl((u_int32)ntx.calcnt);
2262 ik->errcnt = htonl((u_int32)ntx.errcnt);
2263 ik->stbcnt = htonl((u_int32)ntx.stbcnt);
2268 #endif /* KERNEL_PLL */
2273 * get_clock_info - get info about a clock
2277 struct sockaddr_in *srcadr,
2278 struct interface *inter,
2279 struct req_pkt *inpkt
2282 register struct info_clock *ic;
2283 register u_int32 *clkaddr;
2285 struct refclockstat clock_stat;
2286 struct sockaddr_in addr;
2289 memset((char *)&addr, 0, sizeof addr);
2290 addr.sin_family = AF_INET;
2291 addr.sin_port = htons(NTP_PORT);
2292 items = INFO_NITEMS(inpkt->err_nitems);
2293 clkaddr = (u_int32 *) inpkt->data;
2295 ic = (struct info_clock *)prepare_pkt(srcadr, inter, inpkt,
2296 sizeof(struct info_clock));
2298 while (items-- > 0) {
2299 addr.sin_addr.s_addr = *clkaddr++;
2300 if (!ISREFCLOCKADR(&addr) ||
2301 findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2302 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2306 clock_stat.kv_list = (struct ctl_var *)0;
2308 refclock_control(&addr, (struct refclockstat *)0, &clock_stat);
2310 ic->clockadr = addr.sin_addr.s_addr;
2311 ic->type = clock_stat.type;
2312 ic->flags = clock_stat.flags;
2313 ic->lastevent = clock_stat.lastevent;
2314 ic->currentstatus = clock_stat.currentstatus;
2315 ic->polls = htonl((u_int32)clock_stat.polls);
2316 ic->noresponse = htonl((u_int32)clock_stat.noresponse);
2317 ic->badformat = htonl((u_int32)clock_stat.badformat);
2318 ic->baddata = htonl((u_int32)clock_stat.baddata);
2319 ic->timestarted = htonl((u_int32)clock_stat.timereset);
2320 DTOLFP(clock_stat.fudgetime1, <mp);
2321 HTONL_FP(<mp, &ic->fudgetime1);
2322 DTOLFP(clock_stat.fudgetime1, <mp);
2323 HTONL_FP(<mp, &ic->fudgetime2);
2324 ic->fudgeval1 = htonl((u_int32)clock_stat.fudgeval1);
2325 ic->fudgeval2 = htonl((u_int32)clock_stat.fudgeval2);
2327 free_varlist(clock_stat.kv_list);
2329 ic = (struct info_clock *)more_pkt();
2337 * set_clock_fudge - get a clock's fudge factors
2341 struct sockaddr_in *srcadr,
2342 struct interface *inter,
2343 struct req_pkt *inpkt
2346 register struct conf_fudge *cf;
2348 struct refclockstat clock_stat;
2349 struct sockaddr_in addr;
2352 memset((char *)&addr, 0, sizeof addr);
2353 memset((char *)&clock_stat, 0, sizeof clock_stat);
2354 addr.sin_family = AF_INET;
2355 addr.sin_port = htons(NTP_PORT);
2356 items = INFO_NITEMS(inpkt->err_nitems);
2357 cf = (struct conf_fudge *) inpkt->data;
2359 while (items-- > 0) {
2360 addr.sin_addr.s_addr = cf->clockadr;
2361 if (!ISREFCLOCKADR(&addr) ||
2362 findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2363 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2367 switch(ntohl(cf->which)) {
2369 NTOHL_FP(&cf->fudgetime, <mp);
2370 LFPTOD(<mp, clock_stat.fudgetime1);
2371 clock_stat.haveflags = CLK_HAVETIME1;
2374 NTOHL_FP(&cf->fudgetime, <mp);
2375 LFPTOD(<mp, clock_stat.fudgetime2);
2376 clock_stat.haveflags = CLK_HAVETIME2;
2379 clock_stat.fudgeval1 = ntohl(cf->fudgeval_flags);
2380 clock_stat.haveflags = CLK_HAVEVAL1;
2383 clock_stat.fudgeval2 = ntohl(cf->fudgeval_flags);
2384 clock_stat.haveflags = CLK_HAVEVAL2;
2387 clock_stat.flags = (u_char) ntohl(cf->fudgeval_flags) & 0xf;
2388 clock_stat.haveflags =
2389 (CLK_HAVEFLAG1|CLK_HAVEFLAG2|CLK_HAVEFLAG3|CLK_HAVEFLAG4);
2392 msyslog(LOG_ERR, "set_clock_fudge: default!");
2393 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2397 refclock_control(&addr, &clock_stat, (struct refclockstat *)0);
2400 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2406 * get_clkbug_info - get debugging info about a clock
2410 struct sockaddr_in *srcadr,
2411 struct interface *inter,
2412 struct req_pkt *inpkt
2416 register struct info_clkbug *ic;
2417 register u_int32 *clkaddr;
2419 struct refclockbug bug;
2420 struct sockaddr_in addr;
2422 memset((char *)&addr, 0, sizeof addr);
2423 addr.sin_family = AF_INET;
2424 addr.sin_port = htons(NTP_PORT);
2425 items = INFO_NITEMS(inpkt->err_nitems);
2426 clkaddr = (u_int32 *) inpkt->data;
2428 ic = (struct info_clkbug *)prepare_pkt(srcadr, inter, inpkt,
2429 sizeof(struct info_clkbug));
2431 while (items-- > 0) {
2432 addr.sin_addr.s_addr = *clkaddr++;
2433 if (!ISREFCLOCKADR(&addr) ||
2434 findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2435 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2439 memset((char *)&bug, 0, sizeof bug);
2440 refclock_buginfo(&addr, &bug);
2441 if (bug.nvalues == 0 && bug.ntimes == 0) {
2442 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2446 ic->clockadr = addr.sin_addr.s_addr;
2448 if (i > NUMCBUGVALUES)
2450 ic->nvalues = (u_char)i;
2451 ic->svalues = htons((u_short) (bug.svalues & ((1<<i)-1)));
2453 ic->values[i] = htonl(bug.values[i]);
2456 if (i > NUMCBUGTIMES)
2458 ic->ntimes = (u_char)i;
2459 ic->stimes = htonl(bug.stimes);
2461 HTONL_FP(&bug.times[i], &ic->times[i]);
2464 ic = (struct info_clkbug *)more_pkt();