2 * ntp_request.c - respond to information requests
11 #include "ntp_request.h"
12 #include "ntp_control.h"
13 #include "ntp_refclock.h"
15 #include "ntp_stdlib.h"
20 #include <netinet/in.h>
21 #include <arpa/inet.h>
26 #include "ntp_syscall.h"
27 #endif /* KERNEL_PLL */
30 * Structure to hold request procedure information
35 #define NO_REQUEST (-1)
37 * Because we now have v6 addresses in the messages, we need to compensate
38 * for the larger size. Therefore, we introduce the alternate size to
39 * keep us friendly with older implementations. A little ugly.
41 static int client_v6_capable = 0; /* the client can handle longer messages */
43 #define v6sizeof(type) (client_v6_capable ? sizeof(type) : v4sizeof(type))
46 short request_code; /* defined request code */
47 short needs_auth; /* true when authentication needed */
48 short sizeofitem; /* size of request data item (older size)*/
49 short v6_sizeofitem; /* size of request data item (new size)*/
50 void (*handler) P((struct sockaddr_storage *, struct interface *,
51 struct req_pkt *)); /* routine to handle request */
55 * Universal request codes
57 static struct req_proc univ_codes[] = {
58 { NO_REQUEST, NOAUTH, 0, 0 }
61 static void req_ack P((struct sockaddr_storage *, struct interface *, struct req_pkt *, int));
62 static char * prepare_pkt P((struct sockaddr_storage *, struct interface *, struct req_pkt *, u_int));
63 static char * more_pkt P((void));
64 static void flush_pkt P((void));
65 static void peer_list P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
66 static void peer_list_sum P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
67 static void peer_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
68 static void peer_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
69 static void sys_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
70 static void sys_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
71 static void mem_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
72 static void io_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
73 static void timer_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
74 static void loop_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
75 static void do_conf P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
76 static void do_unconf P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
77 static void set_sys_flag P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
78 static void clr_sys_flag P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
79 static void setclr_flags P((struct sockaddr_storage *, struct interface *, struct req_pkt *, u_long));
80 static void list_restrict P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
81 static void do_resaddflags P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
82 static void do_ressubflags P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
83 static void do_unrestrict P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
84 static void do_restrict P((struct sockaddr_storage *, struct interface *, struct req_pkt *, int));
85 static void mon_getlist_0 P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
86 static void mon_getlist_1 P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
87 static void reset_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
88 static void reset_peer P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
89 static void do_key_reread P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
90 static void trust_key P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
91 static void untrust_key P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
92 static void do_trustkey P((struct sockaddr_storage *, struct interface *, struct req_pkt *, u_long));
93 static void get_auth_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
94 static void reset_auth_stats P((void));
95 static void req_get_traps P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
96 static void req_set_trap P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
97 static void req_clr_trap P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
98 static void do_setclr_trap P((struct sockaddr_storage *, struct interface *, struct req_pkt *, int));
99 static void set_request_keyid P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
100 static void set_control_keyid P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
101 static void get_ctl_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
103 static void get_kernel_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
104 #endif /* KERNEL_PLL */
106 static void get_clock_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
107 static void set_clock_fudge P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
108 #endif /* REFCLOCK */
110 static void get_clkbug_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
111 #endif /* REFCLOCK */
116 static struct req_proc ntp_codes[] = {
117 { REQ_PEER_LIST, NOAUTH, 0, 0, peer_list },
118 { REQ_PEER_LIST_SUM, NOAUTH, 0, 0, peer_list_sum },
119 { REQ_PEER_INFO, NOAUTH, v4sizeof(struct info_peer_list),
120 sizeof(struct info_peer_list), peer_info},
121 { REQ_PEER_STATS, NOAUTH, v4sizeof(struct info_peer_list),
122 sizeof(struct info_peer_list), peer_stats},
123 { REQ_SYS_INFO, NOAUTH, 0, 0, sys_info },
124 { REQ_SYS_STATS, NOAUTH, 0, 0, sys_stats },
125 { REQ_IO_STATS, NOAUTH, 0, 0, io_stats },
126 { REQ_MEM_STATS, NOAUTH, 0, 0, mem_stats },
127 { REQ_LOOP_INFO, NOAUTH, 0, 0, loop_info },
128 { REQ_TIMER_STATS, NOAUTH, 0, 0, timer_stats },
129 { REQ_CONFIG, AUTH, v4sizeof(struct conf_peer),
130 sizeof(struct conf_peer), do_conf },
131 { REQ_UNCONFIG, AUTH, v4sizeof(struct conf_unpeer),
132 sizeof(struct conf_unpeer), do_unconf },
133 { REQ_SET_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags),
134 sizeof(struct conf_sys_flags), set_sys_flag },
135 { REQ_CLR_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags),
136 sizeof(struct conf_sys_flags), clr_sys_flag },
137 { REQ_GET_RESTRICT, NOAUTH, 0, 0, list_restrict },
138 { REQ_RESADDFLAGS, AUTH, v4sizeof(struct conf_restrict),
139 sizeof(struct conf_restrict), do_resaddflags },
140 { REQ_RESSUBFLAGS, AUTH, v4sizeof(struct conf_restrict),
141 sizeof(struct conf_restrict), do_ressubflags },
142 { REQ_UNRESTRICT, AUTH, v4sizeof(struct conf_restrict),
143 sizeof(struct conf_restrict), do_unrestrict },
144 { REQ_MON_GETLIST, NOAUTH, 0, 0, mon_getlist_0 },
145 { REQ_MON_GETLIST_1, NOAUTH, 0, 0, mon_getlist_1 },
146 { REQ_RESET_STATS, AUTH, sizeof(struct reset_flags), 0, reset_stats },
147 { REQ_RESET_PEER, AUTH, v4sizeof(struct conf_unpeer),
148 sizeof(struct conf_unpeer), reset_peer },
149 { REQ_REREAD_KEYS, AUTH, 0, 0, do_key_reread },
150 { REQ_TRUSTKEY, AUTH, sizeof(u_long), sizeof(u_long), trust_key },
151 { REQ_UNTRUSTKEY, AUTH, sizeof(u_long), sizeof(u_long), untrust_key },
152 { REQ_AUTHINFO, NOAUTH, 0, 0, get_auth_info },
153 { REQ_TRAPS, NOAUTH, 0, 0, req_get_traps },
154 { REQ_ADD_TRAP, AUTH, v4sizeof(struct conf_trap),
155 sizeof(struct conf_trap), req_set_trap },
156 { REQ_CLR_TRAP, AUTH, v4sizeof(struct conf_trap),
157 sizeof(struct conf_trap), req_clr_trap },
158 { REQ_REQUEST_KEY, AUTH, sizeof(u_long), sizeof(u_long),
160 { REQ_CONTROL_KEY, AUTH, sizeof(u_long), sizeof(u_long),
162 { REQ_GET_CTLSTATS, NOAUTH, 0, 0, get_ctl_stats },
164 { REQ_GET_KERNEL, NOAUTH, 0, 0, get_kernel_info },
167 { REQ_GET_CLOCKINFO, NOAUTH, sizeof(u_int32), sizeof(u_int32),
169 { REQ_SET_CLKFUDGE, AUTH, sizeof(struct conf_fudge),
170 sizeof(struct conf_fudge), set_clock_fudge },
171 { REQ_GET_CLKBUGINFO, NOAUTH, sizeof(u_int32), sizeof(u_int32),
174 { NO_REQUEST, NOAUTH, 0, 0, 0 }
179 * Authentication keyid used to authenticate requests. Zero means we
180 * don't allow writing anything.
182 keyid_t info_auth_keyid;
185 * Statistic counters to keep track of requests and responses.
187 u_long numrequests; /* number of requests we've received */
188 u_long numresppkts; /* number of resp packets sent with data */
190 u_long errorcounter[INFO_ERR_AUTH+1]; /* lazy way to count errors, indexed */
191 /* by the error code */
194 * A hack. To keep the authentication module clear of ntp-ism's, we
195 * include a time reset variable for its stats here.
197 static u_long auth_timereset;
200 * Response packet used by these routines. Also some state information
201 * so that we can handle packet formatting within a common set of
202 * subroutines. Note we try to enter data in place whenever possible,
203 * but the need to set the more bit correctly means we occasionally
204 * use the extra buffer and copy.
206 static struct resp_pkt rpkt;
211 static int databytes;
212 static char exbuf[RESP_DATA_SIZE];
213 static int usingexbuf;
214 static struct sockaddr_storage *toaddr;
215 static struct interface *frominter;
218 * init_request - initialize request data
228 info_auth_keyid = 0; /* by default, can't do this */
230 for (i = 0; i < sizeof(errorcounter)/sizeof(errorcounter[0]); i++)
236 * req_ack - acknowledge request with no data
240 struct sockaddr_storage *srcadr,
241 struct interface *inter,
242 struct req_pkt *inpkt,
249 rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, 0, reqver);
250 rpkt.auth_seq = AUTH_SEQ(0, 0);
251 rpkt.implementation = inpkt->implementation;
252 rpkt.request = inpkt->request;
253 rpkt.err_nitems = ERR_NITEMS(errcode, 0);
254 rpkt.mbz_itemsize = MBZ_ITEMSIZE(0);
257 * send packet and bump counters
259 sendpkt(srcadr, inter, -1, (struct pkt *)&rpkt, RESP_HEADER_SIZE);
260 errorcounter[errcode]++;
265 * prepare_pkt - prepare response packet for transmission, return pointer
266 * to storage for data item.
270 struct sockaddr_storage *srcadr,
271 struct interface *inter,
278 printf("request: preparing pkt\n");
282 * Fill in the implementation, request and itemsize fields
283 * since these won't change.
285 rpkt.implementation = pkt->implementation;
286 rpkt.request = pkt->request;
287 rpkt.mbz_itemsize = MBZ_ITEMSIZE(structsize);
290 * Compute the static data needed to carry on.
296 itemsize = structsize;
301 * return the beginning of the packet buffer.
303 return &rpkt.data[0];
308 * more_pkt - return a data pointer for a new item.
314 * If we were using the extra buffer, send the packet.
319 printf("request: sending pkt\n");
321 rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, MORE_BIT, reqver);
322 rpkt.auth_seq = AUTH_SEQ(0, seqno);
323 rpkt.err_nitems = htons((u_short)nitems);
324 sendpkt(toaddr, frominter, -1, (struct pkt *)&rpkt,
325 RESP_HEADER_SIZE+databytes);
329 * Copy data out of exbuf into the packet.
331 memmove(&rpkt.data[0], exbuf, (unsigned)itemsize);
338 databytes += itemsize;
340 if (databytes + itemsize <= RESP_DATA_SIZE) {
343 printf("request: giving him more data\n");
346 * More room in packet. Give him the
349 return &rpkt.data[databytes];
352 * No room in packet. Give him the extra
353 * buffer unless this was the last in the sequence.
357 printf("request: into extra buffer\n");
370 * flush_pkt - we're done, return remaining information.
377 printf("request: flushing packet, %d items\n", nitems);
380 * Must send the last packet. If nothing in here and nothing
381 * has been sent, send an error saying no data to be found.
383 if (seqno == 0 && nitems == 0)
384 req_ack(toaddr, frominter, (struct req_pkt *)&rpkt,
387 rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, 0, reqver);
388 rpkt.auth_seq = AUTH_SEQ(0, seqno);
389 rpkt.err_nitems = htons((u_short)nitems);
390 sendpkt(toaddr, frominter, -1, (struct pkt *)&rpkt,
391 RESP_HEADER_SIZE+databytes);
399 * process_private - process private mode (7) packets
403 struct recvbuf *rbufp,
407 struct req_pkt *inpkt;
408 struct req_pkt_tail *tailinpkt;
409 struct sockaddr_storage *srcadr;
410 struct interface *inter;
411 struct req_proc *proc;
416 * Initialize pointers, for convenience
418 inpkt = (struct req_pkt *)&rbufp->recv_pkt;
419 srcadr = &rbufp->recv_srcadr;
420 inter = rbufp->dstadr;
424 printf("process_private: impl %d req %d\n",
425 inpkt->implementation, inpkt->request);
429 * Do some sanity checks on the packet. Return a format
433 if ( (++ec, ISRESPONSE(inpkt->rm_vn_mode))
434 || (++ec, ISMORE(inpkt->rm_vn_mode))
435 || (++ec, INFO_VERSION(inpkt->rm_vn_mode) > NTP_VERSION)
436 || (++ec, INFO_VERSION(inpkt->rm_vn_mode) < NTP_OLDVERSION)
437 || (++ec, INFO_SEQ(inpkt->auth_seq) != 0)
438 || (++ec, INFO_ERR(inpkt->err_nitems) != 0)
439 || (++ec, INFO_MBZ(inpkt->mbz_itemsize) != 0)
440 || (++ec, rbufp->recv_length < REQ_LEN_HDR)
442 msyslog(LOG_ERR, "process_private: INFO_ERR_FMT: test %d failed, pkt from %s", ec, stoa(srcadr));
443 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
447 reqver = INFO_VERSION(inpkt->rm_vn_mode);
450 * Get the appropriate procedure list to search.
452 if (inpkt->implementation == IMPL_UNIV)
454 else if ((inpkt->implementation == IMPL_XNTPD) ||
455 (inpkt->implementation == IMPL_XNTPD_OLD))
458 req_ack(srcadr, inter, inpkt, INFO_ERR_IMPL);
463 * Search the list for the request codes. If it isn't one
464 * we know, return an error.
466 while (proc->request_code != NO_REQUEST) {
467 if (proc->request_code == (short) inpkt->request)
471 if (proc->request_code == NO_REQUEST) {
472 req_ack(srcadr, inter, inpkt, INFO_ERR_REQ);
478 printf("found request in tables\n");
482 * If we need data, check to see if we have some. If we
483 * don't, check to see that there is none (picky, picky).
486 /* This part is a bit tricky, we want to be sure that the size
487 * returned is either the old or the new size. We also can find
488 * out if the client can accept both types of messages this way.
490 * Handle the exception of REQ_CONFIG. It can have two data sizes.
492 temp_size = INFO_ITEMSIZE(inpkt->mbz_itemsize);
493 if ((temp_size != proc->sizeofitem &&
494 temp_size != proc->v6_sizeofitem) &&
495 !(inpkt->implementation == IMPL_XNTPD &&
496 inpkt->request == REQ_CONFIG &&
497 temp_size == sizeof(struct old_conf_peer))) {
499 printf("process_private: wrong item size, received %d, should be %d or %d\n",
500 temp_size, proc->sizeofitem, proc->v6_sizeofitem);
501 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
504 if ((proc->sizeofitem != 0) &&
505 ((temp_size * INFO_NITEMS(inpkt->err_nitems)) >
506 (rbufp->recv_length - REQ_LEN_HDR))) {
508 printf("process_private: not enough data\n");
509 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
513 switch (inpkt->implementation) {
515 client_v6_capable = 1;
518 client_v6_capable = 0;
521 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
526 * If we need to authenticate, do so. Note that an
527 * authenticatable packet must include a mac field, must
528 * have used key info_auth_keyid and must have included
529 * a time stamp in the appropriate field. The time stamp
530 * must be within INFO_TS_MAXSKEW of the receive
533 if (proc->needs_auth && sys_authenticate) {
537 if (rbufp->recv_length < (int)((REQ_LEN_HDR +
538 (INFO_ITEMSIZE(inpkt->mbz_itemsize) *
539 INFO_NITEMS(inpkt->err_nitems))
540 + sizeof(struct req_pkt_tail)))) {
541 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
543 tailinpkt = (struct req_pkt_tail *)((char *)&rbufp->recv_pkt +
544 rbufp->recv_length - sizeof(struct req_pkt_tail));
547 * If this guy is restricted from doing this, don't let him
548 * If wrong key was used, or packet doesn't have mac, return.
550 if (!INFO_IS_AUTH(inpkt->auth_seq) || info_auth_keyid == 0
551 || ntohl(tailinpkt->keyid) != info_auth_keyid) {
554 printf("failed auth %d info_auth_keyid %lu pkt keyid %lu\n",
555 INFO_IS_AUTH(inpkt->auth_seq),
556 (u_long)info_auth_keyid,
557 (u_long)ntohl(tailinpkt->keyid));
559 "process_private: failed auth %d info_auth_keyid %lu pkt keyid %lu\n",
560 INFO_IS_AUTH(inpkt->auth_seq),
561 (u_long)info_auth_keyid,
562 (u_long)ntohl(tailinpkt->keyid));
564 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
567 if (rbufp->recv_length > REQ_LEN_MAC) {
570 printf("bad pkt length %d\n",
573 msyslog(LOG_ERR, "process_private: bad pkt length %d",
575 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
578 if (!mod_okay || !authhavekey(info_auth_keyid)) {
581 printf("failed auth mod_okay %d\n", mod_okay);
583 "process_private: failed auth mod_okay %d\n",
586 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
591 * calculate absolute time difference between xmit time stamp
592 * and receive time stamp. If too large, too bad.
594 NTOHL_FP(&tailinpkt->tstamp, &ftmp);
595 L_SUB(&ftmp, &rbufp->recv_time);
596 LFPTOD(&ftmp, dtemp);
597 if (fabs(dtemp) >= INFO_TS_MAXSKEW) {
599 * He's a loser. Tell him.
603 printf("xmit/rcv timestamp delta > INFO_TS_MAXSKEW\n");
605 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
610 * So far so good. See if decryption works out okay.
612 if (!authdecrypt(info_auth_keyid, (u_int32 *)inpkt,
613 rbufp->recv_length - sizeof(struct req_pkt_tail) +
614 REQ_LEN_HDR, sizeof(struct req_pkt_tail) - REQ_LEN_HDR)) {
617 printf("authdecrypt failed\n");
619 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
626 printf("process_private: all okay, into handler\n");
630 * Packet is okay. Call the handler to send him data.
632 (proc->handler)(srcadr, inter, inpkt);
637 * peer_list - send a list of the peers
641 struct sockaddr_storage *srcadr,
642 struct interface *inter,
643 struct req_pkt *inpkt
646 register struct info_peer_list *ip;
647 register struct peer *pp;
649 register int skip = 0;
651 ip = (struct info_peer_list *)prepare_pkt(srcadr, inter, inpkt,
652 v6sizeof(struct info_peer_list));
653 for (i = 0; i < HASH_SIZE && ip != 0; i++) {
655 while (pp != 0 && ip != 0) {
656 if (pp->srcadr.ss_family == AF_INET6) {
657 if (client_v6_capable) {
658 ip->addr6 = GET_INADDR6(pp->srcadr);
666 ip->addr = GET_INADDR(pp->srcadr);
667 if (client_v6_capable)
673 ip->port = NSRCPORT(&pp->srcadr);
674 ip->hmode = pp->hmode;
676 if (pp->flags & FLAG_CONFIG)
677 ip->flags |= INFO_FLAG_CONFIG;
679 ip->flags |= INFO_FLAG_SYSPEER;
680 if (pp->status == CTL_PST_SEL_SYNCCAND)
681 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
682 if (pp->status >= CTL_PST_SEL_SYSPEER)
683 ip->flags |= INFO_FLAG_SHORTLIST;
684 ip = (struct info_peer_list *)more_pkt();
694 * peer_list_sum - return extended peer list
698 struct sockaddr_storage *srcadr,
699 struct interface *inter,
700 struct req_pkt *inpkt
703 register struct info_peer_summary *ips;
704 register struct peer *pp;
711 printf("wants peer list summary\n");
713 ips = (struct info_peer_summary *)prepare_pkt(srcadr, inter, inpkt,
714 v6sizeof(struct info_peer_summary));
715 for (i = 0; i < HASH_SIZE && ips != 0; i++) {
717 while (pp != 0 && ips != 0) {
720 printf("sum: got one\n");
723 * Be careful here not to return v6 peers when we
726 if (pp->srcadr.ss_family == AF_INET6) {
727 if (client_v6_capable) {
728 ips->srcadr6 = GET_INADDR6(pp->srcadr);
730 ips->dstadr6 = GET_INADDR6(pp->dstadr->sin);
737 ips->srcadr = GET_INADDR(pp->srcadr);
738 if (client_v6_capable)
740 /* XXX PDM This code is buggy. Need to replace with a straightforward assignment */
741 ips->dstadr = (pp->processed) ?
742 pp->cast_flags == MDF_BCAST ?
743 GET_INADDR(pp->dstadr->bcast):
745 GET_INADDR(pp->dstadr->sin) ?
746 GET_INADDR(pp->dstadr->sin):
747 GET_INADDR(pp->dstadr->bcast):
748 1 : GET_INADDR(pp->dstadr->sin);
753 ips->srcport = NSRCPORT(&pp->srcadr);
754 ips->stratum = pp->stratum;
755 ips->hpoll = pp->hpoll;
756 ips->ppoll = pp->ppoll;
757 ips->reach = pp->reach;
760 ips->flags |= INFO_FLAG_SYSPEER;
761 if (pp->flags & FLAG_CONFIG)
762 ips->flags |= INFO_FLAG_CONFIG;
763 if (pp->flags & FLAG_REFCLOCK)
764 ips->flags |= INFO_FLAG_REFCLOCK;
765 if (pp->flags & FLAG_AUTHENABLE)
766 ips->flags |= INFO_FLAG_AUTHENABLE;
767 if (pp->flags & FLAG_PREFER)
768 ips->flags |= INFO_FLAG_PREFER;
769 if (pp->flags & FLAG_BURST)
770 ips->flags |= INFO_FLAG_BURST;
771 if (pp->status == CTL_PST_SEL_SYNCCAND)
772 ips->flags |= INFO_FLAG_SEL_CANDIDATE;
773 if (pp->status >= CTL_PST_SEL_SYSPEER)
774 ips->flags |= INFO_FLAG_SHORTLIST;
775 ips->hmode = pp->hmode;
776 ips->delay = HTONS_FP(DTOFP(pp->delay));
777 DTOLFP(pp->offset, <mp);
778 HTONL_FP(<mp, &ips->offset);
779 ips->dispersion = HTONS_FP(DTOUFP(pp->disp));
782 ips = (struct info_peer_summary *)more_pkt();
790 * peer_info - send information for one or more peers
794 struct sockaddr_storage *srcadr,
795 struct interface *inter,
796 struct req_pkt *inpkt
799 register struct info_peer_list *ipl;
800 register struct peer *pp;
801 register struct info_peer *ip;
804 struct sockaddr_storage addr;
805 extern struct peer *sys_peer;
808 memset((char *)&addr, 0, sizeof addr);
809 items = INFO_NITEMS(inpkt->err_nitems);
810 ipl = (struct info_peer_list *) inpkt->data;
812 ip = (struct info_peer *)prepare_pkt(srcadr, inter, inpkt,
813 v6sizeof(struct info_peer));
814 while (items-- > 0 && ip != 0) {
815 memset((char *)&addr, 0, sizeof(addr));
816 NSRCPORT(&addr) = ipl->port;
817 if (client_v6_capable && ipl->v6_flag != 0) {
818 addr.ss_family = AF_INET6;
819 GET_INADDR6(addr) = ipl->addr6;
821 addr.ss_family = AF_INET;
822 GET_INADDR(addr) = ipl->addr;
824 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
825 addr.ss_len = SOCKLEN(&addr);
828 if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0)
830 if (pp->srcadr.ss_family == AF_INET6) {
831 ip->dstadr6 = pp->cast_flags == MDF_BCAST ?
832 GET_INADDR6(pp->dstadr->bcast) :
833 GET_INADDR6(pp->dstadr->sin);
834 ip->srcadr6 = GET_INADDR6(pp->srcadr);
837 /* XXX PDM This code is buggy. Need to replace with a straightforward assignment */
838 ip->dstadr = (pp->processed) ?
839 pp->cast_flags == MDF_BCAST ?
840 GET_INADDR(pp->dstadr->bcast):
842 GET_INADDR(pp->dstadr->sin) ?
843 GET_INADDR(pp->dstadr->sin):
844 GET_INADDR(pp->dstadr->bcast):
845 2 : GET_INADDR(pp->dstadr->sin);
847 ip->srcadr = GET_INADDR(pp->srcadr);
848 if (client_v6_capable)
851 ip->srcport = NSRCPORT(&pp->srcadr);
854 ip->flags |= INFO_FLAG_SYSPEER;
855 if (pp->flags & FLAG_CONFIG)
856 ip->flags |= INFO_FLAG_CONFIG;
857 if (pp->flags & FLAG_REFCLOCK)
858 ip->flags |= INFO_FLAG_REFCLOCK;
859 if (pp->flags & FLAG_AUTHENABLE)
860 ip->flags |= INFO_FLAG_AUTHENABLE;
861 if (pp->flags & FLAG_PREFER)
862 ip->flags |= INFO_FLAG_PREFER;
863 if (pp->flags & FLAG_BURST)
864 ip->flags |= INFO_FLAG_BURST;
865 if (pp->status == CTL_PST_SEL_SYNCCAND)
866 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
867 if (pp->status >= CTL_PST_SEL_SYSPEER)
868 ip->flags |= INFO_FLAG_SHORTLIST;
870 ip->hmode = pp->hmode;
871 ip->keyid = pp->keyid;
872 ip->stratum = pp->stratum;
873 ip->ppoll = pp->ppoll;
874 ip->hpoll = pp->hpoll;
875 ip->precision = pp->precision;
876 ip->version = pp->version;
877 ip->reach = pp->reach;
878 ip->unreach = (u_char) pp->unreach;
879 ip->flash = (u_char)pp->flash;
880 ip->flash2 = (u_short) pp->flash;
881 ip->estbdelay = HTONS_FP(DTOFP(pp->estbdelay));
883 ip->associd = htons(pp->associd);
884 ip->rootdelay = HTONS_FP(DTOUFP(pp->rootdelay));
885 ip->rootdispersion = HTONS_FP(DTOUFP(pp->rootdispersion));
886 ip->refid = pp->refid;
887 HTONL_FP(&pp->reftime, &ip->reftime);
888 HTONL_FP(&pp->org, &ip->org);
889 HTONL_FP(&pp->rec, &ip->rec);
890 HTONL_FP(&pp->xmt, &ip->xmt);
891 j = pp->filter_nextpt - 1;
892 for (i = 0; i < NTP_SHIFT; i++, j--) {
895 ip->filtdelay[i] = HTONS_FP(DTOFP(pp->filter_delay[j]));
896 DTOLFP(pp->filter_offset[j], <mp);
897 HTONL_FP(<mp, &ip->filtoffset[i]);
898 ip->order[i] = (u_char)((pp->filter_nextpt+NTP_SHIFT-1)
899 - pp->filter_order[i]);
900 if (ip->order[i] >= NTP_SHIFT)
901 ip->order[i] -= NTP_SHIFT;
903 DTOLFP(pp->offset, <mp);
904 HTONL_FP(<mp, &ip->offset);
905 ip->delay = HTONS_FP(DTOFP(pp->delay));
906 ip->dispersion = HTONS_FP(DTOUFP(SQRT(pp->disp)));
907 ip->selectdisp = HTONS_FP(DTOUFP(SQRT(pp->jitter)));
908 ip = (struct info_peer *)more_pkt();
915 * peer_stats - send statistics for one or more peers
919 struct sockaddr_storage *srcadr,
920 struct interface *inter,
921 struct req_pkt *inpkt
924 register struct info_peer_list *ipl;
925 register struct peer *pp;
926 register struct info_peer_stats *ip;
928 struct sockaddr_storage addr;
929 extern struct peer *sys_peer;
931 printf("peer_stats: called\n");
932 items = INFO_NITEMS(inpkt->err_nitems);
933 ipl = (struct info_peer_list *) inpkt->data;
934 ip = (struct info_peer_stats *)prepare_pkt(srcadr, inter, inpkt,
935 v6sizeof(struct info_peer_stats));
936 while (items-- > 0 && ip != 0) {
937 memset((char *)&addr, 0, sizeof(addr));
938 NSRCPORT(&addr) = ipl->port;
939 if (client_v6_capable && ipl->v6_flag) {
940 addr.ss_family = AF_INET6;
941 GET_INADDR6(addr) = ipl->addr6;
943 addr.ss_family = AF_INET;
944 GET_INADDR(addr) = ipl->addr;
946 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
947 addr.ss_len = SOCKLEN(&addr);
949 printf("peer_stats: looking for %s, %d, %d\n", stoa(&addr),
950 ipl->port, ((struct sockaddr_in6 *)&addr)->sin6_port);
951 ipl = (struct info_peer_list *)((char *)ipl +
952 INFO_ITEMSIZE(inpkt->mbz_itemsize));
954 if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0)
956 printf("peer_stats: found %s\n", stoa(&addr));
957 if (pp->srcadr.ss_family == AF_INET) {
958 ip->dstadr = (pp->processed) ?
959 pp->cast_flags == MDF_BCAST ?
960 GET_INADDR(pp->dstadr->bcast):
962 GET_INADDR(pp->dstadr->sin) ?
963 GET_INADDR(pp->dstadr->sin):
964 GET_INADDR(pp->dstadr->bcast):
966 ip->srcadr = GET_INADDR(pp->srcadr);
967 if (client_v6_capable)
970 ip->dstadr6 = pp->cast_flags == MDF_BCAST ?
971 GET_INADDR6(pp->dstadr->bcast):
972 GET_INADDR6(pp->dstadr->sin);
973 ip->srcadr6 = GET_INADDR6(pp->srcadr);
976 ip->srcport = NSRCPORT(&pp->srcadr);
979 ip->flags |= INFO_FLAG_SYSPEER;
980 if (pp->flags & FLAG_CONFIG)
981 ip->flags |= INFO_FLAG_CONFIG;
982 if (pp->flags & FLAG_REFCLOCK)
983 ip->flags |= INFO_FLAG_REFCLOCK;
984 if (pp->flags & FLAG_AUTHENABLE)
985 ip->flags |= INFO_FLAG_AUTHENABLE;
986 if (pp->flags & FLAG_PREFER)
987 ip->flags |= INFO_FLAG_PREFER;
988 if (pp->flags & FLAG_BURST)
989 ip->flags |= INFO_FLAG_BURST;
990 if (pp->status == CTL_PST_SEL_SYNCCAND)
991 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
992 if (pp->status >= CTL_PST_SEL_SYSPEER)
993 ip->flags |= INFO_FLAG_SHORTLIST;
994 ip->timereceived = htonl((u_int32)(current_time - pp->timereceived));
995 ip->timetosend = htonl(pp->nextdate - current_time);
996 ip->timereachable = htonl((u_int32)(current_time - pp->timereachable));
997 ip->sent = htonl((u_int32)(pp->sent));
998 ip->processed = htonl((u_int32)(pp->processed));
999 ip->badauth = htonl((u_int32)(pp->badauth));
1000 ip->bogusorg = htonl((u_int32)(pp->bogusorg));
1001 ip->oldpkt = htonl((u_int32)(pp->oldpkt));
1002 ip->seldisp = htonl((u_int32)(pp->seldisptoolarge));
1003 ip->selbroken = htonl((u_int32)(pp->selbroken));
1004 ip->candidate = pp->status;
1005 ip = (struct info_peer_stats *)more_pkt();
1012 * sys_info - return system info
1016 struct sockaddr_storage *srcadr,
1017 struct interface *inter,
1018 struct req_pkt *inpkt
1021 register struct info_sys *is;
1024 * Importations from the protocol module
1026 extern u_char sys_leap;
1027 extern u_char sys_stratum;
1028 extern s_char sys_precision;
1029 extern double sys_rootdelay;
1030 extern double sys_rootdispersion;
1031 extern u_int32 sys_refid;
1032 extern l_fp sys_reftime;
1033 extern u_char sys_poll;
1034 extern struct peer *sys_peer;
1035 extern int sys_bclient;
1036 extern double sys_bdelay;
1037 extern l_fp sys_authdelay;
1038 extern double clock_stability;
1039 extern double sys_jitter;
1041 is = (struct info_sys *)prepare_pkt(srcadr, inter, inpkt,
1042 v6sizeof(struct info_sys));
1044 if (sys_peer != 0) {
1045 if (sys_peer->srcadr.ss_family == AF_INET) {
1046 is->peer = GET_INADDR(sys_peer->srcadr);
1047 if (client_v6_capable)
1049 } else if (client_v6_capable) {
1050 is->peer6 = GET_INADDR6(sys_peer->srcadr);
1053 is->peer_mode = sys_peer->hmode;
1056 if (client_v6_capable) {
1062 is->leap = sys_leap;
1063 is->stratum = sys_stratum;
1064 is->precision = sys_precision;
1065 is->rootdelay = htonl(DTOFP(sys_rootdelay));
1066 is->rootdispersion = htonl(DTOUFP(sys_rootdispersion));
1067 is->frequency = htonl(DTOFP(sys_jitter));
1068 is->stability = htonl(DTOUFP(clock_stability * 1e6));
1069 is->refid = sys_refid;
1070 HTONL_FP(&sys_reftime, &is->reftime);
1072 is->poll = sys_poll;
1075 if (sys_authenticate)
1076 is->flags |= INFO_FLAG_AUTHENTICATE;
1078 is->flags |= INFO_FLAG_BCLIENT;
1081 is->flags |= INFO_FLAG_CAL;
1082 #endif /* REFCLOCK */
1084 is->flags |= INFO_FLAG_KERNEL;
1085 if (mon_enabled != MON_OFF)
1086 is->flags |= INFO_FLAG_MONITOR;
1088 is->flags |= INFO_FLAG_NTP;
1090 is->flags |= INFO_FLAG_PPS_SYNC;
1092 is->flags |= INFO_FLAG_FILEGEN;
1093 is->bdelay = HTONS_FP(DTOFP(sys_bdelay));
1094 HTONL_UF(sys_authdelay.l_f, &is->authdelay);
1102 * sys_stats - return system statistics
1106 struct sockaddr_storage *srcadr,
1107 struct interface *inter,
1108 struct req_pkt *inpkt
1111 register struct info_sys_stats *ss;
1114 * Importations from the protocol module
1116 ss = (struct info_sys_stats *)prepare_pkt(srcadr, inter, inpkt,
1117 sizeof(struct info_sys_stats));
1118 ss->timeup = htonl((u_int32)current_time);
1119 ss->timereset = htonl((u_int32)(current_time - sys_stattime));
1120 ss->denied = htonl((u_int32)sys_restricted);
1121 ss->oldversionpkt = htonl((u_int32)sys_oldversionpkt);
1122 ss->newversionpkt = htonl((u_int32)sys_newversionpkt);
1123 ss->unknownversion = htonl((u_int32)sys_unknownversion);
1124 ss->badlength = htonl((u_int32)sys_badlength);
1125 ss->processed = htonl((u_int32)sys_processed);
1126 ss->badauth = htonl((u_int32)sys_badauth);
1127 ss->limitrejected = htonl((u_int32)sys_limitrejected);
1128 ss->received = htonl((u_int32)sys_received);
1135 * mem_stats - return memory statistics
1139 struct sockaddr_storage *srcadr,
1140 struct interface *inter,
1141 struct req_pkt *inpkt
1144 register struct info_mem_stats *ms;
1148 * Importations from the peer module
1150 extern int peer_hash_count[HASH_SIZE];
1151 extern int peer_free_count;
1152 extern u_long peer_timereset;
1153 extern u_long findpeer_calls;
1154 extern u_long peer_allocations;
1155 extern u_long peer_demobilizations;
1156 extern int total_peer_structs;
1158 ms = (struct info_mem_stats *)prepare_pkt(srcadr, inter, inpkt,
1159 sizeof(struct info_mem_stats));
1161 ms->timereset = htonl((u_int32)(current_time - peer_timereset));
1162 ms->totalpeermem = htons((u_short)total_peer_structs);
1163 ms->freepeermem = htons((u_short)peer_free_count);
1164 ms->findpeer_calls = htonl((u_int32)findpeer_calls);
1165 ms->allocations = htonl((u_int32)peer_allocations);
1166 ms->demobilizations = htonl((u_int32)peer_demobilizations);
1168 for (i = 0; i < HASH_SIZE; i++) {
1169 if (peer_hash_count[i] > 255)
1170 ms->hashcount[i] = 255;
1172 ms->hashcount[i] = (u_char)peer_hash_count[i];
1181 * io_stats - return io statistics
1185 struct sockaddr_storage *srcadr,
1186 struct interface *inter,
1187 struct req_pkt *inpkt
1190 register struct info_io_stats *io;
1193 * Importations from the io module
1195 extern u_long io_timereset;
1197 io = (struct info_io_stats *)prepare_pkt(srcadr, inter, inpkt,
1198 sizeof(struct info_io_stats));
1200 io->timereset = htonl((u_int32)(current_time - io_timereset));
1201 io->totalrecvbufs = htons((u_short) total_recvbuffs());
1202 io->freerecvbufs = htons((u_short) free_recvbuffs());
1203 io->fullrecvbufs = htons((u_short) full_recvbuffs());
1204 io->lowwater = htons((u_short) lowater_additions());
1205 io->dropped = htonl((u_int32)packets_dropped);
1206 io->ignored = htonl((u_int32)packets_ignored);
1207 io->received = htonl((u_int32)packets_received);
1208 io->sent = htonl((u_int32)packets_sent);
1209 io->notsent = htonl((u_int32)packets_notsent);
1210 io->interrupts = htonl((u_int32)handler_calls);
1211 io->int_received = htonl((u_int32)handler_pkts);
1219 * timer_stats - return timer statistics
1223 struct sockaddr_storage *srcadr,
1224 struct interface *inter,
1225 struct req_pkt *inpkt
1228 register struct info_timer_stats *ts;
1231 * Importations from the timer module
1233 extern u_long timer_timereset;
1234 extern u_long timer_overflows;
1235 extern u_long timer_xmtcalls;
1237 ts = (struct info_timer_stats *)prepare_pkt(srcadr, inter, inpkt,
1238 sizeof(struct info_timer_stats));
1240 ts->timereset = htonl((u_int32)(current_time - timer_timereset));
1241 ts->alarms = htonl((u_int32)alarm_overflow);
1242 ts->overflows = htonl((u_int32)timer_overflows);
1243 ts->xmtcalls = htonl((u_int32)timer_xmtcalls);
1251 * loop_info - return the current state of the loop filter
1255 struct sockaddr_storage *srcadr,
1256 struct interface *inter,
1257 struct req_pkt *inpkt
1260 register struct info_loop *li;
1264 * Importations from the loop filter module
1266 extern double last_offset;
1267 extern double drift_comp;
1268 extern int tc_counter;
1269 extern u_long last_time;
1271 li = (struct info_loop *)prepare_pkt(srcadr, inter, inpkt,
1272 sizeof(struct info_loop));
1274 DTOLFP(last_offset, <mp);
1275 HTONL_FP(<mp, &li->last_offset);
1276 DTOLFP(drift_comp * 1e6, <mp);
1277 HTONL_FP(<mp, &li->drift_comp);
1278 li->compliance = htonl((u_int32)(tc_counter));
1279 li->watchdog_timer = htonl((u_int32)(current_time - last_time));
1287 * do_conf - add a peer to the configuration list
1291 struct sockaddr_storage *srcadr,
1292 struct interface *inter,
1293 struct req_pkt *inpkt
1298 struct conf_peer *cp;
1299 struct conf_peer temp_cp;
1300 struct sockaddr_storage peeraddr;
1301 struct sockaddr_in tmp_clock;
1304 * Do a check of everything to see that it looks
1305 * okay. If not, complain about it. Note we are
1308 items = INFO_NITEMS(inpkt->err_nitems);
1309 cp = (struct conf_peer *)inpkt->data;
1310 memset(&temp_cp, 0, sizeof(struct conf_peer));
1311 memcpy(&temp_cp, (char *)cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1313 while (items-- > 0 && !fl) {
1314 if (((temp_cp.version) > NTP_VERSION)
1315 || ((temp_cp.version) < NTP_OLDVERSION))
1317 if (temp_cp.hmode != MODE_ACTIVE
1318 && temp_cp.hmode != MODE_CLIENT
1319 && temp_cp.hmode != MODE_BROADCAST)
1321 if (temp_cp.flags & ~(CONF_FLAG_AUTHENABLE | CONF_FLAG_PREFER
1322 | CONF_FLAG_BURST | CONF_FLAG_SKEY))
1324 cp = (struct conf_peer *)
1325 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1329 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1334 * Looks okay, try it out
1336 items = INFO_NITEMS(inpkt->err_nitems);
1337 cp = (struct conf_peer *)inpkt->data;
1339 while (items-- > 0) {
1340 memset(&temp_cp, 0, sizeof(struct conf_peer));
1341 memcpy(&temp_cp, (char *)cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1342 memset((char *)&peeraddr, 0, sizeof(struct sockaddr_storage));
1345 if (temp_cp.flags & CONF_FLAG_AUTHENABLE)
1346 fl |= FLAG_AUTHENABLE;
1347 if (temp_cp.flags & CONF_FLAG_PREFER)
1349 if (temp_cp.flags & CONF_FLAG_BURST)
1351 if (temp_cp.flags & CONF_FLAG_SKEY)
1353 if (client_v6_capable && temp_cp.v6_flag != 0) {
1354 peeraddr.ss_family = AF_INET6;
1355 GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
1357 peeraddr.ss_family = AF_INET;
1358 GET_INADDR(peeraddr) = temp_cp.peeraddr;
1360 * Make sure the address is valid
1362 tmp_clock = *CAST_V4(peeraddr);
1365 !ISREFCLOCKADR(&tmp_clock) &&
1367 ISBADADR(&tmp_clock)) {
1368 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1373 NSRCPORT(&peeraddr) = htons(NTP_PORT);
1374 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1375 peeraddr.ss_len = SOCKLEN(&peeraddr);
1378 /* XXX W2DO? minpoll/maxpoll arguments ??? */
1379 if (peer_config(&peeraddr, (struct interface *)0,
1380 temp_cp.hmode, temp_cp.version, temp_cp.minpoll,
1381 temp_cp.maxpoll, fl, temp_cp.ttl, temp_cp.keyid,
1383 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1386 cp = (struct conf_peer *)
1387 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1390 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1396 * dns_a - Snarf DNS info for an association ID
1400 struct sockaddr_storage *srcadr,
1401 struct interface *inter,
1402 struct req_pkt *inpkt
1405 register struct info_dns_assoc *dp;
1407 struct sockaddr_in peeraddr;
1410 * Do a check of everything to see that it looks
1411 * okay. If not, complain about it. Note we are
1414 items = INFO_NITEMS(inpkt->err_nitems);
1415 dp = (struct info_dns_assoc *)inpkt->data;
1418 * Looks okay, try it out
1420 items = INFO_NITEMS(inpkt->err_nitems);
1421 dp = (struct info_dns_assoc *)inpkt->data;
1422 memset((char *)&peeraddr, 0, sizeof(struct sockaddr_in));
1423 peeraddr.sin_family = AF_INET;
1424 peeraddr.sin_port = htons(NTP_PORT);
1427 * Make sure the address is valid
1431 !ISREFCLOCKADR(&peeraddr) &&
1433 ISBADADR(&peeraddr)) {
1435 msyslog(LOG_ERR, "dns_a: !ISREFCLOCK && ISBADADR");
1437 msyslog(LOG_ERR, "dns_a: ISBADADR");
1439 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1443 while (items-- > 0) {
1449 associd = dp->associd;
1450 peer = findpeerbyassoc(associd);
1451 if (peer == 0 || peer->flags & FLAG_REFCLOCK) {
1452 msyslog(LOG_ERR, "dns_a: %s",
1455 : "peer->flags & FLAG_REFCLOCK");
1458 peeraddr.sin_addr.s_addr = dp->peeraddr;
1459 for (hnl = 0; dp->hostname[hnl] && hnl < sizeof dp->hostname; ++hnl) ;
1460 if (hnl >= sizeof dp->hostname) {
1461 msyslog(LOG_ERR, "dns_a: hnl (%ld) >= %ld",
1462 (long)hnl, (long)sizeof dp->hostname);
1466 msyslog(LOG_INFO, "dns_a: <%s> for %s, AssocID %d, bogon %d",
1468 stoa((struct sockaddr_storage *)&peeraddr), associd,
1472 /* If it didn't work */
1473 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1478 crypto_public(peer, dp->hostname);
1486 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1491 * do_unconf - remove a peer from the configuration list
1495 struct sockaddr_storage *srcadr,
1496 struct interface *inter,
1497 struct req_pkt *inpkt
1500 register struct conf_unpeer *cp;
1501 struct conf_unpeer temp_cp;
1503 register struct peer *peer;
1504 struct sockaddr_storage peeraddr;
1508 * This is a bit unstructured, but I like to be careful.
1509 * We check to see that every peer exists and is actually
1510 * configured. If so, we remove them. If not, we return
1513 items = INFO_NITEMS(inpkt->err_nitems);
1514 cp = (struct conf_unpeer *)inpkt->data;
1517 while (items-- > 0 && !bad) {
1518 memset(&temp_cp, 0, sizeof(temp_cp));
1519 memset(&peeraddr, 0, sizeof(peeraddr));
1520 memcpy(&temp_cp, cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1521 if (client_v6_capable && temp_cp.v6_flag != 0) {
1522 peeraddr.ss_family = AF_INET6;
1523 GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
1525 peeraddr.ss_family = AF_INET;
1526 GET_INADDR(peeraddr) = temp_cp.peeraddr;
1528 NSRCPORT(&peeraddr) = htons(NTP_PORT);
1529 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1530 peeraddr.ss_len = SOCKLEN(&peeraddr);
1533 peer = (struct peer *)0;
1534 printf("searching for %s\n", stoa(&peeraddr));
1536 peer = findexistingpeer(&peeraddr, peer, -1);
1537 if (peer == (struct peer *)0)
1539 if (peer->flags & FLAG_CONFIG)
1544 cp = (struct conf_unpeer *)
1545 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1549 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1554 * Now do it in earnest.
1557 items = INFO_NITEMS(inpkt->err_nitems);
1558 cp = (struct conf_unpeer *)inpkt->data;
1559 while (items-- > 0) {
1560 memset(&temp_cp, 0, sizeof(temp_cp));
1561 memset(&peeraddr, 0, sizeof(peeraddr));
1562 memcpy(&temp_cp, cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1563 if (client_v6_capable && temp_cp.v6_flag != 0) {
1564 peeraddr.ss_family = AF_INET6;
1565 GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
1567 peeraddr.ss_family = AF_INET;
1568 GET_INADDR(peeraddr) = temp_cp.peeraddr;
1570 NSRCPORT(&peeraddr) = htons(NTP_PORT);
1571 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1572 peeraddr.ss_len = SOCKLEN(&peeraddr);
1574 peer_unconfig(&peeraddr, (struct interface *)0, -1);
1575 cp = (struct conf_unpeer *)
1576 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1579 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1584 * set_sys_flag - set system flags
1588 struct sockaddr_storage *srcadr,
1589 struct interface *inter,
1590 struct req_pkt *inpkt
1593 setclr_flags(srcadr, inter, inpkt, 1);
1598 * clr_sys_flag - clear system flags
1602 struct sockaddr_storage *srcadr,
1603 struct interface *inter,
1604 struct req_pkt *inpkt
1607 setclr_flags(srcadr, inter, inpkt, 0);
1612 * setclr_flags - do the grunge work of flag setting/clearing
1616 struct sockaddr_storage *srcadr,
1617 struct interface *inter,
1618 struct req_pkt *inpkt,
1622 register u_int flags;
1624 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
1625 msyslog(LOG_ERR, "setclr_flags: err_nitems > 1");
1626 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1630 flags = ((struct conf_sys_flags *)inpkt->data)->flags;
1632 if (flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
1633 SYS_FLAG_NTP | SYS_FLAG_KERNEL | SYS_FLAG_MONITOR |
1634 SYS_FLAG_FILEGEN | SYS_FLAG_AUTH | SYS_FLAG_CAL)) {
1635 msyslog(LOG_ERR, "setclr_flags: extra flags: %#x",
1636 flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
1637 SYS_FLAG_NTP | SYS_FLAG_KERNEL |
1638 SYS_FLAG_MONITOR | SYS_FLAG_FILEGEN |
1639 SYS_FLAG_AUTH | SYS_FLAG_CAL));
1640 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1644 if (flags & SYS_FLAG_BCLIENT)
1645 proto_config(PROTO_BROADCLIENT, set, 0., NULL);
1646 if (flags & SYS_FLAG_PPS)
1647 proto_config(PROTO_PPS, set, 0., NULL);
1648 if (flags & SYS_FLAG_NTP)
1649 proto_config(PROTO_NTP, set, 0., NULL);
1650 if (flags & SYS_FLAG_KERNEL)
1651 proto_config(PROTO_KERNEL, set, 0., NULL);
1652 if (flags & SYS_FLAG_MONITOR)
1653 proto_config(PROTO_MONITOR, set, 0., NULL);
1654 if (flags & SYS_FLAG_FILEGEN)
1655 proto_config(PROTO_FILEGEN, set, 0., NULL);
1656 if (flags & SYS_FLAG_AUTH)
1657 proto_config(PROTO_AUTHENTICATE, set, 0., NULL);
1658 if (flags & SYS_FLAG_CAL)
1659 proto_config(PROTO_CAL, set, 0., NULL);
1660 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1665 * list_restrict - return the restrict list
1669 struct sockaddr_storage *srcadr,
1670 struct interface *inter,
1671 struct req_pkt *inpkt
1674 register struct info_restrict *ir;
1675 register struct restrictlist *rl;
1676 register struct restrictlist6 *rl6;
1680 printf("wants restrict list summary\n");
1683 ir = (struct info_restrict *)prepare_pkt(srcadr, inter, inpkt,
1684 v6sizeof(struct info_restrict));
1686 for (rl = restrictlist; rl != 0 && ir != 0; rl = rl->next) {
1687 ir->addr = htonl(rl->addr);
1688 if (client_v6_capable)
1690 ir->mask = htonl(rl->mask);
1691 ir->count = htonl((u_int32)rl->count);
1692 ir->flags = htons(rl->flags);
1693 ir->mflags = htons(rl->mflags);
1694 ir = (struct info_restrict *)more_pkt();
1696 if (client_v6_capable)
1697 for (rl6 = restrictlist6; rl6 != 0 && ir != 0; rl6 = rl6->next) {
1698 ir->addr6 = rl6->addr6;
1699 ir->mask6 = rl6->mask6;
1701 ir->count = htonl((u_int32)rl6->count);
1702 ir->flags = htons(rl6->flags);
1703 ir->mflags = htons(rl6->mflags);
1704 ir = (struct info_restrict *)more_pkt();
1712 * do_resaddflags - add flags to a restrict entry (or create one)
1716 struct sockaddr_storage *srcadr,
1717 struct interface *inter,
1718 struct req_pkt *inpkt
1721 do_restrict(srcadr, inter, inpkt, RESTRICT_FLAGS);
1727 * do_ressubflags - remove flags from a restrict entry
1731 struct sockaddr_storage *srcadr,
1732 struct interface *inter,
1733 struct req_pkt *inpkt
1736 do_restrict(srcadr, inter, inpkt, RESTRICT_UNFLAG);
1741 * do_unrestrict - remove a restrict entry from the list
1745 struct sockaddr_storage *srcadr,
1746 struct interface *inter,
1747 struct req_pkt *inpkt
1750 do_restrict(srcadr, inter, inpkt, RESTRICT_REMOVE);
1758 * do_restrict - do the dirty stuff of dealing with restrictions
1762 struct sockaddr_storage *srcadr,
1763 struct interface *inter,
1764 struct req_pkt *inpkt,
1768 register struct conf_restrict *cr;
1770 struct sockaddr_storage matchaddr;
1771 struct sockaddr_storage matchmask;
1775 * Do a check of the flags to make sure that only
1776 * the NTPPORT flag is set, if any. If not, complain
1777 * about it. Note we are very picky here.
1779 items = INFO_NITEMS(inpkt->err_nitems);
1780 cr = (struct conf_restrict *)inpkt->data;
1783 while (items-- > 0 && !bad) {
1784 if (cr->mflags & ~(RESM_NTPONLY))
1786 if (cr->flags & ~(RES_ALLFLAGS))
1788 if (cr->mask != htonl(INADDR_ANY)) {
1789 if (client_v6_capable && cr->v6_flag != 0) {
1790 if (IN6_IS_ADDR_UNSPECIFIED(&cr->addr6))
1793 if (cr->addr == htonl(INADDR_ANY))
1796 cr = (struct conf_restrict *)((char *)cr +
1797 INFO_ITEMSIZE(inpkt->mbz_itemsize));
1801 msyslog(LOG_ERR, "do_restrict: bad = %#x", bad);
1802 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1807 * Looks okay, try it out
1809 items = INFO_NITEMS(inpkt->err_nitems);
1810 cr = (struct conf_restrict *)inpkt->data;
1811 memset((char *)&matchaddr, 0, sizeof(struct sockaddr_storage));
1812 memset((char *)&matchmask, 0, sizeof(struct sockaddr_storage));
1814 while (items-- > 0) {
1815 if (client_v6_capable && cr->v6_flag != 0) {
1816 GET_INADDR6(matchaddr) = cr->addr6;
1817 GET_INADDR6(matchmask) = cr->mask6;
1818 matchaddr.ss_family = AF_INET6;
1819 matchmask.ss_family = AF_INET6;
1821 GET_INADDR(matchaddr) = cr->addr;
1822 GET_INADDR(matchmask) = cr->mask;
1823 matchaddr.ss_family = AF_INET;
1824 matchmask.ss_family = AF_INET;
1826 hack_restrict(op, &matchaddr, &matchmask, cr->mflags,
1831 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1836 * mon_getlist - return monitor data
1840 struct sockaddr_storage *srcadr,
1841 struct interface *inter,
1842 struct req_pkt *inpkt
1845 register struct info_monitor *im;
1846 register struct mon_data *md;
1847 extern struct mon_data mon_mru_list;
1848 extern int mon_enabled;
1852 printf("wants monitor 0 list\n");
1855 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1858 im = (struct info_monitor *)prepare_pkt(srcadr, inter, inpkt,
1859 v6sizeof(struct info_monitor));
1860 for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0;
1861 md = md->mru_next) {
1862 im->lasttime = htonl((u_int32)md->avg_interval);
1863 im->firsttime = htonl((u_int32)(current_time - md->lasttime));
1864 im->lastdrop = htonl((u_int32)md->drop_count);
1865 im->count = htonl((u_int32)(md->count));
1866 if (md->rmtadr.ss_family == AF_INET6) {
1867 if (!client_v6_capable)
1869 im->addr6 = GET_INADDR6(md->rmtadr);
1872 im->addr = GET_INADDR(md->rmtadr);
1873 if (client_v6_capable)
1876 im->port = md->rmtport;
1877 im->mode = md->mode;
1878 im->version = md->version;
1879 im = (struct info_monitor *)more_pkt();
1885 * mon_getlist - return monitor data
1889 struct sockaddr_storage *srcadr,
1890 struct interface *inter,
1891 struct req_pkt *inpkt
1894 register struct info_monitor_1 *im;
1895 register struct mon_data *md;
1896 extern struct mon_data mon_mru_list;
1897 extern int mon_enabled;
1900 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1903 im = (struct info_monitor_1 *)prepare_pkt(srcadr, inter, inpkt,
1904 v6sizeof(struct info_monitor_1));
1905 for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0;
1906 md = md->mru_next) {
1907 im->lasttime = htonl((u_int32)md->avg_interval);
1908 im->firsttime = htonl((u_int32)(current_time - md->lasttime));
1909 im->lastdrop = htonl((u_int32)md->drop_count);
1910 im->count = htonl((u_int32)md->count);
1911 if (md->rmtadr.ss_family == AF_INET6) {
1912 if (!client_v6_capable)
1914 im->addr6 = GET_INADDR6(md->rmtadr);
1916 im->daddr6 = GET_INADDR6(md->interface->sin);
1918 im->addr = GET_INADDR(md->rmtadr);
1919 if (client_v6_capable)
1921 im->daddr = (md->cast_flags == MDF_BCAST)
1922 ? GET_INADDR(md->interface->bcast)
1924 ? (GET_INADDR(md->interface->sin)
1925 ? GET_INADDR(md->interface->sin)
1926 : GET_INADDR(md->interface->bcast))
1929 im->flags = md->cast_flags;
1930 im->port = md->rmtport;
1931 im->mode = md->mode;
1932 im->version = md->version;
1933 im = (struct info_monitor_1 *)more_pkt();
1939 * Module entry points and the flags they correspond with
1941 struct reset_entry {
1942 int flag; /* flag this corresponds to */
1943 void (*handler) P((void)); /* routine to handle request */
1946 struct reset_entry reset_entries[] = {
1947 { RESET_FLAG_ALLPEERS, peer_all_reset },
1948 { RESET_FLAG_IO, io_clr_stats },
1949 { RESET_FLAG_SYS, proto_clr_stats },
1950 { RESET_FLAG_MEM, peer_clr_stats },
1951 { RESET_FLAG_TIMER, timer_clr_stats },
1952 { RESET_FLAG_AUTH, reset_auth_stats },
1953 { RESET_FLAG_CTL, ctl_clr_stats },
1958 * reset_stats - reset statistic counters here and there
1962 struct sockaddr_storage *srcadr,
1963 struct interface *inter,
1964 struct req_pkt *inpkt
1968 struct reset_entry *rent;
1970 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
1971 msyslog(LOG_ERR, "reset_stats: err_nitems > 1");
1972 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1976 flags = ((struct reset_flags *)inpkt->data)->flags;
1978 if (flags & ~RESET_ALLFLAGS) {
1979 msyslog(LOG_ERR, "reset_stats: reset leaves %#lx",
1980 flags & ~RESET_ALLFLAGS);
1981 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1985 for (rent = reset_entries; rent->flag != 0; rent++) {
1986 if (flags & rent->flag)
1989 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1994 * reset_peer - clear a peer's statistics
1998 struct sockaddr_storage *srcadr,
1999 struct interface *inter,
2000 struct req_pkt *inpkt
2003 register struct conf_unpeer *cp;
2005 register struct peer *peer;
2006 struct sockaddr_storage peeraddr;
2010 * We check first to see that every peer exists. If not,
2011 * we return an error.
2014 items = INFO_NITEMS(inpkt->err_nitems);
2015 cp = (struct conf_unpeer *)inpkt->data;
2018 while (items-- > 0 && !bad) {
2019 memset((char *)&peeraddr, 0, sizeof(peeraddr));
2020 if (client_v6_capable && cp->v6_flag != 0) {
2021 GET_INADDR6(peeraddr) = cp->peeraddr6;
2022 peeraddr.ss_family = AF_INET6;
2024 GET_INADDR(peeraddr) = cp->peeraddr;
2025 peeraddr.ss_family = AF_INET;
2027 NSRCPORT(&peeraddr) = htons(NTP_PORT);
2028 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2029 peeraddr.ss_len = SOCKLEN(&peeraddr);
2031 peer = findexistingpeer(&peeraddr, (struct peer *)0, -1);
2032 if (peer == (struct peer *)0)
2034 cp = (struct conf_unpeer *)((char *)cp +
2035 INFO_ITEMSIZE(inpkt->mbz_itemsize));
2039 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2044 * Now do it in earnest.
2047 items = INFO_NITEMS(inpkt->err_nitems);
2048 cp = (struct conf_unpeer *)inpkt->data;
2049 while (items-- > 0) {
2050 memset((char *)&peeraddr, 0, sizeof(peeraddr));
2051 if (client_v6_capable && cp->v6_flag != 0) {
2052 GET_INADDR6(peeraddr) = cp->peeraddr6;
2053 peeraddr.ss_family = AF_INET6;
2055 GET_INADDR(peeraddr) = cp->peeraddr;
2056 peeraddr.ss_family = AF_INET;
2058 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2059 peeraddr.ss_len = SOCKLEN(&peeraddr);
2061 peer = findexistingpeer(&peeraddr, (struct peer *)0, -1);
2064 peer = findexistingpeer(&peeraddr, (struct peer *)peer, -1);
2066 cp = (struct conf_unpeer *)((char *)cp +
2067 INFO_ITEMSIZE(inpkt->mbz_itemsize));
2070 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2075 * do_key_reread - reread the encryption key file
2079 struct sockaddr_storage *srcadr,
2080 struct interface *inter,
2081 struct req_pkt *inpkt
2085 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2090 * trust_key - make one or more keys trusted
2094 struct sockaddr_storage *srcadr,
2095 struct interface *inter,
2096 struct req_pkt *inpkt
2099 do_trustkey(srcadr, inter, inpkt, 1);
2104 * untrust_key - make one or more keys untrusted
2108 struct sockaddr_storage *srcadr,
2109 struct interface *inter,
2110 struct req_pkt *inpkt
2113 do_trustkey(srcadr, inter, inpkt, 0);
2118 * do_trustkey - make keys either trustable or untrustable
2122 struct sockaddr_storage *srcadr,
2123 struct interface *inter,
2124 struct req_pkt *inpkt,
2128 register u_long *kp;
2131 items = INFO_NITEMS(inpkt->err_nitems);
2132 kp = (u_long *)inpkt->data;
2133 while (items-- > 0) {
2134 authtrust(*kp, trust);
2138 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2143 * get_auth_info - return some stats concerning the authentication module
2147 struct sockaddr_storage *srcadr,
2148 struct interface *inter,
2149 struct req_pkt *inpkt
2152 register struct info_auth *ia;
2155 * Importations from the authentication module
2157 extern u_long authnumkeys;
2158 extern int authnumfreekeys;
2159 extern u_long authkeylookups;
2160 extern u_long authkeynotfound;
2161 extern u_long authencryptions;
2162 extern u_long authdecryptions;
2163 extern u_long authkeyuncached;
2164 extern u_long authkeyexpired;
2166 ia = (struct info_auth *)prepare_pkt(srcadr, inter, inpkt,
2167 sizeof(struct info_auth));
2169 ia->numkeys = htonl((u_int32)authnumkeys);
2170 ia->numfreekeys = htonl((u_int32)authnumfreekeys);
2171 ia->keylookups = htonl((u_int32)authkeylookups);
2172 ia->keynotfound = htonl((u_int32)authkeynotfound);
2173 ia->encryptions = htonl((u_int32)authencryptions);
2174 ia->decryptions = htonl((u_int32)authdecryptions);
2175 ia->keyuncached = htonl((u_int32)authkeyuncached);
2176 ia->expired = htonl((u_int32)authkeyexpired);
2177 ia->timereset = htonl((u_int32)(current_time - auth_timereset));
2186 * reset_auth_stats - reset the authentication stat counters. Done here
2187 * to keep ntp-isms out of the authentication module
2190 reset_auth_stats(void)
2193 * Importations from the authentication module
2195 extern u_long authkeylookups;
2196 extern u_long authkeynotfound;
2197 extern u_long authencryptions;
2198 extern u_long authdecryptions;
2199 extern u_long authkeyuncached;
2202 authkeynotfound = 0;
2203 authencryptions = 0;
2204 authdecryptions = 0;
2205 authkeyuncached = 0;
2206 auth_timereset = current_time;
2211 * req_get_traps - return information about current trap holders
2215 struct sockaddr_storage *srcadr,
2216 struct interface *inter,
2217 struct req_pkt *inpkt
2220 register struct info_trap *it;
2221 register struct ctl_trap *tr;
2225 * Imported from the control module
2227 extern struct ctl_trap ctl_trap[];
2228 extern int num_ctl_traps;
2230 if (num_ctl_traps == 0) {
2231 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2235 it = (struct info_trap *)prepare_pkt(srcadr, inter, inpkt,
2236 v6sizeof(struct info_trap));
2238 for (i = 0, tr = ctl_trap; i < CTL_MAXTRAPS; i++, tr++) {
2239 if (tr->tr_flags & TRAP_INUSE) {
2240 if (tr->tr_addr.ss_family == AF_INET) {
2241 if (tr->tr_localaddr == any_interface)
2242 it->local_address = 0;
2245 = GET_INADDR(tr->tr_localaddr->sin);
2246 it->trap_address = GET_INADDR(tr->tr_addr);
2247 if (client_v6_capable)
2250 if (!client_v6_capable)
2253 = GET_INADDR6(tr->tr_localaddr->sin);
2254 it->trap_address6 = GET_INADDR6(tr->tr_addr);
2257 it->trap_port = NSRCPORT(&tr->tr_addr);
2258 it->sequence = htons(tr->tr_sequence);
2259 it->settime = htonl((u_int32)(current_time - tr->tr_settime));
2260 it->origtime = htonl((u_int32)(current_time - tr->tr_origtime));
2261 it->resets = htonl((u_int32)tr->tr_resets);
2262 it->flags = htonl((u_int32)tr->tr_flags);
2263 it = (struct info_trap *)more_pkt();
2271 * req_set_trap - configure a trap
2275 struct sockaddr_storage *srcadr,
2276 struct interface *inter,
2277 struct req_pkt *inpkt
2280 do_setclr_trap(srcadr, inter, inpkt, 1);
2286 * req_clr_trap - unconfigure a trap
2290 struct sockaddr_storage *srcadr,
2291 struct interface *inter,
2292 struct req_pkt *inpkt
2295 do_setclr_trap(srcadr, inter, inpkt, 0);
2301 * do_setclr_trap - do the grunge work of (un)configuring a trap
2305 struct sockaddr_storage *srcadr,
2306 struct interface *inter,
2307 struct req_pkt *inpkt,
2311 register struct conf_trap *ct;
2312 register struct interface *linter;
2314 struct sockaddr_storage laddr;
2317 * Prepare sockaddr_storage structure
2319 memset((char *)&laddr, 0, sizeof laddr);
2320 laddr.ss_family = srcadr->ss_family;
2321 NSRCPORT(&laddr) = ntohs(NTP_PORT);
2324 * Restrict ourselves to one item only. This eliminates
2325 * the error reporting problem.
2327 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2328 msyslog(LOG_ERR, "do_setclr_trap: err_nitems > 1");
2329 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2332 ct = (struct conf_trap *)inpkt->data;
2335 * Look for the local interface. If none, use the default.
2337 if (ct->local_address == 0) {
2338 linter = any_interface;
2340 if (laddr.ss_family == AF_INET)
2341 GET_INADDR(laddr) = ct->local_address;
2343 GET_INADDR6(laddr) = ct->local_address6;
2344 linter = findinterface(&laddr);
2345 if (linter == NULL) {
2346 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2351 if (laddr.ss_family == AF_INET)
2352 GET_INADDR(laddr) = ct->trap_address;
2354 GET_INADDR6(laddr) = ct->trap_address6;
2355 if (ct->trap_port != 0)
2356 NSRCPORT(&laddr) = ct->trap_port;
2358 NSRCPORT(&laddr) = htons(TRAPPORT);
2361 res = ctlsettrap(&laddr, linter, 0,
2362 INFO_VERSION(inpkt->rm_vn_mode));
2364 res = ctlclrtrap(&laddr, linter, 0);
2368 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2370 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2378 * set_request_keyid - set the keyid used to authenticate requests
2382 struct sockaddr_storage *srcadr,
2383 struct interface *inter,
2384 struct req_pkt *inpkt
2390 * Restrict ourselves to one item only.
2392 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2393 msyslog(LOG_ERR, "set_request_keyid: err_nitems > 1");
2394 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2398 keyid = ntohl(*((u_int32 *)(inpkt->data)));
2399 info_auth_keyid = keyid;
2400 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2406 * set_control_keyid - set the keyid used to authenticate requests
2410 struct sockaddr_storage *srcadr,
2411 struct interface *inter,
2412 struct req_pkt *inpkt
2416 extern keyid_t ctl_auth_keyid;
2419 * Restrict ourselves to one item only.
2421 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2422 msyslog(LOG_ERR, "set_control_keyid: err_nitems > 1");
2423 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2427 keyid = ntohl(*((u_int32 *)(inpkt->data)));
2428 ctl_auth_keyid = keyid;
2429 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2435 * get_ctl_stats - return some stats concerning the control message module
2439 struct sockaddr_storage *srcadr,
2440 struct interface *inter,
2441 struct req_pkt *inpkt
2444 register struct info_control *ic;
2447 * Importations from the control module
2449 extern u_long ctltimereset;
2450 extern u_long numctlreq;
2451 extern u_long numctlbadpkts;
2452 extern u_long numctlresponses;
2453 extern u_long numctlfrags;
2454 extern u_long numctlerrors;
2455 extern u_long numctltooshort;
2456 extern u_long numctlinputresp;
2457 extern u_long numctlinputfrag;
2458 extern u_long numctlinputerr;
2459 extern u_long numctlbadoffset;
2460 extern u_long numctlbadversion;
2461 extern u_long numctldatatooshort;
2462 extern u_long numctlbadop;
2463 extern u_long numasyncmsgs;
2465 ic = (struct info_control *)prepare_pkt(srcadr, inter, inpkt,
2466 sizeof(struct info_control));
2468 ic->ctltimereset = htonl((u_int32)(current_time - ctltimereset));
2469 ic->numctlreq = htonl((u_int32)numctlreq);
2470 ic->numctlbadpkts = htonl((u_int32)numctlbadpkts);
2471 ic->numctlresponses = htonl((u_int32)numctlresponses);
2472 ic->numctlfrags = htonl((u_int32)numctlfrags);
2473 ic->numctlerrors = htonl((u_int32)numctlerrors);
2474 ic->numctltooshort = htonl((u_int32)numctltooshort);
2475 ic->numctlinputresp = htonl((u_int32)numctlinputresp);
2476 ic->numctlinputfrag = htonl((u_int32)numctlinputfrag);
2477 ic->numctlinputerr = htonl((u_int32)numctlinputerr);
2478 ic->numctlbadoffset = htonl((u_int32)numctlbadoffset);
2479 ic->numctlbadversion = htonl((u_int32)numctlbadversion);
2480 ic->numctldatatooshort = htonl((u_int32)numctldatatooshort);
2481 ic->numctlbadop = htonl((u_int32)numctlbadop);
2482 ic->numasyncmsgs = htonl((u_int32)numasyncmsgs);
2491 * get_kernel_info - get kernel pll/pps information
2495 struct sockaddr_storage *srcadr,
2496 struct interface *inter,
2497 struct req_pkt *inpkt
2500 register struct info_kernel *ik;
2504 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2508 memset((char *)&ntx, 0, sizeof(ntx));
2509 if (ntp_adjtime(&ntx) < 0)
2510 msyslog(LOG_ERR, "get_kernel_info: ntp_adjtime() failed: %m");
2511 ik = (struct info_kernel *)prepare_pkt(srcadr, inter, inpkt,
2512 sizeof(struct info_kernel));
2517 ik->offset = htonl((u_int32)ntx.offset);
2518 ik->freq = htonl((u_int32)ntx.freq);
2519 ik->maxerror = htonl((u_int32)ntx.maxerror);
2520 ik->esterror = htonl((u_int32)ntx.esterror);
2521 ik->status = htons(ntx.status);
2522 ik->constant = htonl((u_int32)ntx.constant);
2523 ik->precision = htonl((u_int32)ntx.precision);
2524 ik->tolerance = htonl((u_int32)ntx.tolerance);
2529 ik->ppsfreq = htonl((u_int32)ntx.ppsfreq);
2530 ik->jitter = htonl((u_int32)ntx.jitter);
2531 ik->shift = htons(ntx.shift);
2532 ik->stabil = htonl((u_int32)ntx.stabil);
2533 ik->jitcnt = htonl((u_int32)ntx.jitcnt);
2534 ik->calcnt = htonl((u_int32)ntx.calcnt);
2535 ik->errcnt = htonl((u_int32)ntx.errcnt);
2536 ik->stbcnt = htonl((u_int32)ntx.stbcnt);
2541 #endif /* KERNEL_PLL */
2546 * get_clock_info - get info about a clock
2550 struct sockaddr_storage *srcadr,
2551 struct interface *inter,
2552 struct req_pkt *inpkt
2555 register struct info_clock *ic;
2556 register u_int32 *clkaddr;
2558 struct refclockstat clock_stat;
2559 struct sockaddr_storage addr;
2560 struct sockaddr_in tmp_clock;
2563 memset((char *)&addr, 0, sizeof addr);
2564 addr.ss_family = AF_INET;
2565 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2566 addr.ss_len = SOCKLEN(&addr);
2568 NSRCPORT(&addr) = htons(NTP_PORT);
2569 items = INFO_NITEMS(inpkt->err_nitems);
2570 clkaddr = (u_int32 *) inpkt->data;
2572 ic = (struct info_clock *)prepare_pkt(srcadr, inter, inpkt,
2573 sizeof(struct info_clock));
2575 while (items-- > 0) {
2576 tmp_clock.sin_addr.s_addr = *clkaddr++;
2577 CAST_V4(addr)->sin_addr = tmp_clock.sin_addr;
2578 if (!ISREFCLOCKADR(&tmp_clock) ||
2579 findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2580 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2584 clock_stat.kv_list = (struct ctl_var *)0;
2586 refclock_control(&addr, (struct refclockstat *)0, &clock_stat);
2588 ic->clockadr = tmp_clock.sin_addr.s_addr;
2589 ic->type = clock_stat.type;
2590 ic->flags = clock_stat.flags;
2591 ic->lastevent = clock_stat.lastevent;
2592 ic->currentstatus = clock_stat.currentstatus;
2593 ic->polls = htonl((u_int32)clock_stat.polls);
2594 ic->noresponse = htonl((u_int32)clock_stat.noresponse);
2595 ic->badformat = htonl((u_int32)clock_stat.badformat);
2596 ic->baddata = htonl((u_int32)clock_stat.baddata);
2597 ic->timestarted = htonl((u_int32)clock_stat.timereset);
2598 DTOLFP(clock_stat.fudgetime1, <mp);
2599 HTONL_FP(<mp, &ic->fudgetime1);
2600 DTOLFP(clock_stat.fudgetime2, <mp);
2601 HTONL_FP(<mp, &ic->fudgetime2);
2602 ic->fudgeval1 = htonl((u_int32)clock_stat.fudgeval1);
2603 ic->fudgeval2 = htonl((u_int32)clock_stat.fudgeval2);
2605 free_varlist(clock_stat.kv_list);
2607 ic = (struct info_clock *)more_pkt();
2615 * set_clock_fudge - get a clock's fudge factors
2619 struct sockaddr_storage *srcadr,
2620 struct interface *inter,
2621 struct req_pkt *inpkt
2624 register struct conf_fudge *cf;
2626 struct refclockstat clock_stat;
2627 struct sockaddr_storage addr;
2628 struct sockaddr_in tmp_clock;
2631 memset((char *)&addr, 0, sizeof addr);
2632 memset((char *)&clock_stat, 0, sizeof clock_stat);
2633 items = INFO_NITEMS(inpkt->err_nitems);
2634 cf = (struct conf_fudge *) inpkt->data;
2636 while (items-- > 0) {
2637 tmp_clock.sin_addr.s_addr = cf->clockadr;
2638 *CAST_V4(addr) = tmp_clock;
2639 addr.ss_family = AF_INET;
2640 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2641 addr.ss_len = SOCKLEN(&addr);
2643 NSRCPORT(&addr) = htons(NTP_PORT);
2644 if (!ISREFCLOCKADR(&tmp_clock) ||
2645 findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2646 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2650 switch(ntohl(cf->which)) {
2652 NTOHL_FP(&cf->fudgetime, <mp);
2653 LFPTOD(<mp, clock_stat.fudgetime1);
2654 clock_stat.haveflags = CLK_HAVETIME1;
2657 NTOHL_FP(&cf->fudgetime, <mp);
2658 LFPTOD(<mp, clock_stat.fudgetime2);
2659 clock_stat.haveflags = CLK_HAVETIME2;
2662 clock_stat.fudgeval1 = ntohl(cf->fudgeval_flags);
2663 clock_stat.haveflags = CLK_HAVEVAL1;
2666 clock_stat.fudgeval2 = ntohl(cf->fudgeval_flags);
2667 clock_stat.haveflags = CLK_HAVEVAL2;
2670 clock_stat.flags = (u_char) (ntohl(cf->fudgeval_flags) & 0xf);
2671 clock_stat.haveflags =
2672 (CLK_HAVEFLAG1|CLK_HAVEFLAG2|CLK_HAVEFLAG3|CLK_HAVEFLAG4);
2675 msyslog(LOG_ERR, "set_clock_fudge: default!");
2676 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2680 refclock_control(&addr, &clock_stat, (struct refclockstat *)0);
2683 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2689 * get_clkbug_info - get debugging info about a clock
2693 struct sockaddr_storage *srcadr,
2694 struct interface *inter,
2695 struct req_pkt *inpkt
2699 register struct info_clkbug *ic;
2700 register u_int32 *clkaddr;
2702 struct refclockbug bug;
2703 struct sockaddr_storage addr;
2704 struct sockaddr_in tmp_clock;
2706 memset((char *)&addr, 0, sizeof addr);
2707 addr.ss_family = AF_INET;
2708 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2709 addr.ss_len = SOCKLEN(&addr);
2711 NSRCPORT(&addr) = htons(NTP_PORT);
2712 items = INFO_NITEMS(inpkt->err_nitems);
2713 clkaddr = (u_int32 *) inpkt->data;
2715 ic = (struct info_clkbug *)prepare_pkt(srcadr, inter, inpkt,
2716 sizeof(struct info_clkbug));
2718 while (items-- > 0) {
2719 tmp_clock.sin_addr.s_addr = *clkaddr++;
2720 GET_INADDR(addr) = tmp_clock.sin_addr.s_addr;
2721 if (!ISREFCLOCKADR(&tmp_clock) ||
2722 findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2723 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2727 memset((char *)&bug, 0, sizeof bug);
2728 refclock_buginfo(&addr, &bug);
2729 if (bug.nvalues == 0 && bug.ntimes == 0) {
2730 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2734 ic->clockadr = tmp_clock.sin_addr.s_addr;
2736 if (i > NUMCBUGVALUES)
2738 ic->nvalues = (u_char)i;
2739 ic->svalues = htons((u_short) (bug.svalues & ((1<<i)-1)));
2741 ic->values[i] = htonl(bug.values[i]);
2744 if (i > NUMCBUGTIMES)
2746 ic->ntimes = (u_char)i;
2747 ic->stimes = htonl(bug.stimes);
2749 HTONL_FP(&bug.times[i], &ic->times[i]);
2752 ic = (struct info_clkbug *)more_pkt();