Lines Matching +full:inter +full:- +full:data
2 * ntp_request.c - respond to information requests
38 #define NO_REQUEST (-1)
51 short sizeofitem; /* size of request data item (older size)*/
52 short v6_sizeofitem; /* size of request data item (new size)*/
197 u_long numresppkts; /* number of resp packets sent with data */
205 * A hack. To keep the authentication module clear of ntp-ism's, we
213 * subroutines. Note we try to enter data in place whenever possible,
229 * init_request - initialize request data
247 * req_ack - acknowledge request with no data
252 endpt *inter,
262 rpkt.implementation = inpkt->implementation;
263 rpkt.request = inpkt->request;
270 sendpkt(srcadr, inter, -1, (struct pkt *)&rpkt, RESP_HEADER_SIZE);
276 * prepare_pkt - prepare response packet for transmission, return pointer
277 * to storage for data item.
282 endpt *inter,
293 rpkt.implementation = pkt->implementation;
294 rpkt.request = pkt->request;
298 * Compute the static data needed to carry on.
301 frominter = inter;
316 * more_pkt - return a data pointer for a new item.
329 sendpkt(toaddr, frominter, -1, (struct pkt *)&rpkt,
334 * Copy data out of exbuf into the packet.
336 memcpy(&rpkt.u.data[0], exbuf, (unsigned)itemsize);
346 DPRINTF(4, ("request: giving him more data\n"));
351 return &rpkt.u.data[databytes];
369 * flush_pkt - we're done, return remaining information.
377 * has been sent, send an error saying no data to be found.
386 sendpkt(toaddr, frominter, -1, (struct pkt *)&rpkt,
400 struct req_pkt *inpkt = (struct req_pkt *)&rbufp->recv_pkt;
401 return (INFO_MODE(inpkt->rm_vn_mode));
406 * process_private - process private mode (7) packets
418 endpt *inter;
431 recv_len = rbufp->recv_length;
432 inpkt = (struct req_pkt *)&rbufp->recv_pkt;
433 srcadr = &rbufp->recv_srcadr;
434 inter = rbufp->dstadr;
437 inpkt->implementation, inpkt->request));
444 if ( (++ec, ISRESPONSE(inpkt->rm_vn_mode))
445 || (++ec, ISMORE(inpkt->rm_vn_mode))
446 || (++ec, INFO_VERSION(inpkt->rm_vn_mode) > NTP_VERSION)
447 || (++ec, INFO_VERSION(inpkt->rm_vn_mode) < NTP_OLDVERSION)
448 || (++ec, INFO_SEQ(inpkt->auth_seq) != 0)
449 || (++ec, INFO_ERR(inpkt->err_nitems) != 0)
450 || (++ec, INFO_MBZ(inpkt->mbz_itemsize) != 0)
451 || (++ec, rbufp->recv_length < (int)REQ_LEN_HDR)
464 reqver = INFO_VERSION(inpkt->rm_vn_mode);
469 if (inpkt->implementation == IMPL_UNIV)
471 else if ((inpkt->implementation == IMPL_XNTPD) ||
472 (inpkt->implementation == IMPL_XNTPD_OLD))
475 req_ack(srcadr, inter, inpkt, INFO_ERR_IMPL);
483 while (proc->request_code != NO_REQUEST) {
484 if (proc->request_code == (short) inpkt->request)
488 if (proc->request_code == NO_REQUEST) {
489 req_ack(srcadr, inter, inpkt, INFO_ERR_REQ);
496 * If we need data, check to see if we have some. If we
504 * Handle the exception of REQ_CONFIG. It can have two data sizes.
506 temp_size = INFO_ITEMSIZE(inpkt->mbz_itemsize);
507 if ((temp_size != proc->sizeofitem &&
508 temp_size != proc->v6_sizeofitem) &&
509 !(inpkt->implementation == IMPL_XNTPD &&
510 inpkt->request == REQ_CONFIG &&
513 temp_size, proc->sizeofitem, proc->v6_sizeofitem));
514 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
517 if ((proc->sizeofitem != 0) &&
518 ((size_t)(temp_size * INFO_NITEMS(inpkt->err_nitems)) >
519 (recv_len - REQ_LEN_HDR))) {
520 DPRINTF(3, ("process_private: not enough data\n"));
521 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
525 switch (inpkt->implementation) {
533 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
545 if (proc->needs_auth && sys_authenticate) {
548 (INFO_ITEMSIZE(inpkt->mbz_itemsize) *
549 INFO_NITEMS(inpkt->err_nitems)) +
551 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
556 * For 16-octet digests, regardless of itemsize and
567 + INFO_ITEMSIZE(inpkt->mbz_itemsize) *
568 INFO_NITEMS(inpkt->err_nitems)
569 + sizeof(inpkt->tstamp);
570 /* 32-bit alignment */
575 mac_len = recv_len - noslop_len;
577 tailinpkt = (void *)((char *)inpkt + recv_len -
578 (mac_len + sizeof(inpkt->tstamp)));
586 if (!INFO_IS_AUTH(inpkt->auth_seq) || !info_auth_keyid
587 || ntohl(tailinpkt->keyid) != info_auth_keyid) {
589 INFO_IS_AUTH(inpkt->auth_seq),
591 ntohl(tailinpkt->keyid), (u_long)mac_len));
595 INFO_IS_AUTH(inpkt->auth_seq),
597 ntohl(tailinpkt->keyid), (u_long)mac_len);
599 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
607 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
621 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
629 NTOHL_FP(&tailinpkt->tstamp, &ftmp);
630 L_SUB(&ftmp, &rbufp->recv_time);
638 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
646 recv_len - mac_len, mac_len)) {
648 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
655 * Packet is okay. Call the handler to send him data.
657 (proc->handler)(srcadr, inter, inpkt);
662 * list_peers - send a list of the peers
667 endpt *inter,
674 ip = (struct info_peer_list *)prepare_pkt(srcadr, inter, inpkt,
676 for (pp = peer_list; pp != NULL && ip != NULL; pp = pp->p_link) {
677 if (IS_IPV6(&pp->srcadr)) {
680 ip->addr6 = SOCK_ADDR6(&pp->srcadr);
681 ip->v6_flag = 1;
683 ip->addr = NSRCADR(&pp->srcadr);
685 ip->v6_flag = 0;
688 ip->port = NSRCPORT(&pp->srcadr);
689 ip->hmode = pp->hmode;
690 ip->flags = 0;
691 if (pp->flags & FLAG_CONFIG)
692 ip->flags |= INFO_FLAG_CONFIG;
694 ip->flags |= INFO_FLAG_SYSPEER;
695 if (pp->status == CTL_PST_SEL_SYNCCAND)
696 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
697 if (pp->status >= CTL_PST_SEL_SYSPEER)
698 ip->flags |= INFO_FLAG_SHORTLIST;
707 * list_peers_sum - return extended peer list
712 endpt *inter,
722 ips = (struct info_peer_summary *)prepare_pkt(srcadr, inter, inpkt,
724 for (pp = peer_list; pp != NULL && ips != NULL; pp = pp->p_link) {
730 if (IS_IPV6(&pp->srcadr)) {
733 ips->srcadr6 = SOCK_ADDR6(&pp->srcadr);
734 ips->v6_flag = 1;
735 if (pp->dstadr)
736 ips->dstadr6 = SOCK_ADDR6(&pp->dstadr->sin);
738 ZERO(ips->dstadr6);
740 ips->srcadr = NSRCADR(&pp->srcadr);
742 ips->v6_flag = 0;
744 if (pp->dstadr) {
745 if (!pp->processed)
746 ips->dstadr = NSRCADR(&pp->dstadr->sin);
748 if (MDF_BCAST == pp->cast_flags)
749 ips->dstadr = NSRCADR(&pp->dstadr->bcast);
750 else if (pp->cast_flags) {
751 ips->dstadr = NSRCADR(&pp->dstadr->sin);
752 if (!ips->dstadr)
753 ips->dstadr = NSRCADR(&pp->dstadr->bcast);
757 ips->dstadr = 0;
761 ips->srcport = NSRCPORT(&pp->srcadr);
762 ips->stratum = pp->stratum;
763 ips->hpoll = pp->hpoll;
764 ips->ppoll = pp->ppoll;
765 ips->reach = pp->reach;
766 ips->flags = 0;
768 ips->flags |= INFO_FLAG_SYSPEER;
769 if (pp->flags & FLAG_CONFIG)
770 ips->flags |= INFO_FLAG_CONFIG;
771 if (pp->flags & FLAG_REFCLOCK)
772 ips->flags |= INFO_FLAG_REFCLOCK;
773 if (pp->flags & FLAG_PREFER)
774 ips->flags |= INFO_FLAG_PREFER;
775 if (pp->flags & FLAG_BURST)
776 ips->flags |= INFO_FLAG_BURST;
777 if (pp->status == CTL_PST_SEL_SYNCCAND)
778 ips->flags |= INFO_FLAG_SEL_CANDIDATE;
779 if (pp->status >= CTL_PST_SEL_SYSPEER)
780 ips->flags |= INFO_FLAG_SHORTLIST;
781 ips->hmode = pp->hmode;
782 ips->delay = HTONS_FP(DTOFP(pp->delay));
783 DTOLFP(pp->offset, <mp);
784 HTONL_FP(<mp, &ips->offset);
785 ips->dispersion = HTONS_FP(DTOUFP(SQRT(pp->disp)));
795 * peer_info - send information for one or more peers
800 endpt *inter,
815 items = INFO_NITEMS(inpkt->err_nitems);
816 item_sz = INFO_ITEMSIZE(inpkt->mbz_itemsize);
817 datap = inpkt->u.data;
819 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
822 ip = prepare_pkt(srcadr, inter, inpkt,
824 while (items-- > 0 && ip != NULL) {
841 pp = findexistingpeer(&addr, NULL, NULL, -1, 0, NULL);
844 if (IS_IPV6(&pp->srcadr)) {
845 if (pp->dstadr)
846 ip->dstadr6 =
847 (MDF_BCAST == pp->cast_flags)
848 ? SOCK_ADDR6(&pp->dstadr->bcast)
849 : SOCK_ADDR6(&pp->dstadr->sin);
851 ZERO(ip->dstadr6);
853 ip->srcadr6 = SOCK_ADDR6(&pp->srcadr);
854 ip->v6_flag = 1;
856 if (pp->dstadr) {
857 if (!pp->processed)
858 ip->dstadr = NSRCADR(&pp->dstadr->sin);
860 if (MDF_BCAST == pp->cast_flags)
861 ip->dstadr = NSRCADR(&pp->dstadr->bcast);
862 else if (pp->cast_flags) {
863 ip->dstadr = NSRCADR(&pp->dstadr->sin);
864 if (!ip->dstadr)
865 ip->dstadr = NSRCADR(&pp->dstadr->bcast);
869 ip->dstadr = 0;
871 ip->srcadr = NSRCADR(&pp->srcadr);
873 ip->v6_flag = 0;
875 ip->srcport = NSRCPORT(&pp->srcadr);
876 ip->flags = 0;
878 ip->flags |= INFO_FLAG_SYSPEER;
879 if (pp->flags & FLAG_CONFIG)
880 ip->flags |= INFO_FLAG_CONFIG;
881 if (pp->flags & FLAG_REFCLOCK)
882 ip->flags |= INFO_FLAG_REFCLOCK;
883 if (pp->flags & FLAG_PREFER)
884 ip->flags |= INFO_FLAG_PREFER;
885 if (pp->flags & FLAG_BURST)
886 ip->flags |= INFO_FLAG_BURST;
887 if (pp->status == CTL_PST_SEL_SYNCCAND)
888 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
889 if (pp->status >= CTL_PST_SEL_SYSPEER)
890 ip->flags |= INFO_FLAG_SHORTLIST;
891 ip->leap = pp->leap;
892 ip->hmode = pp->hmode;
893 ip->pmode = pp->pmode;
894 ip->keyid = pp->keyid;
895 ip->stratum = pp->stratum;
896 ip->ppoll = pp->ppoll;
897 ip->hpoll = pp->hpoll;
898 ip->precision = pp->precision;
899 ip->version = pp->version;
900 ip->reach = pp->reach;
901 ip->unreach = (u_char)pp->unreach;
902 ip->flash = (u_char)pp->flash;
903 ip->flash2 = (u_short)pp->flash;
904 ip->estbdelay = HTONS_FP(DTOFP(pp->delay));
905 ip->ttl = (u_char)pp->ttl;
906 ip->associd = htons(pp->associd);
907 ip->rootdelay = HTONS_FP(DTOUFP(pp->rootdelay));
908 ip->rootdispersion = HTONS_FP(DTOUFP(pp->rootdisp));
909 ip->refid = pp->refid;
910 HTONL_FP(&pp->reftime, &ip->reftime);
911 HTONL_FP(&pp->aorg, &ip->org);
912 HTONL_FP(&pp->rec, &ip->rec);
913 HTONL_FP(&pp->xmt, &ip->xmt);
914 j = pp->filter_nextpt - 1;
915 for (i = 0; i < NTP_SHIFT; i++, j--) {
917 j = NTP_SHIFT-1;
918 ip->filtdelay[i] = HTONS_FP(DTOFP(pp->filter_delay[j]));
919 DTOLFP(pp->filter_offset[j], <mp);
920 HTONL_FP(<mp, &ip->filtoffset[i]);
921 ip->order[i] = (u_char)((pp->filter_nextpt +
922 NTP_SHIFT - 1) -
923 pp->filter_order[i]);
924 if (ip->order[i] >= NTP_SHIFT)
925 ip->order[i] -= NTP_SHIFT;
927 DTOLFP(pp->offset, <mp);
928 HTONL_FP(<mp, &ip->offset);
929 ip->delay = HTONS_FP(DTOFP(pp->delay));
930 ip->dispersion = HTONS_FP(DTOUFP(SQRT(pp->disp)));
931 ip->selectdisp = HTONS_FP(DTOUFP(SQRT(pp->jitter)));
939 * peer_stats - send statistics for one or more peers
944 endpt *inter,
957 items = INFO_NITEMS(inpkt->err_nitems);
958 item_sz = INFO_ITEMSIZE(inpkt->mbz_itemsize);
959 datap = inpkt->u.data;
961 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
964 ip = prepare_pkt(srcadr, inter, inpkt,
966 while (items-- > 0 && ip != NULL) {
986 pp = findexistingpeer(&addr, NULL, NULL, -1, 0, NULL);
992 if (IS_IPV4(&pp->srcadr)) {
993 if (pp->dstadr) {
994 if (!pp->processed)
995 ip->dstadr = NSRCADR(&pp->dstadr->sin);
997 if (MDF_BCAST == pp->cast_flags)
998 ip->dstadr = NSRCADR(&pp->dstadr->bcast);
999 else if (pp->cast_flags) {
1000 ip->dstadr = NSRCADR(&pp->dstadr->sin);
1001 if (!ip->dstadr)
1002 ip->dstadr = NSRCADR(&pp->dstadr->bcast);
1006 ip->dstadr = 0;
1008 ip->srcadr = NSRCADR(&pp->srcadr);
1010 ip->v6_flag = 0;
1012 if (pp->dstadr)
1013 ip->dstadr6 =
1014 (MDF_BCAST == pp->cast_flags)
1015 ? SOCK_ADDR6(&pp->dstadr->bcast)
1016 : SOCK_ADDR6(&pp->dstadr->sin);
1018 ZERO(ip->dstadr6);
1020 ip->srcadr6 = SOCK_ADDR6(&pp->srcadr);
1021 ip->v6_flag = 1;
1023 ip->srcport = NSRCPORT(&pp->srcadr);
1024 ip->flags = 0;
1026 ip->flags |= INFO_FLAG_SYSPEER;
1027 if (pp->flags & FLAG_CONFIG)
1028 ip->flags |= INFO_FLAG_CONFIG;
1029 if (pp->flags & FLAG_REFCLOCK)
1030 ip->flags |= INFO_FLAG_REFCLOCK;
1031 if (pp->flags & FLAG_PREFER)
1032 ip->flags |= INFO_FLAG_PREFER;
1033 if (pp->flags & FLAG_BURST)
1034 ip->flags |= INFO_FLAG_BURST;
1035 if (pp->flags & FLAG_IBURST)
1036 ip->flags |= INFO_FLAG_IBURST;
1037 if (pp->status == CTL_PST_SEL_SYNCCAND)
1038 ip->flags |= INFO_FLAG_SEL_CANDIDATE;
1039 if (pp->status >= CTL_PST_SEL_SYSPEER)
1040 ip->flags |= INFO_FLAG_SHORTLIST;
1041 ip->flags = htons(ip->flags);
1042 ip->timereceived = htonl((u_int32)(current_time - pp->timereceived));
1043 ip->timetosend = htonl(pp->nextdate - current_time);
1044 ip->timereachable = htonl((u_int32)(current_time - pp->timereachable));
1045 ip->sent = htonl((u_int32)(pp->sent));
1046 ip->processed = htonl((u_int32)(pp->processed));
1047 ip->badauth = htonl((u_int32)(pp->badauth));
1048 ip->bogusorg = htonl((u_int32)(pp->bogusorg));
1049 ip->oldpkt = htonl((u_int32)(pp->oldpkt));
1050 ip->seldisp = htonl((u_int32)(pp->seldisptoolarge));
1051 ip->selbroken = htonl((u_int32)(pp->selbroken));
1052 ip->candidate = pp->status;
1060 * sys_info - return system info
1065 endpt *inter,
1071 is = (struct info_sys *)prepare_pkt(srcadr, inter, inpkt,
1075 if (IS_IPV4(&sys_peer->srcadr)) {
1076 is->peer = NSRCADR(&sys_peer->srcadr);
1078 is->v6_flag = 0;
1080 is->peer6 = SOCK_ADDR6(&sys_peer->srcadr);
1081 is->v6_flag = 1;
1083 is->peer_mode = sys_peer->hmode;
1085 is->peer = 0;
1087 is->v6_flag = 0;
1089 is->peer_mode = 0;
1092 is->leap = sys_leap;
1093 is->stratum = sys_stratum;
1094 is->precision = sys_precision;
1095 is->rootdelay = htonl(DTOFP(sys_rootdelay));
1096 is->rootdispersion = htonl(DTOUFP(sys_rootdisp));
1097 is->frequency = htonl(DTOFP(sys_jitter));
1098 is->stability = htonl(DTOUFP(clock_stability * 1e6));
1099 is->refid = sys_refid;
1100 HTONL_FP(&sys_reftime, &is->reftime);
1102 is->poll = sys_poll;
1104 is->flags = 0;
1106 is->flags |= INFO_FLAG_AUTHENTICATE;
1108 is->flags |= INFO_FLAG_BCLIENT;
1111 is->flags |= INFO_FLAG_CAL;
1114 is->flags |= INFO_FLAG_KERNEL;
1116 is->flags |= INFO_FLAG_MONITOR;
1118 is->flags |= INFO_FLAG_NTP;
1120 is->flags |= INFO_FLAG_PPS_SYNC;
1122 is->flags |= INFO_FLAG_FILEGEN;
1123 is->bdelay = HTONS_FP(DTOFP(sys_bdelay));
1124 HTONL_UF(sys_authdelay.l_uf, &is->authdelay);
1131 * sys_stats - return system statistics
1136 endpt *inter,
1142 ss = (struct info_sys_stats *)prepare_pkt(srcadr, inter, inpkt,
1144 ss->timeup = htonl((u_int32)current_time);
1145 ss->timereset = htonl((u_int32)(current_time - sys_stattime));
1146 ss->denied = htonl((u_int32)sys_restricted);
1147 ss->oldversionpkt = htonl((u_int32)sys_oldversion);
1148 ss->newversionpkt = htonl((u_int32)sys_newversion);
1149 ss->unknownversion = htonl((u_int32)sys_declined);
1150 ss->badlength = htonl((u_int32)sys_badlength);
1151 ss->processed = htonl((u_int32)sys_processed);
1152 ss->badauth = htonl((u_int32)sys_badauth);
1153 ss->limitrejected = htonl((u_int32)sys_limitrejected);
1154 ss->received = htonl((u_int32)sys_received);
1155 ss->lamport = htonl((u_int32)sys_lamport);
1156 ss->tsrounding = htonl((u_int32)sys_tsrounding);
1163 * mem_stats - return memory statistics
1168 endpt *inter,
1175 ms = (struct info_mem_stats *)prepare_pkt(srcadr, inter, inpkt,
1178 ms->timereset = htonl((u_int32)(current_time - peer_timereset));
1179 ms->totalpeermem = htons((u_short)total_peer_structs);
1180 ms->freepeermem = htons((u_short)peer_free_count);
1181 ms->findpeer_calls = htonl((u_int32)findpeer_calls);
1182 ms->allocations = htonl((u_int32)peer_allocations);
1183 ms->demobilizations = htonl((u_int32)peer_demobilizations);
1186 ms->hashcount[i] = (u_char)
1195 * io_stats - return io statistics
1200 endpt *inter,
1206 io = (struct info_io_stats *)prepare_pkt(srcadr, inter, inpkt,
1209 io->timereset = htonl((u_int32)(current_time - io_timereset));
1210 io->totalrecvbufs = htons((u_short) total_recvbuffs());
1211 io->freerecvbufs = htons((u_short) free_recvbuffs());
1212 io->fullrecvbufs = htons((u_short) full_recvbuffs());
1213 io->lowwater = htons((u_short) lowater_additions());
1214 io->dropped = htonl((u_int32)packets_dropped);
1215 io->ignored = htonl((u_int32)packets_ignored);
1216 io->received = htonl((u_int32)packets_received);
1217 io->sent = htonl((u_int32)packets_sent);
1218 io->notsent = htonl((u_int32)packets_notsent);
1219 io->interrupts = htonl((u_int32)handler_calls);
1220 io->int_received = htonl((u_int32)handler_pkts);
1228 * timer_stats - return timer statistics
1233 endpt * inter,
1240 ts = (struct info_timer_stats *)prepare_pkt(srcadr, inter,
1243 sincereset = current_time - timer_timereset;
1244 ts->timereset = htonl((u_int32)sincereset);
1245 ts->alarms = ts->timereset;
1246 ts->overflows = htonl((u_int32)alarm_overflow);
1247 ts->xmtcalls = htonl((u_int32)timer_xmtcalls);
1255 * loop_info - return the current state of the loop filter
1260 endpt *inter,
1267 li = (struct info_loop *)prepare_pkt(srcadr, inter, inpkt,
1271 HTONL_FP(<mp, &li->last_offset);
1273 HTONL_FP(<mp, &li->drift_comp);
1274 li->compliance = htonl((u_int32)(tc_counter));
1275 li->watchdog_timer = htonl((u_int32)(current_time - sys_epoch));
1283 * do_conf - add a peer to the configuration list
1288 endpt *inter,
1304 items = INFO_NITEMS(inpkt->err_nitems);
1305 item_sz = INFO_ITEMSIZE(inpkt->mbz_itemsize);
1306 datap = inpkt->u.data;
1308 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1312 while (items-- > 0) {
1339 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1358 * hmode > 6 ( --> MODE_BCLIENT).
1361 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1367 * - version
1368 * - ttl
1369 * - keyid
1371 * - minpoll/maxpoll, but they are treated properly
1374 * Note that we ignore any previously-specified ippeerlimit.
1379 if (peer_config(&peeraddr, NULL, NULL, -1,
1384 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1390 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1395 * do_unconf - remove a peer from the configuration list
1400 endpt * inter,
1425 item_sz = INFO_ITEMSIZE(inpkt->mbz_itemsize);
1427 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1433 items = INFO_NITEMS(inpkt->err_nitems);
1434 datap = inpkt->u.data;
1435 while (items-- > 0) {
1459 &peeraddr, NULL, p, -1, 0, NULL);
1460 } while (p && !(FLAG_CONFIG & p->flags));
1463 /* Item not found in dry run -- bail! */
1464 req_ack(srcadr, inter, inpkt,
1468 /* Item found in busy run -- remove! */
1477 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1482 * set_sys_flag - set system flags
1487 endpt *inter,
1491 setclr_flags(srcadr, inter, inpkt, 1);
1496 * clr_sys_flag - clear system flags
1501 endpt *inter,
1505 setclr_flags(srcadr, inter, inpkt, 0);
1510 * setclr_flags - do the grunge work of flag setting/clearing
1515 endpt *inter,
1523 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
1525 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1529 sf = (struct conf_sys_flags *)&inpkt->u;
1530 flags = ntohl(sf->flags);
1540 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1560 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1583 return sizeof(sp->pres)/sizeof(sp->pres[0]);
1595 if (NULL == (sp = *spp) || 0 == sp->fcnt) {
1598 sp->link = *spp;
1599 sp->fcnt = getStackSheetSize(sp);
1602 sp->pres[--sp->fcnt] = ptr;
1614 if (NULL == (sp = *spp) || sp->fcnt >= getStackSheetSize(sp))
1617 *opp = sp->pres[sp->fcnt++];
1618 if (sp->fcnt >= getStackSheetSize(sp)) {
1620 *spp = sp->link;
1634 *spp = sp->link;
1640 * list_restrict4 - iterative helper for list_restrict dumps IPv4
1653 for (rpad = NULL; res; res = res->link)
1658 pir->addr = htonl(res->u.v4.addr);
1660 pir->v6_flag = 0;
1661 pir->mask = htonl(res->u.v4.mask);
1662 pir->count = htonl(res->count);
1663 pir->rflags = htons(res->rflags);
1664 pir->mflags = htons(res->mflags);
1672 * list_restrict6 - iterative helper for list_restrict dumps IPv6
1685 for (rpad = NULL; res; res = res->link)
1690 pir->addr6 = res->u.v6.addr;
1691 pir->mask6 = res->u.v6.mask;
1692 pir->v6_flag = 1;
1693 pir->count = htonl(res->count);
1694 pir->rflags = htons(res->rflags);
1695 pir->mflags = htons(res->mflags);
1704 * list_restrict - return the restrict list
1709 endpt *inter,
1717 ir = (struct info_restrict *)prepare_pkt(srcadr, inter, inpkt,
1733 * do_resaddflags - add flags to a restrict entry (or create one)
1738 endpt *inter,
1742 do_restrict(srcadr, inter, inpkt, RESTRICT_FLAGS);
1748 * do_ressubflags - remove flags from a restrict entry
1753 endpt *inter,
1757 do_restrict(srcadr, inter, inpkt, RESTRICT_UNFLAG);
1762 * do_unrestrict - remove a restrict entry from the list
1767 endpt *inter,
1771 do_restrict(srcadr, inter, inpkt, RESTRICT_REMOVE);
1776 * do_restrict - do the dirty stuff of dealing with restrictions
1781 endpt *inter,
1803 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1812 items = INFO_NITEMS(inpkt->err_nitems);
1813 item_sz = INFO_ITEMSIZE(inpkt->mbz_itemsize);
1814 datap = inpkt->u.data;
1816 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1821 while (items-- > 0 && !bad) {
1843 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1848 * Looks okay, try it out. Needs to reload data pointer and
1849 * item counter. (Talos-CAN-0052)
1853 items = INFO_NITEMS(inpkt->err_nitems);
1854 datap = inpkt->u.data;
1856 while (items-- > 0) {
1885 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1890 * mon_getlist - return monitor data
1895 endpt *inter,
1899 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1923 * reset_stats - reset statistic counters here and there
1928 endpt *inter,
1936 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
1938 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1942 rflags = (struct reset_flags *)&inpkt->u;
1943 flags = ntohl(rflags->flags);
1948 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1952 for (rent = reset_entries; rent->flag != 0; rent++) {
1953 if (flags & rent->flag)
1954 (*rent->handler)();
1956 req_ack(srcadr, inter, inpkt, INFO_OKAY);
1961 * reset_peer - clear a peer's statistics
1966 endpt *inter,
1983 items = INFO_NITEMS(inpkt->err_nitems);
1984 item_sz = INFO_ITEMSIZE(inpkt->mbz_itemsize);
1985 datap = inpkt->u.data;
1987 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1992 while (items-- > 0 && !bad) {
2007 p = findexistingpeer(&peeraddr, NULL, NULL, -1, 0, NULL);
2014 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2019 * Now do it in earnest. Needs to reload data pointer and item
2020 * counter. (Talos-CAN-0052)
2023 items = INFO_NITEMS(inpkt->err_nitems);
2024 datap = inpkt->u.data;
2025 while (items-- > 0) {
2040 p = findexistingpeer(&peeraddr, NULL, NULL, -1, 0, NULL);
2043 p = findexistingpeer(&peeraddr, NULL, p, -1, 0, NULL);
2048 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2053 * do_key_reread - reread the encryption key file
2058 endpt *inter,
2063 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2068 * trust_key - make one or more keys trusted
2073 endpt *inter,
2077 do_trustkey(srcadr, inter, inpkt, 1);
2082 * untrust_key - make one or more keys untrusted
2087 endpt *inter,
2091 do_trustkey(srcadr, inter, inpkt, 0);
2096 * do_trustkey - make keys either trustable or untrustable
2101 endpt *inter,
2109 items = INFO_NITEMS(inpkt->err_nitems);
2110 kp = (uint32_t *)&inpkt->u;
2111 while (items-- > 0) {
2116 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2121 * get_auth_info - return some stats concerning the authentication module
2126 endpt *inter,
2132 ia = (struct info_auth *)prepare_pkt(srcadr, inter, inpkt,
2135 ia->numkeys = htonl((u_int32)authnumkeys);
2136 ia->numfreekeys = htonl((u_int32)authnumfreekeys);
2137 ia->keylookups = htonl((u_int32)authkeylookups);
2138 ia->keynotfound = htonl((u_int32)authkeynotfound);
2139 ia->encryptions = htonl((u_int32)authencryptions);
2140 ia->decryptions = htonl((u_int32)authdecryptions);
2141 ia->keyuncached = htonl((u_int32)authkeyuncached);
2142 ia->expired = htonl((u_int32)authkeyexpired);
2143 ia->timereset = htonl((u_int32)(current_time - auth_timereset));
2152 * reset_auth_stats - reset the authentication stat counters. Done here
2153 * to keep ntp-isms out of the authentication module
2168 * req_get_traps - return information about current trap holders
2173 endpt *inter,
2182 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2186 it = (struct info_trap *)prepare_pkt(srcadr, inter, inpkt,
2190 if (tr->tr_flags & TRAP_INUSE) {
2191 if (IS_IPV4(&tr->tr_addr)) {
2192 if (tr->tr_localaddr == any_interface)
2193 it->local_address = 0;
2195 it->local_address
2196 = NSRCADR(&tr->tr_localaddr->sin);
2197 it->trap_address = NSRCADR(&tr->tr_addr);
2199 it->v6_flag = 0;
2203 it->local_address6
2204 = SOCK_ADDR6(&tr->tr_localaddr->sin);
2205 it->trap_address6 = SOCK_ADDR6(&tr->tr_addr);
2206 it->v6_flag = 1;
2208 it->trap_port = NSRCPORT(&tr->tr_addr);
2209 it->sequence = htons(tr->tr_sequence);
2210 it->settime = htonl((u_int32)(current_time - tr->tr_settime));
2211 it->origtime = htonl((u_int32)(current_time - tr->tr_origtime));
2212 it->resets = htonl((u_int32)tr->tr_resets);
2213 it->flags = htonl((u_int32)tr->tr_flags);
2222 * req_set_trap - configure a trap
2227 endpt *inter,
2231 do_setclr_trap(srcadr, inter, inpkt, 1);
2237 * req_clr_trap - unconfigure a trap
2242 endpt *inter,
2246 do_setclr_trap(srcadr, inter, inpkt, 0);
2252 * do_setclr_trap - do the grunge work of (un)configuring a trap
2257 endpt *inter,
2278 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2280 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2283 ct = (struct conf_trap *)&inpkt->u;
2288 if (ct->local_address == 0) {
2292 NSRCADR(&laddr) = ct->local_address;
2294 SOCK_ADDR6(&laddr) = ct->local_address6;
2297 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2303 NSRCADR(&laddr) = ct->trap_address;
2305 SOCK_ADDR6(&laddr) = ct->trap_address6;
2306 if (ct->trap_port)
2307 NSRCPORT(&laddr) = ct->trap_port;
2313 INFO_VERSION(inpkt->rm_vn_mode));
2319 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2321 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2328 * - only one item allowed
2329 * - key must be valid (that is, known, and not in the autokey range)
2336 endpt *inter,
2344 if (INFO_NITEMS(inpkt->err_nitems) > 1) {
2347 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2352 pkeyid = (keyid_t *)&inpkt->u;
2355 /* validate the new key id, claim data error on failure */
2359 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2363 /* if we arrive here, the key is good -- use it */
2365 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2369 * set_request_keyid - set the keyid used to authenticate requests
2374 endpt *inter,
2379 srcadr, inter, inpkt);
2385 * set_control_keyid - set the keyid used to authenticate requests
2390 endpt *inter,
2395 srcadr, inter, inpkt);
2401 * get_ctl_stats - return some stats concerning the control message module
2406 endpt *inter,
2412 ic = (struct info_control *)prepare_pkt(srcadr, inter, inpkt,
2415 ic->ctltimereset = htonl((u_int32)(current_time - ctltimereset));
2416 ic->numctlreq = htonl((u_int32)numctlreq);
2417 ic->numctlbadpkts = htonl((u_int32)numctlbadpkts);
2418 ic->numctlresponses = htonl((u_int32)numctlresponses);
2419 ic->numctlfrags = htonl((u_int32)numctlfrags);
2420 ic->numctlerrors = htonl((u_int32)numctlerrors);
2421 ic->numctltooshort = htonl((u_int32)numctltooshort);
2422 ic->numctlinputresp = htonl((u_int32)numctlinputresp);
2423 ic->numctlinputfrag = htonl((u_int32)numctlinputfrag);
2424 ic->numctlinputerr = htonl((u_int32)numctlinputerr);
2425 ic->numctlbadoffset = htonl((u_int32)numctlbadoffset);
2426 ic->numctlbadversion = htonl((u_int32)numctlbadversion);
2427 ic->numctldatatooshort = htonl((u_int32)numctldatatooshort);
2428 ic->numctlbadop = htonl((u_int32)numctlbadop);
2429 ic->numasyncmsgs = htonl((u_int32)numasyncmsgs);
2438 * get_kernel_info - get kernel pll/pps information
2443 endpt *inter,
2451 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2458 ik = (struct info_kernel *)prepare_pkt(srcadr, inter, inpkt,
2464 ik->offset = htonl((u_int32)ntx.offset);
2465 ik->freq = htonl((u_int32)ntx.freq);
2466 ik->maxerror = htonl((u_int32)ntx.maxerror);
2467 ik->esterror = htonl((u_int32)ntx.esterror);
2468 ik->status = htons(ntx.status);
2469 ik->constant = htonl((u_int32)ntx.constant);
2470 ik->precision = htonl((u_int32)ntx.precision);
2471 ik->tolerance = htonl((u_int32)ntx.tolerance);
2476 ik->ppsfreq = htonl((u_int32)ntx.ppsfreq);
2477 ik->jitter = htonl((u_int32)ntx.jitter);
2478 ik->shift = htons(ntx.shift);
2479 ik->stabil = htonl((u_int32)ntx.stabil);
2480 ik->jitcnt = htonl((u_int32)ntx.jitcnt);
2481 ik->calcnt = htonl((u_int32)ntx.calcnt);
2482 ik->errcnt = htonl((u_int32)ntx.errcnt);
2483 ik->stbcnt = htonl((u_int32)ntx.stbcnt);
2493 * get_clock_info - get info about a clock
2498 endpt *inter,
2515 items = INFO_NITEMS(inpkt->err_nitems);
2516 clkaddr = &inpkt->u.u32[0];
2518 ic = (struct info_clock *)prepare_pkt(srcadr, inter, inpkt,
2521 while (items-- > 0 && ic) {
2524 findexistingpeer(&addr, NULL, NULL, -1, 0, NULL)) {
2525 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2533 ic->clockadr = NSRCADR(&addr);
2534 ic->type = clock_stat.type;
2535 ic->flags = clock_stat.flags;
2536 ic->lastevent = clock_stat.lastevent;
2537 ic->currentstatus = clock_stat.currentstatus;
2538 ic->polls = htonl((u_int32)clock_stat.polls);
2539 ic->noresponse = htonl((u_int32)clock_stat.noresponse);
2540 ic->badformat = htonl((u_int32)clock_stat.badformat);
2541 ic->baddata = htonl((u_int32)clock_stat.baddata);
2542 ic->timestarted = htonl((u_int32)clock_stat.timereset);
2544 HTONL_FP(<mp, &ic->fudgetime1);
2546 HTONL_FP(<mp, &ic->fudgetime2);
2547 ic->fudgeval1 = htonl((u_int32)clock_stat.fudgeval1);
2548 /* [Bug3527] Backward Incompatible: ic->fudgeval2 is
2553 ic->fudgeval2 = htonl(clock_stat.fudgeval2);
2555 ic->fudgeval2 = clock_stat.fudgeval2;
2568 * set_clock_fudge - get a clock's fudge factors
2573 endpt *inter,
2585 items = INFO_NITEMS(inpkt->err_nitems);
2586 cf = (struct conf_fudge *)&inpkt->u;
2588 while (items-- > 0) {
2590 NSRCADR(&addr) = cf->clockadr;
2596 findexistingpeer(&addr, NULL, NULL, -1, 0, NULL)) {
2597 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2601 switch(ntohl(cf->which)) {
2603 NTOHL_FP(&cf->fudgetime, <mp);
2608 NTOHL_FP(&cf->fudgetime, <mp);
2613 clock_stat.fudgeval1 = ntohl(cf->fudgeval_flags);
2617 clock_stat.fudgeval2 = ntohl(cf->fudgeval_flags);
2621 clock_stat.flags = (u_char) (ntohl(cf->fudgeval_flags) & 0xf);
2627 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
2634 req_ack(srcadr, inter, inpkt, INFO_OKAY);
2640 * get_clkbug_info - get debugging info about a clock
2645 endpt *inter,
2662 items = INFO_NITEMS(inpkt->err_nitems);
2663 clkaddr = (u_int32 *)&inpkt->u;
2665 ic = (struct info_clkbug *)prepare_pkt(srcadr, inter, inpkt,
2668 while (items-- > 0 && ic) {
2671 findexistingpeer(&addr, NULL, NULL, -1, 0, NULL)) {
2672 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2679 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2683 ic->clockadr = NSRCADR(&addr);
2687 ic->nvalues = (u_char)i;
2688 ic->svalues = htons((u_short) (bug.svalues & ((1<<i)-1)));
2689 while (--i >= 0)
2690 ic->values[i] = htonl(bug.values[i]);
2695 ic->ntimes = (u_char)i;
2696 ic->stimes = htonl(bug.stimes);
2697 while (--i >= 0) {
2698 HTONL_FP(&bug.times[i], &ic->times[i]);
2711 fill_info_if_stats(void *data, interface_info_t *interface_info)
2713 struct info_if_stats **ifsp = (struct info_if_stats **)data;
2715 endpt *ep = interface_info->ep;
2722 if (IS_IPV6(&ep->sin)) {
2725 ifs->v6_flag = 1;
2726 ifs->unaddr.addr6 = SOCK_ADDR6(&ep->sin);
2727 ifs->unbcast.addr6 = SOCK_ADDR6(&ep->bcast);
2728 ifs->unmask.addr6 = SOCK_ADDR6(&ep->mask);
2730 ifs->v6_flag = 0;
2731 ifs->unaddr.addr = SOCK_ADDR4(&ep->sin);
2732 ifs->unbcast.addr = SOCK_ADDR4(&ep->bcast);
2733 ifs->unmask.addr = SOCK_ADDR4(&ep->mask);
2735 ifs->v6_flag = htonl(ifs->v6_flag);
2736 strlcpy(ifs->name, ep->name, sizeof(ifs->name));
2737 ifs->family = htons(ep->family);
2738 ifs->flags = htonl(ep->flags);
2739 ifs->last_ttl = htonl(ep->last_ttl);
2740 ifs->num_mcast = htonl(ep->num_mcast);
2741 ifs->received = htonl(ep->received);
2742 ifs->sent = htonl(ep->sent);
2743 ifs->notsent = htonl(ep->notsent);
2744 ifs->ifindex = htonl(ep->ifindex);
2746 ifs->scopeid = ifs->ifindex;
2747 ifs->ifnum = htonl(ep->ifnum);
2748 ifs->uptime = htonl(current_time - ep->starttime);
2749 ifs->ignore_packets = ep->ignore_packets;
2750 ifs->peercnt = htonl(ep->peercnt);
2751 ifs->action = interface_info->action;
2757 * get_if_stats - get interface statistics
2762 endpt *inter,
2770 ifs = (struct info_if_stats *)prepare_pkt(srcadr, inter, inpkt,
2781 endpt *inter,
2789 ifs = (struct info_if_stats *)prepare_pkt(srcadr, inter, inpkt,