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 *));
102 static void get_if_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
103 static void do_if_reload P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
105 static void get_kernel_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
106 #endif /* KERNEL_PLL */
108 static void get_clock_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
109 static void set_clock_fudge P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
110 #endif /* REFCLOCK */
112 static void get_clkbug_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
113 #endif /* REFCLOCK */
118 static struct req_proc ntp_codes[] = {
119 { REQ_PEER_LIST, NOAUTH, 0, 0, peer_list },
120 { REQ_PEER_LIST_SUM, NOAUTH, 0, 0, peer_list_sum },
121 { REQ_PEER_INFO, NOAUTH, v4sizeof(struct info_peer_list),
122 sizeof(struct info_peer_list), peer_info},
123 { REQ_PEER_STATS, NOAUTH, v4sizeof(struct info_peer_list),
124 sizeof(struct info_peer_list), peer_stats},
125 { REQ_SYS_INFO, NOAUTH, 0, 0, sys_info },
126 { REQ_SYS_STATS, NOAUTH, 0, 0, sys_stats },
127 { REQ_IO_STATS, NOAUTH, 0, 0, io_stats },
128 { REQ_MEM_STATS, NOAUTH, 0, 0, mem_stats },
129 { REQ_LOOP_INFO, NOAUTH, 0, 0, loop_info },
130 { REQ_TIMER_STATS, NOAUTH, 0, 0, timer_stats },
131 { REQ_CONFIG, AUTH, v4sizeof(struct conf_peer),
132 sizeof(struct conf_peer), do_conf },
133 { REQ_UNCONFIG, AUTH, v4sizeof(struct conf_unpeer),
134 sizeof(struct conf_unpeer), do_unconf },
135 { REQ_SET_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags),
136 sizeof(struct conf_sys_flags), set_sys_flag },
137 { REQ_CLR_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags),
138 sizeof(struct conf_sys_flags), clr_sys_flag },
139 { REQ_GET_RESTRICT, NOAUTH, 0, 0, list_restrict },
140 { REQ_RESADDFLAGS, AUTH, v4sizeof(struct conf_restrict),
141 sizeof(struct conf_restrict), do_resaddflags },
142 { REQ_RESSUBFLAGS, AUTH, v4sizeof(struct conf_restrict),
143 sizeof(struct conf_restrict), do_ressubflags },
144 { REQ_UNRESTRICT, AUTH, v4sizeof(struct conf_restrict),
145 sizeof(struct conf_restrict), do_unrestrict },
146 { REQ_MON_GETLIST, NOAUTH, 0, 0, mon_getlist_0 },
147 { REQ_MON_GETLIST_1, NOAUTH, 0, 0, mon_getlist_1 },
148 { REQ_RESET_STATS, AUTH, sizeof(struct reset_flags), 0, reset_stats },
149 { REQ_RESET_PEER, AUTH, v4sizeof(struct conf_unpeer),
150 sizeof(struct conf_unpeer), reset_peer },
151 { REQ_REREAD_KEYS, AUTH, 0, 0, do_key_reread },
152 { REQ_TRUSTKEY, AUTH, sizeof(u_long), sizeof(u_long), trust_key },
153 { REQ_UNTRUSTKEY, AUTH, sizeof(u_long), sizeof(u_long), untrust_key },
154 { REQ_AUTHINFO, NOAUTH, 0, 0, get_auth_info },
155 { REQ_TRAPS, NOAUTH, 0, 0, req_get_traps },
156 { REQ_ADD_TRAP, AUTH, v4sizeof(struct conf_trap),
157 sizeof(struct conf_trap), req_set_trap },
158 { REQ_CLR_TRAP, AUTH, v4sizeof(struct conf_trap),
159 sizeof(struct conf_trap), req_clr_trap },
160 { REQ_REQUEST_KEY, AUTH, sizeof(u_long), sizeof(u_long),
162 { REQ_CONTROL_KEY, AUTH, sizeof(u_long), sizeof(u_long),
164 { REQ_GET_CTLSTATS, NOAUTH, 0, 0, get_ctl_stats },
166 { REQ_GET_KERNEL, NOAUTH, 0, 0, get_kernel_info },
169 { REQ_GET_CLOCKINFO, NOAUTH, sizeof(u_int32), sizeof(u_int32),
171 { REQ_SET_CLKFUDGE, AUTH, sizeof(struct conf_fudge),
172 sizeof(struct conf_fudge), set_clock_fudge },
173 { REQ_GET_CLKBUGINFO, NOAUTH, sizeof(u_int32), sizeof(u_int32),
176 { REQ_IF_STATS, AUTH, 0, 0, get_if_stats },
177 { REQ_IF_RELOAD, AUTH, 0, 0, do_if_reload },
179 { NO_REQUEST, NOAUTH, 0, 0, 0 }
184 * Authentication keyid used to authenticate requests. Zero means we
185 * don't allow writing anything.
187 keyid_t info_auth_keyid;
190 * Statistic counters to keep track of requests and responses.
192 u_long numrequests; /* number of requests we've received */
193 u_long numresppkts; /* number of resp packets sent with data */
195 u_long errorcounter[INFO_ERR_AUTH+1]; /* lazy way to count errors, indexed */
196 /* by the error code */
199 * A hack. To keep the authentication module clear of ntp-ism's, we
200 * include a time reset variable for its stats here.
202 static u_long auth_timereset;
205 * Response packet used by these routines. Also some state information
206 * so that we can handle packet formatting within a common set of
207 * subroutines. Note we try to enter data in place whenever possible,
208 * but the need to set the more bit correctly means we occasionally
209 * use the extra buffer and copy.
211 static struct resp_pkt rpkt;
216 static int databytes;
217 static char exbuf[RESP_DATA_SIZE];
218 static int usingexbuf;
219 static struct sockaddr_storage *toaddr;
220 static struct interface *frominter;
223 * init_request - initialize request data
233 info_auth_keyid = 0; /* by default, can't do this */
235 for (i = 0; i < sizeof(errorcounter)/sizeof(errorcounter[0]); i++)
241 * req_ack - acknowledge request with no data
245 struct sockaddr_storage *srcadr,
246 struct interface *inter,
247 struct req_pkt *inpkt,
254 rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, 0, reqver);
255 rpkt.auth_seq = AUTH_SEQ(0, 0);
256 rpkt.implementation = inpkt->implementation;
257 rpkt.request = inpkt->request;
258 rpkt.err_nitems = ERR_NITEMS(errcode, 0);
259 rpkt.mbz_itemsize = MBZ_ITEMSIZE(0);
262 * send packet and bump counters
264 sendpkt(srcadr, inter, -1, (struct pkt *)&rpkt, RESP_HEADER_SIZE);
265 errorcounter[errcode]++;
270 * prepare_pkt - prepare response packet for transmission, return pointer
271 * to storage for data item.
275 struct sockaddr_storage *srcadr,
276 struct interface *inter,
283 printf("request: preparing pkt\n");
287 * Fill in the implementation, request and itemsize fields
288 * since these won't change.
290 rpkt.implementation = pkt->implementation;
291 rpkt.request = pkt->request;
292 rpkt.mbz_itemsize = MBZ_ITEMSIZE(structsize);
295 * Compute the static data needed to carry on.
301 itemsize = structsize;
306 * return the beginning of the packet buffer.
308 return &rpkt.data[0];
313 * more_pkt - return a data pointer for a new item.
319 * If we were using the extra buffer, send the packet.
324 printf("request: sending pkt\n");
326 rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, MORE_BIT, reqver);
327 rpkt.auth_seq = AUTH_SEQ(0, seqno);
328 rpkt.err_nitems = htons((u_short)nitems);
329 sendpkt(toaddr, frominter, -1, (struct pkt *)&rpkt,
330 RESP_HEADER_SIZE+databytes);
334 * Copy data out of exbuf into the packet.
336 memmove(&rpkt.data[0], exbuf, (unsigned)itemsize);
343 databytes += itemsize;
345 if (databytes + itemsize <= RESP_DATA_SIZE) {
348 printf("request: giving him more data\n");
351 * More room in packet. Give him the
354 return &rpkt.data[databytes];
357 * No room in packet. Give him the extra
358 * buffer unless this was the last in the sequence.
362 printf("request: into extra buffer\n");
375 * flush_pkt - we're done, return remaining information.
382 printf("request: flushing packet, %d items\n", nitems);
385 * Must send the last packet. If nothing in here and nothing
386 * has been sent, send an error saying no data to be found.
388 if (seqno == 0 && nitems == 0)
389 req_ack(toaddr, frominter, (struct req_pkt *)&rpkt,
392 rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, 0, reqver);
393 rpkt.auth_seq = AUTH_SEQ(0, seqno);
394 rpkt.err_nitems = htons((u_short)nitems);
395 sendpkt(toaddr, frominter, -1, (struct pkt *)&rpkt,
396 RESP_HEADER_SIZE+databytes);
404 * process_private - process private mode (7) packets
408 struct recvbuf *rbufp,
412 static u_long quiet_until;
413 struct req_pkt *inpkt;
414 struct req_pkt_tail *tailinpkt;
415 struct sockaddr_storage *srcadr;
416 struct interface *inter;
417 struct req_proc *proc;
422 * Initialize pointers, for convenience
424 inpkt = (struct req_pkt *)&rbufp->recv_pkt;
425 srcadr = &rbufp->recv_srcadr;
426 inter = rbufp->dstadr;
430 printf("process_private: impl %d req %d\n",
431 inpkt->implementation, inpkt->request);
435 * Do some sanity checks on the packet. Return a format
439 if ( (++ec, ISRESPONSE(inpkt->rm_vn_mode))
440 || (++ec, ISMORE(inpkt->rm_vn_mode))
441 || (++ec, INFO_VERSION(inpkt->rm_vn_mode) > NTP_VERSION)
442 || (++ec, INFO_VERSION(inpkt->rm_vn_mode) < NTP_OLDVERSION)
443 || (++ec, INFO_SEQ(inpkt->auth_seq) != 0)
444 || (++ec, INFO_ERR(inpkt->err_nitems) != 0)
445 || (++ec, INFO_MBZ(inpkt->mbz_itemsize) != 0)
446 || (++ec, rbufp->recv_length < REQ_LEN_HDR)
449 if (current_time >= quiet_until) {
451 "process_private: drop test %d"
452 " failed, pkt from %s",
454 quiet_until = current_time + 60;
459 reqver = INFO_VERSION(inpkt->rm_vn_mode);
462 * Get the appropriate procedure list to search.
464 if (inpkt->implementation == IMPL_UNIV)
466 else if ((inpkt->implementation == IMPL_XNTPD) ||
467 (inpkt->implementation == IMPL_XNTPD_OLD))
470 req_ack(srcadr, inter, inpkt, INFO_ERR_IMPL);
475 * Search the list for the request codes. If it isn't one
476 * we know, return an error.
478 while (proc->request_code != NO_REQUEST) {
479 if (proc->request_code == (short) inpkt->request)
483 if (proc->request_code == NO_REQUEST) {
484 req_ack(srcadr, inter, inpkt, INFO_ERR_REQ);
490 printf("found request in tables\n");
494 * If we need data, check to see if we have some. If we
495 * don't, check to see that there is none (picky, picky).
498 /* This part is a bit tricky, we want to be sure that the size
499 * returned is either the old or the new size. We also can find
500 * out if the client can accept both types of messages this way.
502 * Handle the exception of REQ_CONFIG. It can have two data sizes.
504 temp_size = INFO_ITEMSIZE(inpkt->mbz_itemsize);
505 if ((temp_size != proc->sizeofitem &&
506 temp_size != proc->v6_sizeofitem) &&
507 !(inpkt->implementation == IMPL_XNTPD &&
508 inpkt->request == REQ_CONFIG &&
509 temp_size == sizeof(struct old_conf_peer))) {
512 printf("process_private: wrong item size, received %d, should be %d or %d\n",
513 temp_size, proc->sizeofitem, proc->v6_sizeofitem);
515 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
518 if ((proc->sizeofitem != 0) &&
519 ((temp_size * INFO_NITEMS(inpkt->err_nitems)) >
520 (rbufp->recv_length - REQ_LEN_HDR))) {
523 printf("process_private: not enough data\n");
525 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
529 switch (inpkt->implementation) {
531 client_v6_capable = 1;
534 client_v6_capable = 0;
537 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
542 * If we need to authenticate, do so. Note that an
543 * authenticatable packet must include a mac field, must
544 * have used key info_auth_keyid and must have included
545 * a time stamp in the appropriate field. The time stamp
546 * must be within INFO_TS_MAXSKEW of the receive
549 if (proc->needs_auth && sys_authenticate) {
553 if (rbufp->recv_length < (int)((REQ_LEN_HDR +
554 (INFO_ITEMSIZE(inpkt->mbz_itemsize) *
555 INFO_NITEMS(inpkt->err_nitems))
556 + sizeof(struct req_pkt_tail)))) {
557 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
559 tailinpkt = (struct req_pkt_tail *)((char *)&rbufp->recv_pkt +
560 rbufp->recv_length - sizeof(struct req_pkt_tail));
563 * If this guy is restricted from doing this, don't let him
564 * If wrong key was used, or packet doesn't have mac, return.
566 if (!INFO_IS_AUTH(inpkt->auth_seq) || info_auth_keyid == 0
567 || ntohl(tailinpkt->keyid) != info_auth_keyid) {
570 printf("failed auth %d info_auth_keyid %lu pkt keyid %lu\n",
571 INFO_IS_AUTH(inpkt->auth_seq),
572 (u_long)info_auth_keyid,
573 (u_long)ntohl(tailinpkt->keyid));
575 "process_private: failed auth %d info_auth_keyid %lu pkt keyid %lu\n",
576 INFO_IS_AUTH(inpkt->auth_seq),
577 (u_long)info_auth_keyid,
578 (u_long)ntohl(tailinpkt->keyid));
580 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
583 if (rbufp->recv_length > REQ_LEN_MAC) {
586 printf("bad pkt length %d\n",
589 msyslog(LOG_ERR, "process_private: bad pkt length %d",
591 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
594 if (!mod_okay || !authhavekey(info_auth_keyid)) {
597 printf("failed auth mod_okay %d\n", mod_okay);
599 "process_private: failed auth mod_okay %d\n",
602 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
607 * calculate absolute time difference between xmit time stamp
608 * and receive time stamp. If too large, too bad.
610 NTOHL_FP(&tailinpkt->tstamp, &ftmp);
611 L_SUB(&ftmp, &rbufp->recv_time);
612 LFPTOD(&ftmp, dtemp);
613 if (fabs(dtemp) >= INFO_TS_MAXSKEW) {
615 * He's a loser. Tell him.
619 printf("xmit/rcv timestamp delta > INFO_TS_MAXSKEW\n");
621 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
626 * So far so good. See if decryption works out okay.
628 if (!authdecrypt(info_auth_keyid, (u_int32 *)inpkt,
629 rbufp->recv_length - sizeof(struct req_pkt_tail) +
630 REQ_LEN_HDR, sizeof(struct req_pkt_tail) - REQ_LEN_HDR)) {
633 printf("authdecrypt failed\n");
635 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
642 printf("process_private: all okay, into handler\n");
646 * Packet is okay. Call the handler to send him data.
648 (proc->handler)(srcadr, inter, inpkt);
653 * peer_list - send a list of the peers
657 struct sockaddr_storage *srcadr,
658 struct interface *inter,
659 struct req_pkt *inpkt
662 register struct info_peer_list *ip;
663 register struct peer *pp;
665 register int skip = 0;
667 ip = (struct info_peer_list *)prepare_pkt(srcadr, inter, inpkt,
668 v6sizeof(struct info_peer_list));
669 for (i = 0; i < NTP_HASH_SIZE && ip != 0; i++) {
671 while (pp != 0 && ip != 0) {
672 if (pp->srcadr.ss_family == AF_INET6) {
673 if (client_v6_capable) {
674 ip->addr6 = GET_INADDR6(pp->srcadr);
682 ip->addr = GET_INADDR(pp->srcadr);
683 if (client_v6_capable)
689 ip->port = NSRCPORT(&pp->srcadr);
690 ip->hmode = pp->hmode;
692 if (pp->flags & FLAG_CONFIG)
693 ip->flags |= INFO_FLAG_CONFIG;
695 ip->flags |= INFO_FLAG_SYSPEER;
696 if (pp->status == CTL_PST_SEL_SYNCCAND)
697 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
698 if (pp->status >= CTL_PST_SEL_SYSPEER)
699 ip->flags |= INFO_FLAG_SHORTLIST;
700 ip = (struct info_peer_list *)more_pkt();
710 * peer_list_sum - return extended peer list
714 struct sockaddr_storage *srcadr,
715 struct interface *inter,
716 struct req_pkt *inpkt
719 register struct info_peer_summary *ips;
720 register struct peer *pp;
727 printf("wants peer list summary\n");
729 ips = (struct info_peer_summary *)prepare_pkt(srcadr, inter, inpkt,
730 v6sizeof(struct info_peer_summary));
731 for (i = 0; i < NTP_HASH_SIZE && ips != 0; i++) {
733 while (pp != 0 && ips != 0) {
736 printf("sum: got one\n");
739 * Be careful here not to return v6 peers when we
742 if (pp->srcadr.ss_family == AF_INET6) {
743 if (client_v6_capable) {
744 ips->srcadr6 = GET_INADDR6(pp->srcadr);
747 ips->dstadr6 = GET_INADDR6(pp->dstadr->sin);
749 memset(&ips->dstadr6, 0, sizeof(ips->dstadr6));
756 ips->srcadr = GET_INADDR(pp->srcadr);
757 if (client_v6_capable)
759 /* XXX PDM This code is buggy. Need to replace with a straightforward assignment */
762 ips->dstadr = (pp->processed) ?
763 pp->cast_flags == MDF_BCAST ?
764 GET_INADDR(pp->dstadr->bcast):
766 GET_INADDR(pp->dstadr->sin) ?
767 GET_INADDR(pp->dstadr->sin):
768 GET_INADDR(pp->dstadr->bcast):
769 1 : GET_INADDR(pp->dstadr->sin);
771 memset(&ips->dstadr, 0, sizeof(ips->dstadr));
777 ips->srcport = NSRCPORT(&pp->srcadr);
778 ips->stratum = pp->stratum;
779 ips->hpoll = pp->hpoll;
780 ips->ppoll = pp->ppoll;
781 ips->reach = pp->reach;
784 ips->flags |= INFO_FLAG_SYSPEER;
785 if (pp->flags & FLAG_CONFIG)
786 ips->flags |= INFO_FLAG_CONFIG;
787 if (pp->flags & FLAG_REFCLOCK)
788 ips->flags |= INFO_FLAG_REFCLOCK;
789 if (pp->flags & FLAG_AUTHENABLE)
790 ips->flags |= INFO_FLAG_AUTHENABLE;
791 if (pp->flags & FLAG_PREFER)
792 ips->flags |= INFO_FLAG_PREFER;
793 if (pp->flags & FLAG_BURST)
794 ips->flags |= INFO_FLAG_BURST;
795 if (pp->status == CTL_PST_SEL_SYNCCAND)
796 ips->flags |= INFO_FLAG_SEL_CANDIDATE;
797 if (pp->status >= CTL_PST_SEL_SYSPEER)
798 ips->flags |= INFO_FLAG_SHORTLIST;
799 ips->hmode = pp->hmode;
800 ips->delay = HTONS_FP(DTOFP(pp->delay));
801 DTOLFP(pp->offset, <mp);
802 HTONL_FP(<mp, &ips->offset);
803 ips->dispersion = HTONS_FP(DTOUFP(SQRT(pp->disp)));
806 ips = (struct info_peer_summary *)more_pkt();
814 * peer_info - send information for one or more peers
818 struct sockaddr_storage *srcadr,
819 struct interface *inter,
820 struct req_pkt *inpkt
823 register struct info_peer_list *ipl;
824 register struct peer *pp;
825 register struct info_peer *ip;
828 struct sockaddr_storage addr;
829 extern struct peer *sys_peer;
832 memset((char *)&addr, 0, sizeof addr);
833 items = INFO_NITEMS(inpkt->err_nitems);
834 ipl = (struct info_peer_list *) inpkt->data;
836 ip = (struct info_peer *)prepare_pkt(srcadr, inter, inpkt,
837 v6sizeof(struct info_peer));
838 while (items-- > 0 && ip != 0) {
839 memset((char *)&addr, 0, sizeof(addr));
840 NSRCPORT(&addr) = ipl->port;
841 if (client_v6_capable && ipl->v6_flag != 0) {
842 addr.ss_family = AF_INET6;
843 GET_INADDR6(addr) = ipl->addr6;
845 addr.ss_family = AF_INET;
846 GET_INADDR(addr) = ipl->addr;
848 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
849 addr.ss_len = SOCKLEN(&addr);
852 if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0)
854 if (pp->srcadr.ss_family == AF_INET6) {
856 ip->dstadr6 = pp->cast_flags == MDF_BCAST ?
857 GET_INADDR6(pp->dstadr->bcast) :
858 GET_INADDR6(pp->dstadr->sin);
860 memset(&ip->dstadr6, 0, sizeof(ip->dstadr6));
862 ip->srcadr6 = GET_INADDR6(pp->srcadr);
865 /* XXX PDM This code is buggy. Need to replace with a straightforward assignment */
867 ip->dstadr = (pp->processed) ?
868 pp->cast_flags == MDF_BCAST ?
869 GET_INADDR(pp->dstadr->bcast):
871 GET_INADDR(pp->dstadr->sin) ?
872 GET_INADDR(pp->dstadr->sin):
873 GET_INADDR(pp->dstadr->bcast):
874 2 : GET_INADDR(pp->dstadr->sin);
876 memset(&ip->dstadr, 0, sizeof(ip->dstadr));
878 ip->srcadr = GET_INADDR(pp->srcadr);
879 if (client_v6_capable)
882 ip->srcport = NSRCPORT(&pp->srcadr);
885 ip->flags |= INFO_FLAG_SYSPEER;
886 if (pp->flags & FLAG_CONFIG)
887 ip->flags |= INFO_FLAG_CONFIG;
888 if (pp->flags & FLAG_REFCLOCK)
889 ip->flags |= INFO_FLAG_REFCLOCK;
890 if (pp->flags & FLAG_AUTHENABLE)
891 ip->flags |= INFO_FLAG_AUTHENABLE;
892 if (pp->flags & FLAG_PREFER)
893 ip->flags |= INFO_FLAG_PREFER;
894 if (pp->flags & FLAG_BURST)
895 ip->flags |= INFO_FLAG_BURST;
896 if (pp->status == CTL_PST_SEL_SYNCCAND)
897 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
898 if (pp->status >= CTL_PST_SEL_SYSPEER)
899 ip->flags |= INFO_FLAG_SHORTLIST;
901 ip->hmode = pp->hmode;
902 ip->keyid = pp->keyid;
903 ip->stratum = pp->stratum;
904 ip->ppoll = pp->ppoll;
905 ip->hpoll = pp->hpoll;
906 ip->precision = pp->precision;
907 ip->version = pp->version;
908 ip->reach = pp->reach;
909 ip->unreach = (u_char) pp->unreach;
910 ip->flash = (u_char)pp->flash;
911 ip->flash2 = (u_short) pp->flash;
912 ip->estbdelay = HTONS_FP(DTOFP(pp->estbdelay));
914 ip->associd = htons(pp->associd);
915 ip->rootdelay = HTONS_FP(DTOUFP(pp->rootdelay));
916 ip->rootdispersion = HTONS_FP(DTOUFP(pp->rootdispersion));
917 ip->refid = pp->refid;
918 HTONL_FP(&pp->reftime, &ip->reftime);
919 HTONL_FP(&pp->org, &ip->org);
920 HTONL_FP(&pp->rec, &ip->rec);
921 HTONL_FP(&pp->xmt, &ip->xmt);
922 j = pp->filter_nextpt - 1;
923 for (i = 0; i < NTP_SHIFT; i++, j--) {
926 ip->filtdelay[i] = HTONS_FP(DTOFP(pp->filter_delay[j]));
927 DTOLFP(pp->filter_offset[j], <mp);
928 HTONL_FP(<mp, &ip->filtoffset[i]);
929 ip->order[i] = (u_char)((pp->filter_nextpt+NTP_SHIFT-1)
930 - pp->filter_order[i]);
931 if (ip->order[i] >= NTP_SHIFT)
932 ip->order[i] -= NTP_SHIFT;
934 DTOLFP(pp->offset, <mp);
935 HTONL_FP(<mp, &ip->offset);
936 ip->delay = HTONS_FP(DTOFP(pp->delay));
937 ip->dispersion = HTONS_FP(DTOUFP(SQRT(pp->disp)));
938 ip->selectdisp = HTONS_FP(DTOUFP(SQRT(pp->jitter)));
939 ip = (struct info_peer *)more_pkt();
946 * peer_stats - send statistics for one or more peers
950 struct sockaddr_storage *srcadr,
951 struct interface *inter,
952 struct req_pkt *inpkt
955 register struct info_peer_list *ipl;
956 register struct peer *pp;
957 register struct info_peer_stats *ip;
959 struct sockaddr_storage addr;
960 extern struct peer *sys_peer;
964 printf("peer_stats: called\n");
966 items = INFO_NITEMS(inpkt->err_nitems);
967 ipl = (struct info_peer_list *) inpkt->data;
968 ip = (struct info_peer_stats *)prepare_pkt(srcadr, inter, inpkt,
969 v6sizeof(struct info_peer_stats));
970 while (items-- > 0 && ip != 0) {
971 memset((char *)&addr, 0, sizeof(addr));
972 NSRCPORT(&addr) = ipl->port;
973 if (client_v6_capable && ipl->v6_flag) {
974 addr.ss_family = AF_INET6;
975 GET_INADDR6(addr) = ipl->addr6;
977 addr.ss_family = AF_INET;
978 GET_INADDR(addr) = ipl->addr;
980 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
981 addr.ss_len = SOCKLEN(&addr);
985 printf("peer_stats: looking for %s, %d, %d\n", stoa(&addr),
986 ipl->port, ((struct sockaddr_in6 *)&addr)->sin6_port);
988 ipl = (struct info_peer_list *)((char *)ipl +
989 INFO_ITEMSIZE(inpkt->mbz_itemsize));
991 if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0)
995 printf("peer_stats: found %s\n", stoa(&addr));
997 if (pp->srcadr.ss_family == AF_INET) {
999 ip->dstadr = (pp->processed) ?
1000 pp->cast_flags == MDF_BCAST ?
1001 GET_INADDR(pp->dstadr->bcast):
1003 GET_INADDR(pp->dstadr->sin) ?
1004 GET_INADDR(pp->dstadr->sin):
1005 GET_INADDR(pp->dstadr->bcast):
1008 memset(&ip->dstadr, 0, sizeof(ip->dstadr));
1010 ip->srcadr = GET_INADDR(pp->srcadr);
1011 if (client_v6_capable)
1015 ip->dstadr6 = pp->cast_flags == MDF_BCAST ?
1016 GET_INADDR6(pp->dstadr->bcast):
1017 GET_INADDR6(pp->dstadr->sin);
1019 memset(&ip->dstadr6, 0, sizeof(ip->dstadr6));
1021 ip->srcadr6 = GET_INADDR6(pp->srcadr);
1024 ip->srcport = NSRCPORT(&pp->srcadr);
1027 ip->flags |= INFO_FLAG_SYSPEER;
1028 if (pp->flags & FLAG_CONFIG)
1029 ip->flags |= INFO_FLAG_CONFIG;
1030 if (pp->flags & FLAG_REFCLOCK)
1031 ip->flags |= INFO_FLAG_REFCLOCK;
1032 if (pp->flags & FLAG_AUTHENABLE)
1033 ip->flags |= INFO_FLAG_AUTHENABLE;
1034 if (pp->flags & FLAG_PREFER)
1035 ip->flags |= INFO_FLAG_PREFER;
1036 if (pp->flags & FLAG_BURST)
1037 ip->flags |= INFO_FLAG_BURST;
1038 if (pp->flags & FLAG_IBURST)
1039 ip->flags |= INFO_FLAG_IBURST;
1040 if (pp->status == CTL_PST_SEL_SYNCCAND)
1041 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
1042 if (pp->status >= CTL_PST_SEL_SYSPEER)
1043 ip->flags |= INFO_FLAG_SHORTLIST;
1044 ip->flags = htons(ip->flags);
1045 ip->timereceived = htonl((u_int32)(current_time - pp->timereceived));
1046 ip->timetosend = htonl(pp->nextdate - current_time);
1047 ip->timereachable = htonl((u_int32)(current_time - pp->timereachable));
1048 ip->sent = htonl((u_int32)(pp->sent));
1049 ip->processed = htonl((u_int32)(pp->processed));
1050 ip->badauth = htonl((u_int32)(pp->badauth));
1051 ip->bogusorg = htonl((u_int32)(pp->bogusorg));
1052 ip->oldpkt = htonl((u_int32)(pp->oldpkt));
1053 ip->seldisp = htonl((u_int32)(pp->seldisptoolarge));
1054 ip->selbroken = htonl((u_int32)(pp->selbroken));
1055 ip->candidate = pp->status;
1056 ip = (struct info_peer_stats *)more_pkt();
1063 * sys_info - return system info
1067 struct sockaddr_storage *srcadr,
1068 struct interface *inter,
1069 struct req_pkt *inpkt
1072 register struct info_sys *is;
1074 is = (struct info_sys *)prepare_pkt(srcadr, inter, inpkt,
1075 v6sizeof(struct info_sys));
1077 if (sys_peer != 0) {
1078 if (sys_peer->srcadr.ss_family == AF_INET) {
1079 is->peer = GET_INADDR(sys_peer->srcadr);
1080 if (client_v6_capable)
1082 } else if (client_v6_capable) {
1083 is->peer6 = GET_INADDR6(sys_peer->srcadr);
1086 is->peer_mode = sys_peer->hmode;
1089 if (client_v6_capable) {
1095 is->leap = sys_leap;
1096 is->stratum = sys_stratum;
1097 is->precision = sys_precision;
1098 is->rootdelay = htonl(DTOFP(sys_rootdelay));
1099 is->rootdispersion = htonl(DTOUFP(sys_rootdispersion));
1100 is->frequency = htonl(DTOFP(sys_jitter));
1101 is->stability = htonl(DTOUFP(clock_stability));
1102 is->refid = sys_refid;
1103 HTONL_FP(&sys_reftime, &is->reftime);
1105 is->poll = sys_poll;
1108 if (sys_authenticate)
1109 is->flags |= INFO_FLAG_AUTHENTICATE;
1111 is->flags |= INFO_FLAG_BCLIENT;
1114 is->flags |= INFO_FLAG_CAL;
1115 #endif /* REFCLOCK */
1117 is->flags |= INFO_FLAG_KERNEL;
1118 if (mon_enabled != MON_OFF)
1119 is->flags |= INFO_FLAG_MONITOR;
1121 is->flags |= INFO_FLAG_NTP;
1123 is->flags |= INFO_FLAG_PPS_SYNC;
1125 is->flags |= INFO_FLAG_FILEGEN;
1126 is->bdelay = HTONS_FP(DTOFP(sys_bdelay));
1127 HTONL_UF(sys_authdelay.l_f, &is->authdelay);
1135 * sys_stats - return system statistics
1139 struct sockaddr_storage *srcadr,
1140 struct interface *inter,
1141 struct req_pkt *inpkt
1144 register struct info_sys_stats *ss;
1147 * Importations from the protocol module
1149 ss = (struct info_sys_stats *)prepare_pkt(srcadr, inter, inpkt,
1150 sizeof(struct info_sys_stats));
1151 ss->timeup = htonl((u_int32)current_time);
1152 ss->timereset = htonl((u_int32)(current_time - sys_stattime));
1153 ss->denied = htonl((u_int32)sys_restricted);
1154 ss->oldversionpkt = htonl((u_int32)sys_oldversionpkt);
1155 ss->newversionpkt = htonl((u_int32)sys_newversionpkt);
1156 ss->unknownversion = htonl((u_int32)sys_unknownversion);
1157 ss->badlength = htonl((u_int32)sys_badlength);
1158 ss->processed = htonl((u_int32)sys_processed);
1159 ss->badauth = htonl((u_int32)sys_badauth);
1160 ss->limitrejected = htonl((u_int32)sys_limitrejected);
1161 ss->received = htonl((u_int32)sys_received);
1168 * mem_stats - return memory statistics
1172 struct sockaddr_storage *srcadr,
1173 struct interface *inter,
1174 struct req_pkt *inpkt
1177 register struct info_mem_stats *ms;
1181 * Importations from the peer module
1183 extern int peer_hash_count[NTP_HASH_SIZE];
1184 extern int peer_free_count;
1185 extern u_long peer_timereset;
1186 extern u_long findpeer_calls;
1187 extern u_long peer_allocations;
1188 extern u_long peer_demobilizations;
1189 extern int total_peer_structs;
1191 ms = (struct info_mem_stats *)prepare_pkt(srcadr, inter, inpkt,
1192 sizeof(struct info_mem_stats));
1194 ms->timereset = htonl((u_int32)(current_time - peer_timereset));
1195 ms->totalpeermem = htons((u_short)total_peer_structs);
1196 ms->freepeermem = htons((u_short)peer_free_count);
1197 ms->findpeer_calls = htonl((u_int32)findpeer_calls);
1198 ms->allocations = htonl((u_int32)peer_allocations);
1199 ms->demobilizations = htonl((u_int32)peer_demobilizations);
1201 for (i = 0; i < NTP_HASH_SIZE; i++) {
1202 if (peer_hash_count[i] > 255)
1203 ms->hashcount[i] = 255;
1205 ms->hashcount[i] = (u_char)peer_hash_count[i];
1214 * io_stats - return io statistics
1218 struct sockaddr_storage *srcadr,
1219 struct interface *inter,
1220 struct req_pkt *inpkt
1223 register struct info_io_stats *io;
1226 * Importations from the io module
1228 extern u_long io_timereset;
1230 io = (struct info_io_stats *)prepare_pkt(srcadr, inter, inpkt,
1231 sizeof(struct info_io_stats));
1233 io->timereset = htonl((u_int32)(current_time - io_timereset));
1234 io->totalrecvbufs = htons((u_short) total_recvbuffs());
1235 io->freerecvbufs = htons((u_short) free_recvbuffs());
1236 io->fullrecvbufs = htons((u_short) full_recvbuffs());
1237 io->lowwater = htons((u_short) lowater_additions());
1238 io->dropped = htonl((u_int32)packets_dropped);
1239 io->ignored = htonl((u_int32)packets_ignored);
1240 io->received = htonl((u_int32)packets_received);
1241 io->sent = htonl((u_int32)packets_sent);
1242 io->notsent = htonl((u_int32)packets_notsent);
1243 io->interrupts = htonl((u_int32)handler_calls);
1244 io->int_received = htonl((u_int32)handler_pkts);
1252 * timer_stats - return timer statistics
1256 struct sockaddr_storage *srcadr,
1257 struct interface *inter,
1258 struct req_pkt *inpkt
1261 register struct info_timer_stats *ts;
1264 * Importations from the timer module
1266 extern u_long timer_timereset;
1267 extern u_long timer_overflows;
1268 extern u_long timer_xmtcalls;
1270 ts = (struct info_timer_stats *)prepare_pkt(srcadr, inter, inpkt,
1271 sizeof(struct info_timer_stats));
1273 ts->timereset = htonl((u_int32)(current_time - timer_timereset));
1274 ts->alarms = htonl((u_int32)alarm_overflow);
1275 ts->overflows = htonl((u_int32)timer_overflows);
1276 ts->xmtcalls = htonl((u_int32)timer_xmtcalls);
1284 * loop_info - return the current state of the loop filter
1288 struct sockaddr_storage *srcadr,
1289 struct interface *inter,
1290 struct req_pkt *inpkt
1293 register struct info_loop *li;
1297 * Importations from the loop filter module
1299 extern double last_offset;
1300 extern double drift_comp;
1301 extern int tc_counter;
1302 extern u_long sys_clocktime;
1304 li = (struct info_loop *)prepare_pkt(srcadr, inter, inpkt,
1305 sizeof(struct info_loop));
1307 DTOLFP(last_offset, <mp);
1308 HTONL_FP(<mp, &li->last_offset);
1309 DTOLFP(drift_comp * 1e6, <mp);
1310 HTONL_FP(<mp, &li->drift_comp);
1311 li->compliance = htonl((u_int32)(tc_counter));
1312 li->watchdog_timer = htonl((u_int32)(current_time - sys_clocktime));
1320 * do_conf - add a peer to the configuration list
1324 struct sockaddr_storage *srcadr,
1325 struct interface *inter,
1326 struct req_pkt *inpkt
1329 static u_long soonest_ifrescan_time = 0;
1332 struct conf_peer *cp;
1333 struct conf_peer temp_cp;
1334 struct sockaddr_storage peeraddr;
1335 struct sockaddr_in tmp_clock;
1338 * Do a check of everything to see that it looks
1339 * okay. If not, complain about it. Note we are
1342 items = INFO_NITEMS(inpkt->err_nitems);
1343 cp = (struct conf_peer *)inpkt->data;
1344 memset(&temp_cp, 0, sizeof(struct conf_peer));
1345 memcpy(&temp_cp, (char *)cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1347 while (items-- > 0 && !fl) {
1348 if (((temp_cp.version) > NTP_VERSION)
1349 || ((temp_cp.version) < NTP_OLDVERSION))
1351 if (temp_cp.hmode != MODE_ACTIVE
1352 && temp_cp.hmode != MODE_CLIENT
1353 && temp_cp.hmode != MODE_BROADCAST)
1355 if (temp_cp.flags & ~(CONF_FLAG_AUTHENABLE | CONF_FLAG_PREFER
1356 | CONF_FLAG_BURST | CONF_FLAG_IBURST | CONF_FLAG_SKEY))
1358 cp = (struct conf_peer *)
1359 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1363 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1368 * Looks okay, try it out
1370 items = INFO_NITEMS(inpkt->err_nitems);
1371 cp = (struct conf_peer *)inpkt->data;
1373 while (items-- > 0) {
1374 memset(&temp_cp, 0, sizeof(struct conf_peer));
1375 memcpy(&temp_cp, (char *)cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1376 memset((char *)&peeraddr, 0, sizeof(struct sockaddr_storage));
1379 if (temp_cp.flags & CONF_FLAG_AUTHENABLE)
1380 fl |= FLAG_AUTHENABLE;
1381 if (temp_cp.flags & CONF_FLAG_PREFER)
1383 if (temp_cp.flags & CONF_FLAG_BURST)
1385 if (temp_cp.flags & CONF_FLAG_IBURST)
1387 if (temp_cp.flags & CONF_FLAG_SKEY)
1390 if (client_v6_capable && temp_cp.v6_flag != 0) {
1391 peeraddr.ss_family = AF_INET6;
1392 GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
1394 peeraddr.ss_family = AF_INET;
1395 GET_INADDR(peeraddr) = temp_cp.peeraddr;
1397 * Make sure the address is valid
1399 tmp_clock = *CAST_V4(peeraddr);
1402 !ISREFCLOCKADR(&tmp_clock) &&
1404 ISBADADR(&tmp_clock)) {
1405 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1410 NSRCPORT(&peeraddr) = htons(NTP_PORT);
1411 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1412 peeraddr.ss_len = SOCKLEN(&peeraddr);
1415 /* XXX W2DO? minpoll/maxpoll arguments ??? */
1416 if (peer_config(&peeraddr, (struct interface *)0,
1417 temp_cp.hmode, temp_cp.version, temp_cp.minpoll,
1418 temp_cp.maxpoll, fl, temp_cp.ttl, temp_cp.keyid,
1420 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1425 * ntp_intres.c uses REQ_CONFIG/doconf() to add each
1426 * server after its name is resolved. If we have been
1427 * disconnected from the network, it may notice the
1428 * network has returned and add the first server while
1429 * the relevant interface is still disabled, awaiting
1430 * the next interface rescan. To get things moving
1431 * more quickly, trigger an interface scan now, except
1432 * if we have done so in the last half minute.
1434 if (soonest_ifrescan_time < current_time) {
1435 soonest_ifrescan_time = current_time + 30;
1436 timer_interfacetimeout(current_time);
1437 DPRINTF(1, ("do_conf triggering interface rescan\n"));
1440 cp = (struct conf_peer *)
1441 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1444 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1450 * dns_a - Snarf DNS info for an association ID
1454 struct sockaddr_storage *srcadr,
1455 struct interface *inter,
1456 struct req_pkt *inpkt
1459 register struct info_dns_assoc *dp;
1461 struct sockaddr_in peeraddr;
1464 * Do a check of everything to see that it looks
1465 * okay. If not, complain about it. Note we are
1468 items = INFO_NITEMS(inpkt->err_nitems);
1469 dp = (struct info_dns_assoc *)inpkt->data;
1472 * Looks okay, try it out
1474 items = INFO_NITEMS(inpkt->err_nitems);
1475 dp = (struct info_dns_assoc *)inpkt->data;
1476 memset((char *)&peeraddr, 0, sizeof(struct sockaddr_in));
1477 peeraddr.sin_family = AF_INET;
1478 peeraddr.sin_port = htons(NTP_PORT);
1481 * Make sure the address is valid
1485 !ISREFCLOCKADR(&peeraddr) &&
1487 ISBADADR(&peeraddr)) {
1489 msyslog(LOG_ERR, "dns_a: !ISREFCLOCK && ISBADADR");
1491 msyslog(LOG_ERR, "dns_a: ISBADADR");
1493 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1497 while (items-- > 0) {
1503 associd = dp->associd;
1504 peer = findpeerbyassoc(associd);
1505 if (peer == 0 || peer->flags & FLAG_REFCLOCK) {
1506 msyslog(LOG_ERR, "dns_a: %s",
1509 : "peer->flags & FLAG_REFCLOCK");
1512 peeraddr.sin_addr.s_addr = dp->peeraddr;
1513 for (hnl = 0; dp->hostname[hnl] && hnl < sizeof dp->hostname; ++hnl) ;
1514 if (hnl >= sizeof dp->hostname) {
1515 msyslog(LOG_ERR, "dns_a: hnl (%ld) >= %ld",
1516 (long)hnl, (long)sizeof dp->hostname);
1520 msyslog(LOG_INFO, "dns_a: <%s> for %s, AssocID %d, bogon %d",
1522 stoa((struct sockaddr_storage *)&peeraddr), associd,
1526 /* If it didn't work */
1527 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1532 crypto_public(peer, dp->hostname);
1540 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1545 * do_unconf - remove a peer from the configuration list
1549 struct sockaddr_storage *srcadr,
1550 struct interface *inter,
1551 struct req_pkt *inpkt
1554 register struct conf_unpeer *cp;
1555 struct conf_unpeer temp_cp;
1557 register struct peer *peer;
1558 struct sockaddr_storage peeraddr;
1562 * This is a bit unstructured, but I like to be careful.
1563 * We check to see that every peer exists and is actually
1564 * configured. If so, we remove them. If not, we return
1567 items = INFO_NITEMS(inpkt->err_nitems);
1568 cp = (struct conf_unpeer *)inpkt->data;
1571 while (items-- > 0 && !bad) {
1572 memset(&temp_cp, 0, sizeof(temp_cp));
1573 memset(&peeraddr, 0, sizeof(peeraddr));
1574 memcpy(&temp_cp, cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1575 if (client_v6_capable && temp_cp.v6_flag != 0) {
1576 peeraddr.ss_family = AF_INET6;
1577 GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
1579 peeraddr.ss_family = AF_INET;
1580 GET_INADDR(peeraddr) = temp_cp.peeraddr;
1582 NSRCPORT(&peeraddr) = htons(NTP_PORT);
1583 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1584 peeraddr.ss_len = SOCKLEN(&peeraddr);
1587 peer = (struct peer *)0;
1590 printf("searching for %s\n", stoa(&peeraddr));
1593 peer = findexistingpeer(&peeraddr, peer, -1);
1594 if (peer == (struct peer *)0)
1596 if (peer->flags & FLAG_CONFIG)
1601 cp = (struct conf_unpeer *)
1602 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1606 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1611 * Now do it in earnest.
1614 items = INFO_NITEMS(inpkt->err_nitems);
1615 cp = (struct conf_unpeer *)inpkt->data;
1616 while (items-- > 0) {
1617 memset(&temp_cp, 0, sizeof(temp_cp));
1618 memset(&peeraddr, 0, sizeof(peeraddr));
1619 memcpy(&temp_cp, cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1620 if (client_v6_capable && temp_cp.v6_flag != 0) {
1621 peeraddr.ss_family = AF_INET6;
1622 GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
1624 peeraddr.ss_family = AF_INET;
1625 GET_INADDR(peeraddr) = temp_cp.peeraddr;
1627 NSRCPORT(&peeraddr) = htons(NTP_PORT);
1628 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1629 peeraddr.ss_len = SOCKLEN(&peeraddr);
1631 peer_unconfig(&peeraddr, (struct interface *)0, -1);
1632 cp = (struct conf_unpeer *)
1633 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1636 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1641 * set_sys_flag - set system flags
1645 struct sockaddr_storage *srcadr,
1646 struct interface *inter,
1647 struct req_pkt *inpkt
1650 setclr_flags(srcadr, inter, inpkt, 1);
1655 * clr_sys_flag - clear system flags
1659 struct sockaddr_storage *srcadr,
1660 struct interface *inter,
1661 struct req_pkt *inpkt
1664 setclr_flags(srcadr, inter, inpkt, 0);
1669 * setclr_flags - do the grunge work of flag setting/clearing
1673 struct sockaddr_storage *srcadr,
1674 struct interface *inter,
1675 struct req_pkt *inpkt,
1679 register u_int flags;
1680 int prev_kern_enable;
1682 prev_kern_enable = kern_enable;
1683 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
1684 msyslog(LOG_ERR, "setclr_flags: err_nitems > 1");
1685 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1689 flags = ((struct conf_sys_flags *)inpkt->data)->flags;
1690 flags = ntohl(flags);
1692 if (flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
1693 SYS_FLAG_NTP | SYS_FLAG_KERNEL | SYS_FLAG_MONITOR |
1694 SYS_FLAG_FILEGEN | SYS_FLAG_AUTH | SYS_FLAG_CAL)) {
1695 msyslog(LOG_ERR, "setclr_flags: extra flags: %#x",
1696 flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
1697 SYS_FLAG_NTP | SYS_FLAG_KERNEL |
1698 SYS_FLAG_MONITOR | SYS_FLAG_FILEGEN |
1699 SYS_FLAG_AUTH | SYS_FLAG_CAL));
1700 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1704 if (flags & SYS_FLAG_BCLIENT)
1705 proto_config(PROTO_BROADCLIENT, set, 0., NULL);
1706 if (flags & SYS_FLAG_PPS)
1707 proto_config(PROTO_PPS, set, 0., NULL);
1708 if (flags & SYS_FLAG_NTP)
1709 proto_config(PROTO_NTP, set, 0., NULL);
1710 if (flags & SYS_FLAG_KERNEL)
1711 proto_config(PROTO_KERNEL, set, 0., NULL);
1712 if (flags & SYS_FLAG_MONITOR)
1713 proto_config(PROTO_MONITOR, set, 0., NULL);
1714 if (flags & SYS_FLAG_FILEGEN)
1715 proto_config(PROTO_FILEGEN, set, 0., NULL);
1716 if (flags & SYS_FLAG_AUTH)
1717 proto_config(PROTO_AUTHENTICATE, set, 0., NULL);
1718 if (flags & SYS_FLAG_CAL)
1719 proto_config(PROTO_CAL, set, 0., NULL);
1720 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1722 /* Reset the kernel ntp parameters if the kernel flag changed. */
1723 if (prev_kern_enable && !kern_enable)
1724 loop_config(LOOP_KERN_CLEAR, 0.0);
1725 if (!prev_kern_enable && kern_enable)
1726 loop_config(LOOP_DRIFTCOMP, drift_comp);
1731 * list_restrict - return the restrict list
1735 struct sockaddr_storage *srcadr,
1736 struct interface *inter,
1737 struct req_pkt *inpkt
1740 register struct info_restrict *ir;
1741 register struct restrictlist *rl;
1742 register struct restrictlist6 *rl6;
1746 printf("wants restrict list summary\n");
1749 ir = (struct info_restrict *)prepare_pkt(srcadr, inter, inpkt,
1750 v6sizeof(struct info_restrict));
1752 for (rl = restrictlist; rl != 0 && ir != 0; rl = rl->next) {
1753 ir->addr = htonl(rl->addr);
1754 if (client_v6_capable)
1756 ir->mask = htonl(rl->mask);
1757 ir->count = htonl((u_int32)rl->count);
1758 ir->flags = htons(rl->flags);
1759 ir->mflags = htons(rl->mflags);
1760 ir = (struct info_restrict *)more_pkt();
1762 if (client_v6_capable)
1763 for (rl6 = restrictlist6; rl6 != 0 && ir != 0; rl6 = rl6->next) {
1764 ir->addr6 = rl6->addr6;
1765 ir->mask6 = rl6->mask6;
1767 ir->count = htonl((u_int32)rl6->count);
1768 ir->flags = htons(rl6->flags);
1769 ir->mflags = htons(rl6->mflags);
1770 ir = (struct info_restrict *)more_pkt();
1778 * do_resaddflags - add flags to a restrict entry (or create one)
1782 struct sockaddr_storage *srcadr,
1783 struct interface *inter,
1784 struct req_pkt *inpkt
1787 do_restrict(srcadr, inter, inpkt, RESTRICT_FLAGS);
1793 * do_ressubflags - remove flags from a restrict entry
1797 struct sockaddr_storage *srcadr,
1798 struct interface *inter,
1799 struct req_pkt *inpkt
1802 do_restrict(srcadr, inter, inpkt, RESTRICT_UNFLAG);
1807 * do_unrestrict - remove a restrict entry from the list
1811 struct sockaddr_storage *srcadr,
1812 struct interface *inter,
1813 struct req_pkt *inpkt
1816 do_restrict(srcadr, inter, inpkt, RESTRICT_REMOVE);
1824 * do_restrict - do the dirty stuff of dealing with restrictions
1828 struct sockaddr_storage *srcadr,
1829 struct interface *inter,
1830 struct req_pkt *inpkt,
1834 register struct conf_restrict *cr;
1836 struct sockaddr_storage matchaddr;
1837 struct sockaddr_storage matchmask;
1841 * Do a check of the flags to make sure that only
1842 * the NTPPORT flag is set, if any. If not, complain
1843 * about it. Note we are very picky here.
1845 items = INFO_NITEMS(inpkt->err_nitems);
1846 cr = (struct conf_restrict *)inpkt->data;
1849 cr->flags = ntohs(cr->flags);
1850 cr->mflags = ntohs(cr->mflags);
1851 while (items-- > 0 && !bad) {
1852 if (cr->mflags & ~(RESM_NTPONLY))
1854 if (cr->flags & ~(RES_ALLFLAGS))
1856 if (cr->mask != htonl(INADDR_ANY)) {
1857 if (client_v6_capable && cr->v6_flag != 0) {
1858 if (IN6_IS_ADDR_UNSPECIFIED(&cr->addr6))
1861 if (cr->addr == htonl(INADDR_ANY))
1864 cr = (struct conf_restrict *)((char *)cr +
1865 INFO_ITEMSIZE(inpkt->mbz_itemsize));
1869 msyslog(LOG_ERR, "do_restrict: bad = %#x", bad);
1870 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1875 * Looks okay, try it out
1877 items = INFO_NITEMS(inpkt->err_nitems);
1878 cr = (struct conf_restrict *)inpkt->data;
1879 memset((char *)&matchaddr, 0, sizeof(struct sockaddr_storage));
1880 memset((char *)&matchmask, 0, sizeof(struct sockaddr_storage));
1882 while (items-- > 0) {
1883 if (client_v6_capable && cr->v6_flag != 0) {
1884 GET_INADDR6(matchaddr) = cr->addr6;
1885 GET_INADDR6(matchmask) = cr->mask6;
1886 matchaddr.ss_family = AF_INET6;
1887 matchmask.ss_family = AF_INET6;
1889 GET_INADDR(matchaddr) = cr->addr;
1890 GET_INADDR(matchmask) = cr->mask;
1891 matchaddr.ss_family = AF_INET;
1892 matchmask.ss_family = AF_INET;
1894 hack_restrict(op, &matchaddr, &matchmask, cr->mflags,
1899 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1904 * mon_getlist - return monitor data
1908 struct sockaddr_storage *srcadr,
1909 struct interface *inter,
1910 struct req_pkt *inpkt
1913 register struct info_monitor *im;
1914 register struct mon_data *md;
1915 extern struct mon_data mon_mru_list;
1916 extern int mon_enabled;
1920 printf("wants monitor 0 list\n");
1925 im = (struct info_monitor *)prepare_pkt(srcadr, inter, inpkt,
1926 v6sizeof(struct info_monitor));
1927 for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0;
1928 md = md->mru_next) {
1929 im->lasttime = htonl((u_int32)md->avg_interval);
1930 im->firsttime = htonl((u_int32)(current_time - md->lasttime));
1931 im->lastdrop = htonl((u_int32)md->drop_count);
1932 im->count = htonl((u_int32)(md->count));
1933 if (md->rmtadr.ss_family == AF_INET6) {
1934 if (!client_v6_capable)
1936 im->addr6 = GET_INADDR6(md->rmtadr);
1939 im->addr = GET_INADDR(md->rmtadr);
1940 if (client_v6_capable)
1943 im->port = md->rmtport;
1944 im->mode = md->mode;
1945 im->version = md->version;
1946 im = (struct info_monitor *)more_pkt();
1952 * mon_getlist - return monitor data
1956 struct sockaddr_storage *srcadr,
1957 struct interface *inter,
1958 struct req_pkt *inpkt
1961 register struct info_monitor_1 *im;
1962 register struct mon_data *md;
1963 extern struct mon_data mon_mru_list;
1964 extern int mon_enabled;
1969 im = (struct info_monitor_1 *)prepare_pkt(srcadr, inter, inpkt,
1970 v6sizeof(struct info_monitor_1));
1971 for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0;
1972 md = md->mru_next) {
1973 im->lasttime = htonl((u_int32)md->avg_interval);
1974 im->firsttime = htonl((u_int32)(current_time - md->lasttime));
1975 im->lastdrop = htonl((u_int32)md->drop_count);
1976 im->count = htonl((u_int32)md->count);
1977 if (md->rmtadr.ss_family == AF_INET6) {
1978 if (!client_v6_capable)
1980 im->addr6 = GET_INADDR6(md->rmtadr);
1982 im->daddr6 = GET_INADDR6(md->interface->sin);
1984 im->addr = GET_INADDR(md->rmtadr);
1985 if (client_v6_capable)
1987 im->daddr = (md->cast_flags == MDF_BCAST)
1988 ? GET_INADDR(md->interface->bcast)
1990 ? (GET_INADDR(md->interface->sin)
1991 ? GET_INADDR(md->interface->sin)
1992 : GET_INADDR(md->interface->bcast))
1995 im->flags = htonl(md->cast_flags);
1996 im->port = md->rmtport;
1997 im->mode = md->mode;
1998 im->version = md->version;
1999 im = (struct info_monitor_1 *)more_pkt();
2005 * Module entry points and the flags they correspond with
2007 struct reset_entry {
2008 int flag; /* flag this corresponds to */
2009 void (*handler) P((void)); /* routine to handle request */
2012 struct reset_entry reset_entries[] = {
2013 { RESET_FLAG_ALLPEERS, peer_all_reset },
2014 { RESET_FLAG_IO, io_clr_stats },
2015 { RESET_FLAG_SYS, proto_clr_stats },
2016 { RESET_FLAG_MEM, peer_clr_stats },
2017 { RESET_FLAG_TIMER, timer_clr_stats },
2018 { RESET_FLAG_AUTH, reset_auth_stats },
2019 { RESET_FLAG_CTL, ctl_clr_stats },
2024 * reset_stats - reset statistic counters here and there
2028 struct sockaddr_storage *srcadr,
2029 struct interface *inter,
2030 struct req_pkt *inpkt
2034 struct reset_entry *rent;
2036 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2037 msyslog(LOG_ERR, "reset_stats: err_nitems > 1");
2038 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2042 flags = ((struct reset_flags *)inpkt->data)->flags;
2043 flags = ntohl(flags);
2045 if (flags & ~RESET_ALLFLAGS) {
2046 msyslog(LOG_ERR, "reset_stats: reset leaves %#lx",
2047 flags & ~RESET_ALLFLAGS);
2048 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2052 for (rent = reset_entries; rent->flag != 0; rent++) {
2053 if (flags & rent->flag)
2056 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2061 * reset_peer - clear a peer's statistics
2065 struct sockaddr_storage *srcadr,
2066 struct interface *inter,
2067 struct req_pkt *inpkt
2070 register struct conf_unpeer *cp;
2072 register struct peer *peer;
2073 struct sockaddr_storage peeraddr;
2077 * We check first to see that every peer exists. If not,
2078 * we return an error.
2081 items = INFO_NITEMS(inpkt->err_nitems);
2082 cp = (struct conf_unpeer *)inpkt->data;
2085 while (items-- > 0 && !bad) {
2086 memset((char *)&peeraddr, 0, sizeof(peeraddr));
2087 if (client_v6_capable && cp->v6_flag != 0) {
2088 GET_INADDR6(peeraddr) = cp->peeraddr6;
2089 peeraddr.ss_family = AF_INET6;
2091 GET_INADDR(peeraddr) = cp->peeraddr;
2092 peeraddr.ss_family = AF_INET;
2094 NSRCPORT(&peeraddr) = htons(NTP_PORT);
2095 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2096 peeraddr.ss_len = SOCKLEN(&peeraddr);
2098 peer = findexistingpeer(&peeraddr, (struct peer *)0, -1);
2099 if (peer == (struct peer *)0)
2101 cp = (struct conf_unpeer *)((char *)cp +
2102 INFO_ITEMSIZE(inpkt->mbz_itemsize));
2106 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2111 * Now do it in earnest.
2114 items = INFO_NITEMS(inpkt->err_nitems);
2115 cp = (struct conf_unpeer *)inpkt->data;
2116 while (items-- > 0) {
2117 memset((char *)&peeraddr, 0, sizeof(peeraddr));
2118 if (client_v6_capable && cp->v6_flag != 0) {
2119 GET_INADDR6(peeraddr) = cp->peeraddr6;
2120 peeraddr.ss_family = AF_INET6;
2122 GET_INADDR(peeraddr) = cp->peeraddr;
2123 peeraddr.ss_family = AF_INET;
2125 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2126 peeraddr.ss_len = SOCKLEN(&peeraddr);
2128 peer = findexistingpeer(&peeraddr, (struct peer *)0, -1);
2131 peer = findexistingpeer(&peeraddr, (struct peer *)peer, -1);
2133 cp = (struct conf_unpeer *)((char *)cp +
2134 INFO_ITEMSIZE(inpkt->mbz_itemsize));
2137 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2142 * do_key_reread - reread the encryption key file
2146 struct sockaddr_storage *srcadr,
2147 struct interface *inter,
2148 struct req_pkt *inpkt
2152 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2157 * trust_key - make one or more keys trusted
2161 struct sockaddr_storage *srcadr,
2162 struct interface *inter,
2163 struct req_pkt *inpkt
2166 do_trustkey(srcadr, inter, inpkt, 1);
2171 * untrust_key - make one or more keys untrusted
2175 struct sockaddr_storage *srcadr,
2176 struct interface *inter,
2177 struct req_pkt *inpkt
2180 do_trustkey(srcadr, inter, inpkt, 0);
2185 * do_trustkey - make keys either trustable or untrustable
2189 struct sockaddr_storage *srcadr,
2190 struct interface *inter,
2191 struct req_pkt *inpkt,
2195 register u_long *kp;
2198 items = INFO_NITEMS(inpkt->err_nitems);
2199 kp = (u_long *)inpkt->data;
2200 while (items-- > 0) {
2201 authtrust(*kp, trust);
2205 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2210 * get_auth_info - return some stats concerning the authentication module
2214 struct sockaddr_storage *srcadr,
2215 struct interface *inter,
2216 struct req_pkt *inpkt
2219 register struct info_auth *ia;
2222 * Importations from the authentication module
2224 extern u_long authnumkeys;
2225 extern int authnumfreekeys;
2226 extern u_long authkeylookups;
2227 extern u_long authkeynotfound;
2228 extern u_long authencryptions;
2229 extern u_long authdecryptions;
2230 extern u_long authkeyuncached;
2231 extern u_long authkeyexpired;
2233 ia = (struct info_auth *)prepare_pkt(srcadr, inter, inpkt,
2234 sizeof(struct info_auth));
2236 ia->numkeys = htonl((u_int32)authnumkeys);
2237 ia->numfreekeys = htonl((u_int32)authnumfreekeys);
2238 ia->keylookups = htonl((u_int32)authkeylookups);
2239 ia->keynotfound = htonl((u_int32)authkeynotfound);
2240 ia->encryptions = htonl((u_int32)authencryptions);
2241 ia->decryptions = htonl((u_int32)authdecryptions);
2242 ia->keyuncached = htonl((u_int32)authkeyuncached);
2243 ia->expired = htonl((u_int32)authkeyexpired);
2244 ia->timereset = htonl((u_int32)(current_time - auth_timereset));
2253 * reset_auth_stats - reset the authentication stat counters. Done here
2254 * to keep ntp-isms out of the authentication module
2257 reset_auth_stats(void)
2260 * Importations from the authentication module
2262 extern u_long authkeylookups;
2263 extern u_long authkeynotfound;
2264 extern u_long authencryptions;
2265 extern u_long authdecryptions;
2266 extern u_long authkeyuncached;
2269 authkeynotfound = 0;
2270 authencryptions = 0;
2271 authdecryptions = 0;
2272 authkeyuncached = 0;
2273 auth_timereset = current_time;
2278 * req_get_traps - return information about current trap holders
2282 struct sockaddr_storage *srcadr,
2283 struct interface *inter,
2284 struct req_pkt *inpkt
2287 register struct info_trap *it;
2288 register struct ctl_trap *tr;
2292 * Imported from the control module
2294 extern struct ctl_trap ctl_trap[];
2295 extern int num_ctl_traps;
2297 if (num_ctl_traps == 0) {
2298 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2302 it = (struct info_trap *)prepare_pkt(srcadr, inter, inpkt,
2303 v6sizeof(struct info_trap));
2305 for (i = 0, tr = ctl_trap; i < CTL_MAXTRAPS; i++, tr++) {
2306 if (tr->tr_flags & TRAP_INUSE) {
2307 if (tr->tr_addr.ss_family == AF_INET) {
2308 if (tr->tr_localaddr == any_interface)
2309 it->local_address = 0;
2312 = GET_INADDR(tr->tr_localaddr->sin);
2313 it->trap_address = GET_INADDR(tr->tr_addr);
2314 if (client_v6_capable)
2317 if (!client_v6_capable)
2320 = GET_INADDR6(tr->tr_localaddr->sin);
2321 it->trap_address6 = GET_INADDR6(tr->tr_addr);
2324 it->trap_port = NSRCPORT(&tr->tr_addr);
2325 it->sequence = htons(tr->tr_sequence);
2326 it->settime = htonl((u_int32)(current_time - tr->tr_settime));
2327 it->origtime = htonl((u_int32)(current_time - tr->tr_origtime));
2328 it->resets = htonl((u_int32)tr->tr_resets);
2329 it->flags = htonl((u_int32)tr->tr_flags);
2330 it = (struct info_trap *)more_pkt();
2338 * req_set_trap - configure a trap
2342 struct sockaddr_storage *srcadr,
2343 struct interface *inter,
2344 struct req_pkt *inpkt
2347 do_setclr_trap(srcadr, inter, inpkt, 1);
2353 * req_clr_trap - unconfigure a trap
2357 struct sockaddr_storage *srcadr,
2358 struct interface *inter,
2359 struct req_pkt *inpkt
2362 do_setclr_trap(srcadr, inter, inpkt, 0);
2368 * do_setclr_trap - do the grunge work of (un)configuring a trap
2372 struct sockaddr_storage *srcadr,
2373 struct interface *inter,
2374 struct req_pkt *inpkt,
2378 register struct conf_trap *ct;
2379 register struct interface *linter;
2381 struct sockaddr_storage laddr;
2384 * Prepare sockaddr_storage structure
2386 memset((char *)&laddr, 0, sizeof laddr);
2387 laddr.ss_family = srcadr->ss_family;
2388 NSRCPORT(&laddr) = ntohs(NTP_PORT);
2391 * Restrict ourselves to one item only. This eliminates
2392 * the error reporting problem.
2394 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2395 msyslog(LOG_ERR, "do_setclr_trap: err_nitems > 1");
2396 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2399 ct = (struct conf_trap *)inpkt->data;
2402 * Look for the local interface. If none, use the default.
2404 if (ct->local_address == 0) {
2405 linter = any_interface;
2407 if (laddr.ss_family == AF_INET)
2408 GET_INADDR(laddr) = ct->local_address;
2410 GET_INADDR6(laddr) = ct->local_address6;
2411 linter = findinterface(&laddr);
2412 if (linter == NULL) {
2413 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2418 if (laddr.ss_family == AF_INET)
2419 GET_INADDR(laddr) = ct->trap_address;
2421 GET_INADDR6(laddr) = ct->trap_address6;
2422 if (ct->trap_port != 0)
2423 NSRCPORT(&laddr) = ct->trap_port;
2425 NSRCPORT(&laddr) = htons(TRAPPORT);
2428 res = ctlsettrap(&laddr, linter, 0,
2429 INFO_VERSION(inpkt->rm_vn_mode));
2431 res = ctlclrtrap(&laddr, linter, 0);
2435 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2437 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2445 * set_request_keyid - set the keyid used to authenticate requests
2449 struct sockaddr_storage *srcadr,
2450 struct interface *inter,
2451 struct req_pkt *inpkt
2457 * Restrict ourselves to one item only.
2459 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2460 msyslog(LOG_ERR, "set_request_keyid: err_nitems > 1");
2461 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2465 keyid = ntohl(*((u_int32 *)(inpkt->data)));
2466 info_auth_keyid = keyid;
2467 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2473 * set_control_keyid - set the keyid used to authenticate requests
2477 struct sockaddr_storage *srcadr,
2478 struct interface *inter,
2479 struct req_pkt *inpkt
2483 extern keyid_t ctl_auth_keyid;
2486 * Restrict ourselves to one item only.
2488 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2489 msyslog(LOG_ERR, "set_control_keyid: err_nitems > 1");
2490 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2494 keyid = ntohl(*((u_int32 *)(inpkt->data)));
2495 ctl_auth_keyid = keyid;
2496 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2502 * get_ctl_stats - return some stats concerning the control message module
2506 struct sockaddr_storage *srcadr,
2507 struct interface *inter,
2508 struct req_pkt *inpkt
2511 register struct info_control *ic;
2514 * Importations from the control module
2516 extern u_long ctltimereset;
2517 extern u_long numctlreq;
2518 extern u_long numctlbadpkts;
2519 extern u_long numctlresponses;
2520 extern u_long numctlfrags;
2521 extern u_long numctlerrors;
2522 extern u_long numctltooshort;
2523 extern u_long numctlinputresp;
2524 extern u_long numctlinputfrag;
2525 extern u_long numctlinputerr;
2526 extern u_long numctlbadoffset;
2527 extern u_long numctlbadversion;
2528 extern u_long numctldatatooshort;
2529 extern u_long numctlbadop;
2530 extern u_long numasyncmsgs;
2532 ic = (struct info_control *)prepare_pkt(srcadr, inter, inpkt,
2533 sizeof(struct info_control));
2535 ic->ctltimereset = htonl((u_int32)(current_time - ctltimereset));
2536 ic->numctlreq = htonl((u_int32)numctlreq);
2537 ic->numctlbadpkts = htonl((u_int32)numctlbadpkts);
2538 ic->numctlresponses = htonl((u_int32)numctlresponses);
2539 ic->numctlfrags = htonl((u_int32)numctlfrags);
2540 ic->numctlerrors = htonl((u_int32)numctlerrors);
2541 ic->numctltooshort = htonl((u_int32)numctltooshort);
2542 ic->numctlinputresp = htonl((u_int32)numctlinputresp);
2543 ic->numctlinputfrag = htonl((u_int32)numctlinputfrag);
2544 ic->numctlinputerr = htonl((u_int32)numctlinputerr);
2545 ic->numctlbadoffset = htonl((u_int32)numctlbadoffset);
2546 ic->numctlbadversion = htonl((u_int32)numctlbadversion);
2547 ic->numctldatatooshort = htonl((u_int32)numctldatatooshort);
2548 ic->numctlbadop = htonl((u_int32)numctlbadop);
2549 ic->numasyncmsgs = htonl((u_int32)numasyncmsgs);
2558 * get_kernel_info - get kernel pll/pps information
2562 struct sockaddr_storage *srcadr,
2563 struct interface *inter,
2564 struct req_pkt *inpkt
2567 register struct info_kernel *ik;
2571 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2575 memset((char *)&ntx, 0, sizeof(ntx));
2576 if (ntp_adjtime(&ntx) < 0)
2577 msyslog(LOG_ERR, "get_kernel_info: ntp_adjtime() failed: %m");
2578 ik = (struct info_kernel *)prepare_pkt(srcadr, inter, inpkt,
2579 sizeof(struct info_kernel));
2584 ik->offset = htonl((u_int32)ntx.offset);
2585 ik->freq = htonl((u_int32)ntx.freq);
2586 ik->maxerror = htonl((u_int32)ntx.maxerror);
2587 ik->esterror = htonl((u_int32)ntx.esterror);
2588 ik->status = htons(ntx.status);
2589 ik->constant = htonl((u_int32)ntx.constant);
2590 ik->precision = htonl((u_int32)ntx.precision);
2591 ik->tolerance = htonl((u_int32)ntx.tolerance);
2596 ik->ppsfreq = htonl((u_int32)ntx.ppsfreq);
2597 ik->jitter = htonl((u_int32)ntx.jitter);
2598 ik->shift = htons(ntx.shift);
2599 ik->stabil = htonl((u_int32)ntx.stabil);
2600 ik->jitcnt = htonl((u_int32)ntx.jitcnt);
2601 ik->calcnt = htonl((u_int32)ntx.calcnt);
2602 ik->errcnt = htonl((u_int32)ntx.errcnt);
2603 ik->stbcnt = htonl((u_int32)ntx.stbcnt);
2608 #endif /* KERNEL_PLL */
2613 * get_clock_info - get info about a clock
2617 struct sockaddr_storage *srcadr,
2618 struct interface *inter,
2619 struct req_pkt *inpkt
2622 register struct info_clock *ic;
2623 register u_int32 *clkaddr;
2625 struct refclockstat clock_stat;
2626 struct sockaddr_storage addr;
2627 struct sockaddr_in tmp_clock;
2630 memset((char *)&addr, 0, sizeof addr);
2631 addr.ss_family = AF_INET;
2632 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2633 addr.ss_len = SOCKLEN(&addr);
2635 NSRCPORT(&addr) = htons(NTP_PORT);
2636 items = INFO_NITEMS(inpkt->err_nitems);
2637 clkaddr = (u_int32 *) inpkt->data;
2639 ic = (struct info_clock *)prepare_pkt(srcadr, inter, inpkt,
2640 sizeof(struct info_clock));
2642 while (items-- > 0) {
2643 tmp_clock.sin_addr.s_addr = *clkaddr++;
2644 CAST_V4(addr)->sin_addr = tmp_clock.sin_addr;
2645 if (!ISREFCLOCKADR(&tmp_clock) ||
2646 findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2647 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2651 clock_stat.kv_list = (struct ctl_var *)0;
2653 refclock_control(&addr, (struct refclockstat *)0, &clock_stat);
2655 ic->clockadr = tmp_clock.sin_addr.s_addr;
2656 ic->type = clock_stat.type;
2657 ic->flags = clock_stat.flags;
2658 ic->lastevent = clock_stat.lastevent;
2659 ic->currentstatus = clock_stat.currentstatus;
2660 ic->polls = htonl((u_int32)clock_stat.polls);
2661 ic->noresponse = htonl((u_int32)clock_stat.noresponse);
2662 ic->badformat = htonl((u_int32)clock_stat.badformat);
2663 ic->baddata = htonl((u_int32)clock_stat.baddata);
2664 ic->timestarted = htonl((u_int32)clock_stat.timereset);
2665 DTOLFP(clock_stat.fudgetime1, <mp);
2666 HTONL_FP(<mp, &ic->fudgetime1);
2667 DTOLFP(clock_stat.fudgetime2, <mp);
2668 HTONL_FP(<mp, &ic->fudgetime2);
2669 ic->fudgeval1 = htonl((u_int32)clock_stat.fudgeval1);
2670 ic->fudgeval2 = htonl((u_int32)clock_stat.fudgeval2);
2672 free_varlist(clock_stat.kv_list);
2674 ic = (struct info_clock *)more_pkt();
2682 * set_clock_fudge - get a clock's fudge factors
2686 struct sockaddr_storage *srcadr,
2687 struct interface *inter,
2688 struct req_pkt *inpkt
2691 register struct conf_fudge *cf;
2693 struct refclockstat clock_stat;
2694 struct sockaddr_storage addr;
2695 struct sockaddr_in tmp_clock;
2698 memset((char *)&addr, 0, sizeof addr);
2699 memset((char *)&clock_stat, 0, sizeof clock_stat);
2700 items = INFO_NITEMS(inpkt->err_nitems);
2701 cf = (struct conf_fudge *) inpkt->data;
2703 while (items-- > 0) {
2704 tmp_clock.sin_addr.s_addr = cf->clockadr;
2705 *CAST_V4(addr) = tmp_clock;
2706 addr.ss_family = AF_INET;
2707 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2708 addr.ss_len = SOCKLEN(&addr);
2710 NSRCPORT(&addr) = htons(NTP_PORT);
2711 if (!ISREFCLOCKADR(&tmp_clock) ||
2712 findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2713 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2717 switch(ntohl(cf->which)) {
2719 NTOHL_FP(&cf->fudgetime, <mp);
2720 LFPTOD(<mp, clock_stat.fudgetime1);
2721 clock_stat.haveflags = CLK_HAVETIME1;
2724 NTOHL_FP(&cf->fudgetime, <mp);
2725 LFPTOD(<mp, clock_stat.fudgetime2);
2726 clock_stat.haveflags = CLK_HAVETIME2;
2729 clock_stat.fudgeval1 = ntohl(cf->fudgeval_flags);
2730 clock_stat.haveflags = CLK_HAVEVAL1;
2733 clock_stat.fudgeval2 = ntohl(cf->fudgeval_flags);
2734 clock_stat.haveflags = CLK_HAVEVAL2;
2737 clock_stat.flags = (u_char) (ntohl(cf->fudgeval_flags) & 0xf);
2738 clock_stat.haveflags =
2739 (CLK_HAVEFLAG1|CLK_HAVEFLAG2|CLK_HAVEFLAG3|CLK_HAVEFLAG4);
2742 msyslog(LOG_ERR, "set_clock_fudge: default!");
2743 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2747 refclock_control(&addr, &clock_stat, (struct refclockstat *)0);
2750 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2756 * get_clkbug_info - get debugging info about a clock
2760 struct sockaddr_storage *srcadr,
2761 struct interface *inter,
2762 struct req_pkt *inpkt
2766 register struct info_clkbug *ic;
2767 register u_int32 *clkaddr;
2769 struct refclockbug bug;
2770 struct sockaddr_storage addr;
2771 struct sockaddr_in tmp_clock;
2773 memset((char *)&addr, 0, sizeof addr);
2774 addr.ss_family = AF_INET;
2775 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2776 addr.ss_len = SOCKLEN(&addr);
2778 NSRCPORT(&addr) = htons(NTP_PORT);
2779 items = INFO_NITEMS(inpkt->err_nitems);
2780 clkaddr = (u_int32 *) inpkt->data;
2782 ic = (struct info_clkbug *)prepare_pkt(srcadr, inter, inpkt,
2783 sizeof(struct info_clkbug));
2785 while (items-- > 0) {
2786 tmp_clock.sin_addr.s_addr = *clkaddr++;
2787 GET_INADDR(addr) = tmp_clock.sin_addr.s_addr;
2788 if (!ISREFCLOCKADR(&tmp_clock) ||
2789 findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2790 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2794 memset((char *)&bug, 0, sizeof bug);
2795 refclock_buginfo(&addr, &bug);
2796 if (bug.nvalues == 0 && bug.ntimes == 0) {
2797 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2801 ic->clockadr = tmp_clock.sin_addr.s_addr;
2803 if (i > NUMCBUGVALUES)
2805 ic->nvalues = (u_char)i;
2806 ic->svalues = htons((u_short) (bug.svalues & ((1<<i)-1)));
2808 ic->values[i] = htonl(bug.values[i]);
2811 if (i > NUMCBUGTIMES)
2813 ic->ntimes = (u_char)i;
2814 ic->stimes = htonl(bug.stimes);
2816 HTONL_FP(&bug.times[i], &ic->times[i]);
2819 ic = (struct info_clkbug *)more_pkt();
2826 * receiver of interface structures
2829 fill_info_if_stats(void *data, interface_info_t *interface_info)
2831 struct info_if_stats **ifsp = (struct info_if_stats **)data;
2832 struct info_if_stats *ifs = *ifsp;
2833 struct interface *interface = interface_info->interface;
2835 memset((char*)ifs, 0, sizeof(*ifs));
2837 if (interface->sin.ss_family == AF_INET6) {
2838 if (!client_v6_capable) {
2842 memcpy((char *)&ifs->unaddr.addr6, (char *)&CAST_V6(interface->sin)->sin6_addr, sizeof(struct in6_addr));
2843 memcpy((char *)&ifs->unbcast.addr6, (char *)&CAST_V6(interface->bcast)->sin6_addr, sizeof(struct in6_addr));
2844 memcpy((char *)&ifs->unmask.addr6, (char *)&CAST_V6(interface->mask)->sin6_addr, sizeof(struct in6_addr));
2847 memcpy((char *)&ifs->unaddr.addr, (char *)&CAST_V4(interface->sin)->sin_addr, sizeof(struct in_addr));
2848 memcpy((char *)&ifs->unbcast.addr, (char *)&CAST_V4(interface->bcast)->sin_addr, sizeof(struct in_addr));
2849 memcpy((char *)&ifs->unmask.addr, (char *)&CAST_V4(interface->mask)->sin_addr, sizeof(struct in_addr));
2851 ifs->v6_flag = htonl(ifs->v6_flag);
2852 strcpy(ifs->name, interface->name);
2853 ifs->family = htons(interface->family);
2854 ifs->flags = htonl(interface->flags);
2855 ifs->last_ttl = htonl(interface->last_ttl);
2856 ifs->num_mcast = htonl(interface->num_mcast);
2857 ifs->received = htonl(interface->received);
2858 ifs->sent = htonl(interface->sent);
2859 ifs->notsent = htonl(interface->notsent);
2860 ifs->scopeid = htonl(interface->scopeid);
2861 ifs->ifindex = htonl(interface->ifindex);
2862 ifs->ifnum = htonl(interface->ifnum);
2863 ifs->uptime = htonl(current_time - interface->starttime);
2864 ifs->ignore_packets = interface->ignore_packets;
2865 ifs->peercnt = htonl(interface->peercnt);
2866 ifs->action = interface_info->action;
2868 *ifsp = (struct info_if_stats *)more_pkt();
2872 * get_if_stats - get interface statistics
2876 struct sockaddr_storage *srcadr,
2877 struct interface *inter,
2878 struct req_pkt *inpkt
2881 struct info_if_stats *ifs;
2883 DPRINTF(3, ("wants interface statistics\n"));
2885 ifs = (struct info_if_stats *)prepare_pkt(srcadr, inter, inpkt,
2886 v6sizeof(struct info_if_stats));
2888 interface_enumerate(fill_info_if_stats, &ifs);
2895 struct sockaddr_storage *srcadr,
2896 struct interface *inter,
2897 struct req_pkt *inpkt
2900 struct info_if_stats *ifs;
2902 DPRINTF(3, ("wants interface reload\n"));
2904 ifs = (struct info_if_stats *)prepare_pkt(srcadr, inter, inpkt,
2905 v6sizeof(struct info_if_stats));
2907 interface_update(fill_info_if_stats, &ifs);