1 /* 2 * ntp_request.c - respond to information requests 3 */ 4 5 #ifdef HAVE_CONFIG_H 6 # include <config.h> 7 #endif 8 9 #include "ntpd.h" 10 #include "ntp_io.h" 11 #include "ntp_request.h" 12 #include "ntp_control.h" 13 #include "ntp_refclock.h" 14 #include "ntp_if.h" 15 #include "ntp_stdlib.h" 16 17 #include <stdio.h> 18 #include <stddef.h> 19 #include <signal.h> 20 #include <netinet/in.h> 21 #include <arpa/inet.h> 22 23 #include "recvbuff.h" 24 25 #ifdef KERNEL_PLL 26 #include "ntp_syscall.h" 27 #endif /* KERNEL_PLL */ 28 29 /* 30 * Structure to hold request procedure information 31 */ 32 #define NOAUTH 0 33 #define AUTH 1 34 35 #define NO_REQUEST (-1) 36 /* 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. 40 */ 41 static int client_v6_capable = 0; /* the client can handle longer messages */ 42 43 #define v6sizeof(type) (client_v6_capable ? sizeof(type) : v4sizeof(type)) 44 45 struct req_proc { 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 */ 52 }; 53 54 /* 55 * Universal request codes 56 */ 57 static struct req_proc univ_codes[] = { 58 { NO_REQUEST, NOAUTH, 0, 0 } 59 }; 60 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 *)); 104 #ifdef KERNEL_PLL 105 static void get_kernel_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *)); 106 #endif /* KERNEL_PLL */ 107 #ifdef REFCLOCK 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 */ 111 #ifdef REFCLOCK 112 static void get_clkbug_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *)); 113 #endif /* REFCLOCK */ 114 115 /* 116 * ntpd request codes 117 */ 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), 161 set_request_keyid }, 162 { REQ_CONTROL_KEY, AUTH, sizeof(u_long), sizeof(u_long), 163 set_control_keyid }, 164 { REQ_GET_CTLSTATS, NOAUTH, 0, 0, get_ctl_stats }, 165 #ifdef KERNEL_PLL 166 { REQ_GET_KERNEL, NOAUTH, 0, 0, get_kernel_info }, 167 #endif 168 #ifdef REFCLOCK 169 { REQ_GET_CLOCKINFO, NOAUTH, sizeof(u_int32), sizeof(u_int32), 170 get_clock_info }, 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), 174 get_clkbug_info }, 175 #endif 176 { REQ_IF_STATS, AUTH, 0, 0, get_if_stats }, 177 { REQ_IF_RELOAD, AUTH, 0, 0, do_if_reload }, 178 179 { NO_REQUEST, NOAUTH, 0, 0, 0 } 180 }; 181 182 183 /* 184 * Authentication keyid used to authenticate requests. Zero means we 185 * don't allow writing anything. 186 */ 187 keyid_t info_auth_keyid; 188 189 /* 190 * Statistic counters to keep track of requests and responses. 191 */ 192 u_long numrequests; /* number of requests we've received */ 193 u_long numresppkts; /* number of resp packets sent with data */ 194 195 u_long errorcounter[INFO_ERR_AUTH+1]; /* lazy way to count errors, indexed */ 196 /* by the error code */ 197 198 /* 199 * A hack. To keep the authentication module clear of ntp-ism's, we 200 * include a time reset variable for its stats here. 201 */ 202 static u_long auth_timereset; 203 204 /* 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. 210 */ 211 static struct resp_pkt rpkt; 212 static int reqver; 213 static int seqno; 214 static int nitems; 215 static int itemsize; 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; 221 222 /* 223 * init_request - initialize request data 224 */ 225 void 226 init_request (void) 227 { 228 int i; 229 230 numrequests = 0; 231 numresppkts = 0; 232 auth_timereset = 0; 233 info_auth_keyid = 0; /* by default, can't do this */ 234 235 for (i = 0; i < sizeof(errorcounter)/sizeof(errorcounter[0]); i++) 236 errorcounter[i] = 0; 237 } 238 239 240 /* 241 * req_ack - acknowledge request with no data 242 */ 243 static void 244 req_ack( 245 struct sockaddr_storage *srcadr, 246 struct interface *inter, 247 struct req_pkt *inpkt, 248 int errcode 249 ) 250 { 251 /* 252 * fill in the fields 253 */ 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); 260 261 /* 262 * send packet and bump counters 263 */ 264 sendpkt(srcadr, inter, -1, (struct pkt *)&rpkt, RESP_HEADER_SIZE); 265 errorcounter[errcode]++; 266 } 267 268 269 /* 270 * prepare_pkt - prepare response packet for transmission, return pointer 271 * to storage for data item. 272 */ 273 static char * 274 prepare_pkt( 275 struct sockaddr_storage *srcadr, 276 struct interface *inter, 277 struct req_pkt *pkt, 278 u_int structsize 279 ) 280 { 281 #ifdef DEBUG 282 if (debug > 3) 283 printf("request: preparing pkt\n"); 284 #endif 285 286 /* 287 * Fill in the implementation, request and itemsize fields 288 * since these won't change. 289 */ 290 rpkt.implementation = pkt->implementation; 291 rpkt.request = pkt->request; 292 rpkt.mbz_itemsize = MBZ_ITEMSIZE(structsize); 293 294 /* 295 * Compute the static data needed to carry on. 296 */ 297 toaddr = srcadr; 298 frominter = inter; 299 seqno = 0; 300 nitems = 0; 301 itemsize = structsize; 302 databytes = 0; 303 usingexbuf = 0; 304 305 /* 306 * return the beginning of the packet buffer. 307 */ 308 return &rpkt.data[0]; 309 } 310 311 312 /* 313 * more_pkt - return a data pointer for a new item. 314 */ 315 static char * 316 more_pkt(void) 317 { 318 /* 319 * If we were using the extra buffer, send the packet. 320 */ 321 if (usingexbuf) { 322 #ifdef DEBUG 323 if (debug > 2) 324 printf("request: sending pkt\n"); 325 #endif 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); 331 numresppkts++; 332 333 /* 334 * Copy data out of exbuf into the packet. 335 */ 336 memmove(&rpkt.data[0], exbuf, (unsigned)itemsize); 337 seqno++; 338 databytes = 0; 339 nitems = 0; 340 usingexbuf = 0; 341 } 342 343 databytes += itemsize; 344 nitems++; 345 if (databytes + itemsize <= RESP_DATA_SIZE) { 346 #ifdef DEBUG 347 if (debug > 3) 348 printf("request: giving him more data\n"); 349 #endif 350 /* 351 * More room in packet. Give him the 352 * next address. 353 */ 354 return &rpkt.data[databytes]; 355 } else { 356 /* 357 * No room in packet. Give him the extra 358 * buffer unless this was the last in the sequence. 359 */ 360 #ifdef DEBUG 361 if (debug > 3) 362 printf("request: into extra buffer\n"); 363 #endif 364 if (seqno == MAXSEQ) 365 return (char *)0; 366 else { 367 usingexbuf = 1; 368 return exbuf; 369 } 370 } 371 } 372 373 374 /* 375 * flush_pkt - we're done, return remaining information. 376 */ 377 static void 378 flush_pkt(void) 379 { 380 #ifdef DEBUG 381 if (debug > 2) 382 printf("request: flushing packet, %d items\n", nitems); 383 #endif 384 /* 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. 387 */ 388 if (seqno == 0 && nitems == 0) 389 req_ack(toaddr, frominter, (struct req_pkt *)&rpkt, 390 INFO_ERR_NODATA); 391 else { 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); 397 numresppkts++; 398 } 399 } 400 401 402 403 /* 404 * process_private - process private mode (7) packets 405 */ 406 void 407 process_private( 408 struct recvbuf *rbufp, 409 int mod_okay 410 ) 411 { 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; 418 int ec; 419 short temp_size; 420 421 /* 422 * Initialize pointers, for convenience 423 */ 424 inpkt = (struct req_pkt *)&rbufp->recv_pkt; 425 srcadr = &rbufp->recv_srcadr; 426 inter = rbufp->dstadr; 427 428 #ifdef DEBUG 429 if (debug > 2) 430 printf("process_private: impl %d req %d\n", 431 inpkt->implementation, inpkt->request); 432 #endif 433 434 /* 435 * Do some sanity checks on the packet. Return a format 436 * error if it fails. 437 */ 438 ec = 0; 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) 447 ) { 448 NLOG(NLOG_SYSEVENT) 449 if (current_time >= quiet_until) { 450 msyslog(LOG_ERR, 451 "process_private: drop test %d" 452 " failed, pkt from %s", 453 ec, stoa(srcadr)); 454 quiet_until = current_time + 60; 455 } 456 return; 457 } 458 459 reqver = INFO_VERSION(inpkt->rm_vn_mode); 460 461 /* 462 * Get the appropriate procedure list to search. 463 */ 464 if (inpkt->implementation == IMPL_UNIV) 465 proc = univ_codes; 466 else if ((inpkt->implementation == IMPL_XNTPD) || 467 (inpkt->implementation == IMPL_XNTPD_OLD)) 468 proc = ntp_codes; 469 else { 470 req_ack(srcadr, inter, inpkt, INFO_ERR_IMPL); 471 return; 472 } 473 474 /* 475 * Search the list for the request codes. If it isn't one 476 * we know, return an error. 477 */ 478 while (proc->request_code != NO_REQUEST) { 479 if (proc->request_code == (short) inpkt->request) 480 break; 481 proc++; 482 } 483 if (proc->request_code == NO_REQUEST) { 484 req_ack(srcadr, inter, inpkt, INFO_ERR_REQ); 485 return; 486 } 487 488 #ifdef DEBUG 489 if (debug > 3) 490 printf("found request in tables\n"); 491 #endif 492 493 /* 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). 496 */ 497 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. 501 * 502 * Handle the exception of REQ_CONFIG. It can have two data sizes. 503 */ 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))) { 510 #ifdef DEBUG 511 if (debug > 2) 512 printf("process_private: wrong item size, received %d, should be %d or %d\n", 513 temp_size, proc->sizeofitem, proc->v6_sizeofitem); 514 #endif 515 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 516 return; 517 } 518 if ((proc->sizeofitem != 0) && 519 ((temp_size * INFO_NITEMS(inpkt->err_nitems)) > 520 (rbufp->recv_length - REQ_LEN_HDR))) { 521 #ifdef DEBUG 522 if (debug > 2) 523 printf("process_private: not enough data\n"); 524 #endif 525 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 526 return; 527 } 528 529 switch (inpkt->implementation) { 530 case IMPL_XNTPD: 531 client_v6_capable = 1; 532 break; 533 case IMPL_XNTPD_OLD: 534 client_v6_capable = 0; 535 break; 536 default: 537 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 538 return; 539 } 540 541 /* 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 547 * time stamp. 548 */ 549 if (proc->needs_auth && sys_authenticate) { 550 l_fp ftmp; 551 double dtemp; 552 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); 558 } 559 tailinpkt = (struct req_pkt_tail *)((char *)&rbufp->recv_pkt + 560 rbufp->recv_length - sizeof(struct req_pkt_tail)); 561 562 /* 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. 565 */ 566 if (!INFO_IS_AUTH(inpkt->auth_seq) || info_auth_keyid == 0 567 || ntohl(tailinpkt->keyid) != info_auth_keyid) { 568 #ifdef DEBUG 569 if (debug > 4) 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)); 574 msyslog(LOG_DEBUG, 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)); 579 #endif 580 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH); 581 return; 582 } 583 if (rbufp->recv_length > REQ_LEN_MAC) { 584 #ifdef DEBUG 585 if (debug > 4) 586 printf("bad pkt length %d\n", 587 rbufp->recv_length); 588 #endif 589 msyslog(LOG_ERR, "process_private: bad pkt length %d", 590 rbufp->recv_length); 591 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 592 return; 593 } 594 if (!mod_okay || !authhavekey(info_auth_keyid)) { 595 #ifdef DEBUG 596 if (debug > 4) 597 printf("failed auth mod_okay %d\n", mod_okay); 598 msyslog(LOG_DEBUG, 599 "process_private: failed auth mod_okay %d\n", 600 mod_okay); 601 #endif 602 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH); 603 return; 604 } 605 606 /* 607 * calculate absolute time difference between xmit time stamp 608 * and receive time stamp. If too large, too bad. 609 */ 610 NTOHL_FP(&tailinpkt->tstamp, &ftmp); 611 L_SUB(&ftmp, &rbufp->recv_time); 612 LFPTOD(&ftmp, dtemp); 613 if (fabs(dtemp) >= INFO_TS_MAXSKEW) { 614 /* 615 * He's a loser. Tell him. 616 */ 617 #ifdef DEBUG 618 if (debug > 4) 619 printf("xmit/rcv timestamp delta > INFO_TS_MAXSKEW\n"); 620 #endif 621 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH); 622 return; 623 } 624 625 /* 626 * So far so good. See if decryption works out okay. 627 */ 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)) { 631 #ifdef DEBUG 632 if (debug > 4) 633 printf("authdecrypt failed\n"); 634 #endif 635 req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH); 636 return; 637 } 638 } 639 640 #ifdef DEBUG 641 if (debug > 3) 642 printf("process_private: all okay, into handler\n"); 643 #endif 644 645 /* 646 * Packet is okay. Call the handler to send him data. 647 */ 648 (proc->handler)(srcadr, inter, inpkt); 649 } 650 651 652 /* 653 * peer_list - send a list of the peers 654 */ 655 static void 656 peer_list( 657 struct sockaddr_storage *srcadr, 658 struct interface *inter, 659 struct req_pkt *inpkt 660 ) 661 { 662 register struct info_peer_list *ip; 663 register struct peer *pp; 664 register int i; 665 register int skip = 0; 666 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++) { 670 pp = peer_hash[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); 675 ip->v6_flag = 1; 676 skip = 0; 677 } else { 678 skip = 1; 679 break; 680 } 681 } else { 682 ip->addr = GET_INADDR(pp->srcadr); 683 if (client_v6_capable) 684 ip->v6_flag = 0; 685 skip = 0; 686 } 687 688 if(!skip) { 689 ip->port = NSRCPORT(&pp->srcadr); 690 ip->hmode = pp->hmode; 691 ip->flags = 0; 692 if (pp->flags & FLAG_CONFIG) 693 ip->flags |= INFO_FLAG_CONFIG; 694 if (pp == sys_peer) 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(); 701 } 702 pp = pp->next; 703 } 704 } 705 flush_pkt(); 706 } 707 708 709 /* 710 * peer_list_sum - return extended peer list 711 */ 712 static void 713 peer_list_sum( 714 struct sockaddr_storage *srcadr, 715 struct interface *inter, 716 struct req_pkt *inpkt 717 ) 718 { 719 register struct info_peer_summary *ips; 720 register struct peer *pp; 721 register int i; 722 l_fp ltmp; 723 register int skip; 724 725 #ifdef DEBUG 726 if (debug > 2) 727 printf("wants peer list summary\n"); 728 #endif 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++) { 732 pp = peer_hash[i]; 733 while (pp != 0 && ips != 0) { 734 #ifdef DEBUG 735 if (debug > 3) 736 printf("sum: got one\n"); 737 #endif 738 /* 739 * Be careful here not to return v6 peers when we 740 * want only v4. 741 */ 742 if (pp->srcadr.ss_family == AF_INET6) { 743 if (client_v6_capable) { 744 ips->srcadr6 = GET_INADDR6(pp->srcadr); 745 ips->v6_flag = 1; 746 if (pp->dstadr) 747 ips->dstadr6 = GET_INADDR6(pp->dstadr->sin); 748 else 749 memset(&ips->dstadr6, 0, sizeof(ips->dstadr6)); 750 skip = 0; 751 } else { 752 skip = 1; 753 break; 754 } 755 } else { 756 ips->srcadr = GET_INADDR(pp->srcadr); 757 if (client_v6_capable) 758 ips->v6_flag = 0; 759 /* XXX PDM This code is buggy. Need to replace with a straightforward assignment */ 760 761 if (pp->dstadr) 762 ips->dstadr = (pp->processed) ? 763 pp->cast_flags == MDF_BCAST ? 764 GET_INADDR(pp->dstadr->bcast): 765 pp->cast_flags ? 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); 770 else 771 memset(&ips->dstadr, 0, sizeof(ips->dstadr)); 772 773 skip = 0; 774 } 775 776 if (!skip){ 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; 782 ips->flags = 0; 783 if (pp == sys_peer) 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))); 804 } 805 pp = pp->next; 806 ips = (struct info_peer_summary *)more_pkt(); 807 } 808 } 809 flush_pkt(); 810 } 811 812 813 /* 814 * peer_info - send information for one or more peers 815 */ 816 static void 817 peer_info ( 818 struct sockaddr_storage *srcadr, 819 struct interface *inter, 820 struct req_pkt *inpkt 821 ) 822 { 823 register struct info_peer_list *ipl; 824 register struct peer *pp; 825 register struct info_peer *ip; 826 register int items; 827 register int i, j; 828 struct sockaddr_storage addr; 829 extern struct peer *sys_peer; 830 l_fp ltmp; 831 832 memset((char *)&addr, 0, sizeof addr); 833 items = INFO_NITEMS(inpkt->err_nitems); 834 ipl = (struct info_peer_list *) inpkt->data; 835 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; 844 } else { 845 addr.ss_family = AF_INET; 846 GET_INADDR(addr) = ipl->addr; 847 } 848 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR 849 addr.ss_len = SOCKLEN(&addr); 850 #endif 851 ipl++; 852 if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0) 853 continue; 854 if (pp->srcadr.ss_family == AF_INET6) { 855 if (pp->dstadr) 856 ip->dstadr6 = pp->cast_flags == MDF_BCAST ? 857 GET_INADDR6(pp->dstadr->bcast) : 858 GET_INADDR6(pp->dstadr->sin); 859 else 860 memset(&ip->dstadr6, 0, sizeof(ip->dstadr6)); 861 862 ip->srcadr6 = GET_INADDR6(pp->srcadr); 863 ip->v6_flag = 1; 864 } else { 865 /* XXX PDM This code is buggy. Need to replace with a straightforward assignment */ 866 if (pp->dstadr) 867 ip->dstadr = (pp->processed) ? 868 pp->cast_flags == MDF_BCAST ? 869 GET_INADDR(pp->dstadr->bcast): 870 pp->cast_flags ? 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); 875 else 876 memset(&ip->dstadr, 0, sizeof(ip->dstadr)); 877 878 ip->srcadr = GET_INADDR(pp->srcadr); 879 if (client_v6_capable) 880 ip->v6_flag = 0; 881 } 882 ip->srcport = NSRCPORT(&pp->srcadr); 883 ip->flags = 0; 884 if (pp == sys_peer) 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; 900 ip->leap = pp->leap; 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)); 913 ip->ttl = pp->ttl; 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--) { 924 if (j < 0) 925 j = NTP_SHIFT-1; 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; 933 } 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(); 940 } 941 flush_pkt(); 942 } 943 944 945 /* 946 * peer_stats - send statistics for one or more peers 947 */ 948 static void 949 peer_stats ( 950 struct sockaddr_storage *srcadr, 951 struct interface *inter, 952 struct req_pkt *inpkt 953 ) 954 { 955 register struct info_peer_list *ipl; 956 register struct peer *pp; 957 register struct info_peer_stats *ip; 958 register int items; 959 struct sockaddr_storage addr; 960 extern struct peer *sys_peer; 961 962 #ifdef DEBUG 963 if (debug) 964 printf("peer_stats: called\n"); 965 #endif 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; 976 } else { 977 addr.ss_family = AF_INET; 978 GET_INADDR(addr) = ipl->addr; 979 } 980 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR 981 addr.ss_len = SOCKLEN(&addr); 982 #endif 983 #ifdef DEBUG 984 if (debug) 985 printf("peer_stats: looking for %s, %d, %d\n", stoa(&addr), 986 ipl->port, ((struct sockaddr_in6 *)&addr)->sin6_port); 987 #endif 988 ipl = (struct info_peer_list *)((char *)ipl + 989 INFO_ITEMSIZE(inpkt->mbz_itemsize)); 990 991 if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0) 992 continue; 993 #ifdef DEBUG 994 if (debug) 995 printf("peer_stats: found %s\n", stoa(&addr)); 996 #endif 997 if (pp->srcadr.ss_family == AF_INET) { 998 if (pp->dstadr) 999 ip->dstadr = (pp->processed) ? 1000 pp->cast_flags == MDF_BCAST ? 1001 GET_INADDR(pp->dstadr->bcast): 1002 pp->cast_flags ? 1003 GET_INADDR(pp->dstadr->sin) ? 1004 GET_INADDR(pp->dstadr->sin): 1005 GET_INADDR(pp->dstadr->bcast): 1006 3 : 7; 1007 else 1008 memset(&ip->dstadr, 0, sizeof(ip->dstadr)); 1009 1010 ip->srcadr = GET_INADDR(pp->srcadr); 1011 if (client_v6_capable) 1012 ip->v6_flag = 0; 1013 } else { 1014 if (pp->dstadr) 1015 ip->dstadr6 = pp->cast_flags == MDF_BCAST ? 1016 GET_INADDR6(pp->dstadr->bcast): 1017 GET_INADDR6(pp->dstadr->sin); 1018 else 1019 memset(&ip->dstadr6, 0, sizeof(ip->dstadr6)); 1020 1021 ip->srcadr6 = GET_INADDR6(pp->srcadr); 1022 ip->v6_flag = 1; 1023 } 1024 ip->srcport = NSRCPORT(&pp->srcadr); 1025 ip->flags = 0; 1026 if (pp == sys_peer) 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(); 1057 } 1058 flush_pkt(); 1059 } 1060 1061 1062 /* 1063 * sys_info - return system info 1064 */ 1065 static void 1066 sys_info( 1067 struct sockaddr_storage *srcadr, 1068 struct interface *inter, 1069 struct req_pkt *inpkt 1070 ) 1071 { 1072 register struct info_sys *is; 1073 1074 is = (struct info_sys *)prepare_pkt(srcadr, inter, inpkt, 1075 v6sizeof(struct info_sys)); 1076 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) 1081 is->v6_flag = 0; 1082 } else if (client_v6_capable) { 1083 is->peer6 = GET_INADDR6(sys_peer->srcadr); 1084 is->v6_flag = 1; 1085 } 1086 is->peer_mode = sys_peer->hmode; 1087 } else { 1088 is->peer = 0; 1089 if (client_v6_capable) { 1090 is->v6_flag = 0; 1091 } 1092 is->peer_mode = 0; 1093 } 1094 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); 1104 1105 is->poll = sys_poll; 1106 1107 is->flags = 0; 1108 if (sys_authenticate) 1109 is->flags |= INFO_FLAG_AUTHENTICATE; 1110 if (sys_bclient) 1111 is->flags |= INFO_FLAG_BCLIENT; 1112 #ifdef REFCLOCK 1113 if (cal_enable) 1114 is->flags |= INFO_FLAG_CAL; 1115 #endif /* REFCLOCK */ 1116 if (kern_enable) 1117 is->flags |= INFO_FLAG_KERNEL; 1118 if (mon_enabled != MON_OFF) 1119 is->flags |= INFO_FLAG_MONITOR; 1120 if (ntp_enable) 1121 is->flags |= INFO_FLAG_NTP; 1122 if (pps_enable) 1123 is->flags |= INFO_FLAG_PPS_SYNC; 1124 if (stats_control) 1125 is->flags |= INFO_FLAG_FILEGEN; 1126 is->bdelay = HTONS_FP(DTOFP(sys_bdelay)); 1127 HTONL_UF(sys_authdelay.l_f, &is->authdelay); 1128 1129 (void) more_pkt(); 1130 flush_pkt(); 1131 } 1132 1133 1134 /* 1135 * sys_stats - return system statistics 1136 */ 1137 static void 1138 sys_stats( 1139 struct sockaddr_storage *srcadr, 1140 struct interface *inter, 1141 struct req_pkt *inpkt 1142 ) 1143 { 1144 register struct info_sys_stats *ss; 1145 1146 /* 1147 * Importations from the protocol module 1148 */ 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); 1162 (void) more_pkt(); 1163 flush_pkt(); 1164 } 1165 1166 1167 /* 1168 * mem_stats - return memory statistics 1169 */ 1170 static void 1171 mem_stats( 1172 struct sockaddr_storage *srcadr, 1173 struct interface *inter, 1174 struct req_pkt *inpkt 1175 ) 1176 { 1177 register struct info_mem_stats *ms; 1178 register int i; 1179 1180 /* 1181 * Importations from the peer module 1182 */ 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; 1190 1191 ms = (struct info_mem_stats *)prepare_pkt(srcadr, inter, inpkt, 1192 sizeof(struct info_mem_stats)); 1193 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); 1200 1201 for (i = 0; i < NTP_HASH_SIZE; i++) { 1202 if (peer_hash_count[i] > 255) 1203 ms->hashcount[i] = 255; 1204 else 1205 ms->hashcount[i] = (u_char)peer_hash_count[i]; 1206 } 1207 1208 (void) more_pkt(); 1209 flush_pkt(); 1210 } 1211 1212 1213 /* 1214 * io_stats - return io statistics 1215 */ 1216 static void 1217 io_stats( 1218 struct sockaddr_storage *srcadr, 1219 struct interface *inter, 1220 struct req_pkt *inpkt 1221 ) 1222 { 1223 register struct info_io_stats *io; 1224 1225 /* 1226 * Importations from the io module 1227 */ 1228 extern u_long io_timereset; 1229 1230 io = (struct info_io_stats *)prepare_pkt(srcadr, inter, inpkt, 1231 sizeof(struct info_io_stats)); 1232 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); 1245 1246 (void) more_pkt(); 1247 flush_pkt(); 1248 } 1249 1250 1251 /* 1252 * timer_stats - return timer statistics 1253 */ 1254 static void 1255 timer_stats( 1256 struct sockaddr_storage *srcadr, 1257 struct interface *inter, 1258 struct req_pkt *inpkt 1259 ) 1260 { 1261 register struct info_timer_stats *ts; 1262 1263 /* 1264 * Importations from the timer module 1265 */ 1266 extern u_long timer_timereset; 1267 extern u_long timer_overflows; 1268 extern u_long timer_xmtcalls; 1269 1270 ts = (struct info_timer_stats *)prepare_pkt(srcadr, inter, inpkt, 1271 sizeof(struct info_timer_stats)); 1272 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); 1277 1278 (void) more_pkt(); 1279 flush_pkt(); 1280 } 1281 1282 1283 /* 1284 * loop_info - return the current state of the loop filter 1285 */ 1286 static void 1287 loop_info( 1288 struct sockaddr_storage *srcadr, 1289 struct interface *inter, 1290 struct req_pkt *inpkt 1291 ) 1292 { 1293 register struct info_loop *li; 1294 l_fp ltmp; 1295 1296 /* 1297 * Importations from the loop filter module 1298 */ 1299 extern double last_offset; 1300 extern double drift_comp; 1301 extern int tc_counter; 1302 extern u_long sys_clocktime; 1303 1304 li = (struct info_loop *)prepare_pkt(srcadr, inter, inpkt, 1305 sizeof(struct info_loop)); 1306 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)); 1313 1314 (void) more_pkt(); 1315 flush_pkt(); 1316 } 1317 1318 1319 /* 1320 * do_conf - add a peer to the configuration list 1321 */ 1322 static void 1323 do_conf( 1324 struct sockaddr_storage *srcadr, 1325 struct interface *inter, 1326 struct req_pkt *inpkt 1327 ) 1328 { 1329 static u_long soonest_ifrescan_time = 0; 1330 int items; 1331 u_int fl; 1332 struct conf_peer *cp; 1333 struct conf_peer temp_cp; 1334 struct sockaddr_storage peeraddr; 1335 struct sockaddr_in tmp_clock; 1336 1337 /* 1338 * Do a check of everything to see that it looks 1339 * okay. If not, complain about it. Note we are 1340 * very picky here. 1341 */ 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)); 1346 fl = 0; 1347 while (items-- > 0 && !fl) { 1348 if (((temp_cp.version) > NTP_VERSION) 1349 || ((temp_cp.version) < NTP_OLDVERSION)) 1350 fl = 1; 1351 if (temp_cp.hmode != MODE_ACTIVE 1352 && temp_cp.hmode != MODE_CLIENT 1353 && temp_cp.hmode != MODE_BROADCAST) 1354 fl = 1; 1355 if (temp_cp.flags & ~(CONF_FLAG_AUTHENABLE | CONF_FLAG_PREFER 1356 | CONF_FLAG_BURST | CONF_FLAG_IBURST | CONF_FLAG_SKEY)) 1357 fl = 1; 1358 cp = (struct conf_peer *) 1359 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize)); 1360 } 1361 1362 if (fl) { 1363 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 1364 return; 1365 } 1366 1367 /* 1368 * Looks okay, try it out 1369 */ 1370 items = INFO_NITEMS(inpkt->err_nitems); 1371 cp = (struct conf_peer *)inpkt->data; 1372 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)); 1377 1378 fl = 0; 1379 if (temp_cp.flags & CONF_FLAG_AUTHENABLE) 1380 fl |= FLAG_AUTHENABLE; 1381 if (temp_cp.flags & CONF_FLAG_PREFER) 1382 fl |= FLAG_PREFER; 1383 if (temp_cp.flags & CONF_FLAG_BURST) 1384 fl |= FLAG_BURST; 1385 if (temp_cp.flags & CONF_FLAG_IBURST) 1386 fl |= FLAG_IBURST; 1387 if (temp_cp.flags & CONF_FLAG_SKEY) 1388 fl |= FLAG_SKEY; 1389 1390 if (client_v6_capable && temp_cp.v6_flag != 0) { 1391 peeraddr.ss_family = AF_INET6; 1392 GET_INADDR6(peeraddr) = temp_cp.peeraddr6; 1393 } else { 1394 peeraddr.ss_family = AF_INET; 1395 GET_INADDR(peeraddr) = temp_cp.peeraddr; 1396 /* 1397 * Make sure the address is valid 1398 */ 1399 tmp_clock = *CAST_V4(peeraddr); 1400 if ( 1401 #ifdef REFCLOCK 1402 !ISREFCLOCKADR(&tmp_clock) && 1403 #endif 1404 ISBADADR(&tmp_clock)) { 1405 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 1406 return; 1407 } 1408 1409 } 1410 NSRCPORT(&peeraddr) = htons(NTP_PORT); 1411 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR 1412 peeraddr.ss_len = SOCKLEN(&peeraddr); 1413 #endif 1414 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, 1419 NULL) == 0) { 1420 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 1421 return; 1422 } 1423 1424 /* 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. 1433 */ 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")); 1438 } 1439 1440 cp = (struct conf_peer *) 1441 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize)); 1442 } 1443 1444 req_ack(srcadr, inter, inpkt, INFO_OKAY); 1445 } 1446 1447 #if 0 1448 /* XXX */ 1449 /* 1450 * dns_a - Snarf DNS info for an association ID 1451 */ 1452 static void 1453 dns_a( 1454 struct sockaddr_storage *srcadr, 1455 struct interface *inter, 1456 struct req_pkt *inpkt 1457 ) 1458 { 1459 register struct info_dns_assoc *dp; 1460 register int items; 1461 struct sockaddr_in peeraddr; 1462 1463 /* 1464 * Do a check of everything to see that it looks 1465 * okay. If not, complain about it. Note we are 1466 * very picky here. 1467 */ 1468 items = INFO_NITEMS(inpkt->err_nitems); 1469 dp = (struct info_dns_assoc *)inpkt->data; 1470 1471 /* 1472 * Looks okay, try it out 1473 */ 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); 1479 1480 /* 1481 * Make sure the address is valid 1482 */ 1483 if ( 1484 #ifdef REFCLOCK 1485 !ISREFCLOCKADR(&peeraddr) && 1486 #endif 1487 ISBADADR(&peeraddr)) { 1488 #ifdef REFCLOCK 1489 msyslog(LOG_ERR, "dns_a: !ISREFCLOCK && ISBADADR"); 1490 #else 1491 msyslog(LOG_ERR, "dns_a: ISBADADR"); 1492 #endif 1493 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 1494 return; 1495 } 1496 1497 while (items-- > 0) { 1498 associd_t associd; 1499 size_t hnl; 1500 struct peer *peer; 1501 int bogon = 0; 1502 1503 associd = dp->associd; 1504 peer = findpeerbyassoc(associd); 1505 if (peer == 0 || peer->flags & FLAG_REFCLOCK) { 1506 msyslog(LOG_ERR, "dns_a: %s", 1507 (peer == 0) 1508 ? "peer == 0" 1509 : "peer->flags & FLAG_REFCLOCK"); 1510 ++bogon; 1511 } 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); 1517 ++bogon; 1518 } 1519 1520 msyslog(LOG_INFO, "dns_a: <%s> for %s, AssocID %d, bogon %d", 1521 dp->hostname, 1522 stoa((struct sockaddr_storage *)&peeraddr), associd, 1523 bogon); 1524 1525 if (bogon) { 1526 /* If it didn't work */ 1527 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 1528 return; 1529 } else { 1530 #if 0 1531 #ifdef PUBKEY 1532 crypto_public(peer, dp->hostname); 1533 #endif /* PUBKEY */ 1534 #endif 1535 } 1536 1537 dp++; 1538 } 1539 1540 req_ack(srcadr, inter, inpkt, INFO_OKAY); 1541 } 1542 #endif /* 0 */ 1543 1544 /* 1545 * do_unconf - remove a peer from the configuration list 1546 */ 1547 static void 1548 do_unconf( 1549 struct sockaddr_storage *srcadr, 1550 struct interface *inter, 1551 struct req_pkt *inpkt 1552 ) 1553 { 1554 register struct conf_unpeer *cp; 1555 struct conf_unpeer temp_cp; 1556 register int items; 1557 register struct peer *peer; 1558 struct sockaddr_storage peeraddr; 1559 int bad, found; 1560 1561 /* 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 1565 * an error. 1566 */ 1567 items = INFO_NITEMS(inpkt->err_nitems); 1568 cp = (struct conf_unpeer *)inpkt->data; 1569 1570 bad = 0; 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; 1578 } else { 1579 peeraddr.ss_family = AF_INET; 1580 GET_INADDR(peeraddr) = temp_cp.peeraddr; 1581 } 1582 NSRCPORT(&peeraddr) = htons(NTP_PORT); 1583 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR 1584 peeraddr.ss_len = SOCKLEN(&peeraddr); 1585 #endif 1586 found = 0; 1587 peer = (struct peer *)0; 1588 #ifdef DEBUG 1589 if (debug) 1590 printf("searching for %s\n", stoa(&peeraddr)); 1591 #endif 1592 while (!found) { 1593 peer = findexistingpeer(&peeraddr, peer, -1); 1594 if (peer == (struct peer *)0) 1595 break; 1596 if (peer->flags & FLAG_CONFIG) 1597 found = 1; 1598 } 1599 if (!found) 1600 bad = 1; 1601 cp = (struct conf_unpeer *) 1602 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize)); 1603 } 1604 1605 if (bad) { 1606 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 1607 return; 1608 } 1609 1610 /* 1611 * Now do it in earnest. 1612 */ 1613 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; 1623 } else { 1624 peeraddr.ss_family = AF_INET; 1625 GET_INADDR(peeraddr) = temp_cp.peeraddr; 1626 } 1627 NSRCPORT(&peeraddr) = htons(NTP_PORT); 1628 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR 1629 peeraddr.ss_len = SOCKLEN(&peeraddr); 1630 #endif 1631 peer_unconfig(&peeraddr, (struct interface *)0, -1); 1632 cp = (struct conf_unpeer *) 1633 ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize)); 1634 } 1635 1636 req_ack(srcadr, inter, inpkt, INFO_OKAY); 1637 } 1638 1639 1640 /* 1641 * set_sys_flag - set system flags 1642 */ 1643 static void 1644 set_sys_flag( 1645 struct sockaddr_storage *srcadr, 1646 struct interface *inter, 1647 struct req_pkt *inpkt 1648 ) 1649 { 1650 setclr_flags(srcadr, inter, inpkt, 1); 1651 } 1652 1653 1654 /* 1655 * clr_sys_flag - clear system flags 1656 */ 1657 static void 1658 clr_sys_flag( 1659 struct sockaddr_storage *srcadr, 1660 struct interface *inter, 1661 struct req_pkt *inpkt 1662 ) 1663 { 1664 setclr_flags(srcadr, inter, inpkt, 0); 1665 } 1666 1667 1668 /* 1669 * setclr_flags - do the grunge work of flag setting/clearing 1670 */ 1671 static void 1672 setclr_flags( 1673 struct sockaddr_storage *srcadr, 1674 struct interface *inter, 1675 struct req_pkt *inpkt, 1676 u_long set 1677 ) 1678 { 1679 register u_int flags; 1680 int prev_kern_enable; 1681 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); 1686 return; 1687 } 1688 1689 flags = ((struct conf_sys_flags *)inpkt->data)->flags; 1690 flags = ntohl(flags); 1691 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); 1701 return; 1702 } 1703 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); 1721 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); 1727 } 1728 1729 1730 /* 1731 * list_restrict - return the restrict list 1732 */ 1733 static void 1734 list_restrict( 1735 struct sockaddr_storage *srcadr, 1736 struct interface *inter, 1737 struct req_pkt *inpkt 1738 ) 1739 { 1740 register struct info_restrict *ir; 1741 register struct restrictlist *rl; 1742 register struct restrictlist6 *rl6; 1743 1744 #ifdef DEBUG 1745 if (debug > 2) 1746 printf("wants restrict list summary\n"); 1747 #endif 1748 1749 ir = (struct info_restrict *)prepare_pkt(srcadr, inter, inpkt, 1750 v6sizeof(struct info_restrict)); 1751 1752 for (rl = restrictlist; rl != 0 && ir != 0; rl = rl->next) { 1753 ir->addr = htonl(rl->addr); 1754 if (client_v6_capable) 1755 ir->v6_flag = 0; 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(); 1761 } 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; 1766 ir->v6_flag = 1; 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(); 1771 } 1772 flush_pkt(); 1773 } 1774 1775 1776 1777 /* 1778 * do_resaddflags - add flags to a restrict entry (or create one) 1779 */ 1780 static void 1781 do_resaddflags( 1782 struct sockaddr_storage *srcadr, 1783 struct interface *inter, 1784 struct req_pkt *inpkt 1785 ) 1786 { 1787 do_restrict(srcadr, inter, inpkt, RESTRICT_FLAGS); 1788 } 1789 1790 1791 1792 /* 1793 * do_ressubflags - remove flags from a restrict entry 1794 */ 1795 static void 1796 do_ressubflags( 1797 struct sockaddr_storage *srcadr, 1798 struct interface *inter, 1799 struct req_pkt *inpkt 1800 ) 1801 { 1802 do_restrict(srcadr, inter, inpkt, RESTRICT_UNFLAG); 1803 } 1804 1805 1806 /* 1807 * do_unrestrict - remove a restrict entry from the list 1808 */ 1809 static void 1810 do_unrestrict( 1811 struct sockaddr_storage *srcadr, 1812 struct interface *inter, 1813 struct req_pkt *inpkt 1814 ) 1815 { 1816 do_restrict(srcadr, inter, inpkt, RESTRICT_REMOVE); 1817 } 1818 1819 1820 1821 1822 1823 /* 1824 * do_restrict - do the dirty stuff of dealing with restrictions 1825 */ 1826 static void 1827 do_restrict( 1828 struct sockaddr_storage *srcadr, 1829 struct interface *inter, 1830 struct req_pkt *inpkt, 1831 int op 1832 ) 1833 { 1834 register struct conf_restrict *cr; 1835 register int items; 1836 struct sockaddr_storage matchaddr; 1837 struct sockaddr_storage matchmask; 1838 int bad; 1839 1840 /* 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. 1844 */ 1845 items = INFO_NITEMS(inpkt->err_nitems); 1846 cr = (struct conf_restrict *)inpkt->data; 1847 1848 bad = 0; 1849 cr->flags = ntohs(cr->flags); 1850 cr->mflags = ntohs(cr->mflags); 1851 while (items-- > 0 && !bad) { 1852 if (cr->mflags & ~(RESM_NTPONLY)) 1853 bad |= 1; 1854 if (cr->flags & ~(RES_ALLFLAGS)) 1855 bad |= 2; 1856 if (cr->mask != htonl(INADDR_ANY)) { 1857 if (client_v6_capable && cr->v6_flag != 0) { 1858 if (IN6_IS_ADDR_UNSPECIFIED(&cr->addr6)) 1859 bad |= 4; 1860 } else 1861 if (cr->addr == htonl(INADDR_ANY)) 1862 bad |= 8; 1863 } 1864 cr = (struct conf_restrict *)((char *)cr + 1865 INFO_ITEMSIZE(inpkt->mbz_itemsize)); 1866 } 1867 1868 if (bad) { 1869 msyslog(LOG_ERR, "do_restrict: bad = %#x", bad); 1870 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 1871 return; 1872 } 1873 1874 /* 1875 * Looks okay, try it out 1876 */ 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)); 1881 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; 1888 } else { 1889 GET_INADDR(matchaddr) = cr->addr; 1890 GET_INADDR(matchmask) = cr->mask; 1891 matchaddr.ss_family = AF_INET; 1892 matchmask.ss_family = AF_INET; 1893 } 1894 hack_restrict(op, &matchaddr, &matchmask, cr->mflags, 1895 cr->flags); 1896 cr++; 1897 } 1898 1899 req_ack(srcadr, inter, inpkt, INFO_OKAY); 1900 } 1901 1902 1903 /* 1904 * mon_getlist - return monitor data 1905 */ 1906 static void 1907 mon_getlist_0( 1908 struct sockaddr_storage *srcadr, 1909 struct interface *inter, 1910 struct req_pkt *inpkt 1911 ) 1912 { 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; 1917 1918 #ifdef DEBUG 1919 if (debug > 2) 1920 printf("wants monitor 0 list\n"); 1921 #endif 1922 if (!mon_enabled) { 1923 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 1924 return; 1925 } 1926 im = (struct info_monitor *)prepare_pkt(srcadr, inter, inpkt, 1927 v6sizeof(struct info_monitor)); 1928 for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0; 1929 md = md->mru_next) { 1930 im->lasttime = htonl((u_int32)md->avg_interval); 1931 im->firsttime = htonl((u_int32)(current_time - md->lasttime)); 1932 im->lastdrop = htonl((u_int32)md->drop_count); 1933 im->count = htonl((u_int32)(md->count)); 1934 if (md->rmtadr.ss_family == AF_INET6) { 1935 if (!client_v6_capable) 1936 continue; 1937 im->addr6 = GET_INADDR6(md->rmtadr); 1938 im->v6_flag = 1; 1939 } else { 1940 im->addr = GET_INADDR(md->rmtadr); 1941 if (client_v6_capable) 1942 im->v6_flag = 0; 1943 } 1944 im->port = md->rmtport; 1945 im->mode = md->mode; 1946 im->version = md->version; 1947 im = (struct info_monitor *)more_pkt(); 1948 } 1949 flush_pkt(); 1950 } 1951 1952 /* 1953 * mon_getlist - return monitor data 1954 */ 1955 static void 1956 mon_getlist_1( 1957 struct sockaddr_storage *srcadr, 1958 struct interface *inter, 1959 struct req_pkt *inpkt 1960 ) 1961 { 1962 register struct info_monitor_1 *im; 1963 register struct mon_data *md; 1964 extern struct mon_data mon_mru_list; 1965 extern int mon_enabled; 1966 1967 if (!mon_enabled) { 1968 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 1969 return; 1970 } 1971 im = (struct info_monitor_1 *)prepare_pkt(srcadr, inter, inpkt, 1972 v6sizeof(struct info_monitor_1)); 1973 for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0; 1974 md = md->mru_next) { 1975 im->lasttime = htonl((u_int32)md->avg_interval); 1976 im->firsttime = htonl((u_int32)(current_time - md->lasttime)); 1977 im->lastdrop = htonl((u_int32)md->drop_count); 1978 im->count = htonl((u_int32)md->count); 1979 if (md->rmtadr.ss_family == AF_INET6) { 1980 if (!client_v6_capable) 1981 continue; 1982 im->addr6 = GET_INADDR6(md->rmtadr); 1983 im->v6_flag = 1; 1984 im->daddr6 = GET_INADDR6(md->interface->sin); 1985 } else { 1986 im->addr = GET_INADDR(md->rmtadr); 1987 if (client_v6_capable) 1988 im->v6_flag = 0; 1989 im->daddr = (md->cast_flags == MDF_BCAST) 1990 ? GET_INADDR(md->interface->bcast) 1991 : (md->cast_flags 1992 ? (GET_INADDR(md->interface->sin) 1993 ? GET_INADDR(md->interface->sin) 1994 : GET_INADDR(md->interface->bcast)) 1995 : 4); 1996 } 1997 im->flags = htonl(md->cast_flags); 1998 im->port = md->rmtport; 1999 im->mode = md->mode; 2000 im->version = md->version; 2001 im = (struct info_monitor_1 *)more_pkt(); 2002 } 2003 flush_pkt(); 2004 } 2005 2006 /* 2007 * Module entry points and the flags they correspond with 2008 */ 2009 struct reset_entry { 2010 int flag; /* flag this corresponds to */ 2011 void (*handler) P((void)); /* routine to handle request */ 2012 }; 2013 2014 struct reset_entry reset_entries[] = { 2015 { RESET_FLAG_ALLPEERS, peer_all_reset }, 2016 { RESET_FLAG_IO, io_clr_stats }, 2017 { RESET_FLAG_SYS, proto_clr_stats }, 2018 { RESET_FLAG_MEM, peer_clr_stats }, 2019 { RESET_FLAG_TIMER, timer_clr_stats }, 2020 { RESET_FLAG_AUTH, reset_auth_stats }, 2021 { RESET_FLAG_CTL, ctl_clr_stats }, 2022 { 0, 0 } 2023 }; 2024 2025 /* 2026 * reset_stats - reset statistic counters here and there 2027 */ 2028 static void 2029 reset_stats( 2030 struct sockaddr_storage *srcadr, 2031 struct interface *inter, 2032 struct req_pkt *inpkt 2033 ) 2034 { 2035 u_long flags; 2036 struct reset_entry *rent; 2037 2038 if (INFO_NITEMS(inpkt->err_nitems) > 1) { 2039 msyslog(LOG_ERR, "reset_stats: err_nitems > 1"); 2040 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 2041 return; 2042 } 2043 2044 flags = ((struct reset_flags *)inpkt->data)->flags; 2045 flags = ntohl(flags); 2046 2047 if (flags & ~RESET_ALLFLAGS) { 2048 msyslog(LOG_ERR, "reset_stats: reset leaves %#lx", 2049 flags & ~RESET_ALLFLAGS); 2050 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 2051 return; 2052 } 2053 2054 for (rent = reset_entries; rent->flag != 0; rent++) { 2055 if (flags & rent->flag) 2056 (rent->handler)(); 2057 } 2058 req_ack(srcadr, inter, inpkt, INFO_OKAY); 2059 } 2060 2061 2062 /* 2063 * reset_peer - clear a peer's statistics 2064 */ 2065 static void 2066 reset_peer( 2067 struct sockaddr_storage *srcadr, 2068 struct interface *inter, 2069 struct req_pkt *inpkt 2070 ) 2071 { 2072 register struct conf_unpeer *cp; 2073 register int items; 2074 register struct peer *peer; 2075 struct sockaddr_storage peeraddr; 2076 int bad; 2077 2078 /* 2079 * We check first to see that every peer exists. If not, 2080 * we return an error. 2081 */ 2082 2083 items = INFO_NITEMS(inpkt->err_nitems); 2084 cp = (struct conf_unpeer *)inpkt->data; 2085 2086 bad = 0; 2087 while (items-- > 0 && !bad) { 2088 memset((char *)&peeraddr, 0, sizeof(peeraddr)); 2089 if (client_v6_capable && cp->v6_flag != 0) { 2090 GET_INADDR6(peeraddr) = cp->peeraddr6; 2091 peeraddr.ss_family = AF_INET6; 2092 } else { 2093 GET_INADDR(peeraddr) = cp->peeraddr; 2094 peeraddr.ss_family = AF_INET; 2095 } 2096 NSRCPORT(&peeraddr) = htons(NTP_PORT); 2097 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR 2098 peeraddr.ss_len = SOCKLEN(&peeraddr); 2099 #endif 2100 peer = findexistingpeer(&peeraddr, (struct peer *)0, -1); 2101 if (peer == (struct peer *)0) 2102 bad++; 2103 cp = (struct conf_unpeer *)((char *)cp + 2104 INFO_ITEMSIZE(inpkt->mbz_itemsize)); 2105 } 2106 2107 if (bad) { 2108 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 2109 return; 2110 } 2111 2112 /* 2113 * Now do it in earnest. 2114 */ 2115 2116 items = INFO_NITEMS(inpkt->err_nitems); 2117 cp = (struct conf_unpeer *)inpkt->data; 2118 while (items-- > 0) { 2119 memset((char *)&peeraddr, 0, sizeof(peeraddr)); 2120 if (client_v6_capable && cp->v6_flag != 0) { 2121 GET_INADDR6(peeraddr) = cp->peeraddr6; 2122 peeraddr.ss_family = AF_INET6; 2123 } else { 2124 GET_INADDR(peeraddr) = cp->peeraddr; 2125 peeraddr.ss_family = AF_INET; 2126 } 2127 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR 2128 peeraddr.ss_len = SOCKLEN(&peeraddr); 2129 #endif 2130 peer = findexistingpeer(&peeraddr, (struct peer *)0, -1); 2131 while (peer != 0) { 2132 peer_reset(peer); 2133 peer = findexistingpeer(&peeraddr, (struct peer *)peer, -1); 2134 } 2135 cp = (struct conf_unpeer *)((char *)cp + 2136 INFO_ITEMSIZE(inpkt->mbz_itemsize)); 2137 } 2138 2139 req_ack(srcadr, inter, inpkt, INFO_OKAY); 2140 } 2141 2142 2143 /* 2144 * do_key_reread - reread the encryption key file 2145 */ 2146 static void 2147 do_key_reread( 2148 struct sockaddr_storage *srcadr, 2149 struct interface *inter, 2150 struct req_pkt *inpkt 2151 ) 2152 { 2153 rereadkeys(); 2154 req_ack(srcadr, inter, inpkt, INFO_OKAY); 2155 } 2156 2157 2158 /* 2159 * trust_key - make one or more keys trusted 2160 */ 2161 static void 2162 trust_key( 2163 struct sockaddr_storage *srcadr, 2164 struct interface *inter, 2165 struct req_pkt *inpkt 2166 ) 2167 { 2168 do_trustkey(srcadr, inter, inpkt, 1); 2169 } 2170 2171 2172 /* 2173 * untrust_key - make one or more keys untrusted 2174 */ 2175 static void 2176 untrust_key( 2177 struct sockaddr_storage *srcadr, 2178 struct interface *inter, 2179 struct req_pkt *inpkt 2180 ) 2181 { 2182 do_trustkey(srcadr, inter, inpkt, 0); 2183 } 2184 2185 2186 /* 2187 * do_trustkey - make keys either trustable or untrustable 2188 */ 2189 static void 2190 do_trustkey( 2191 struct sockaddr_storage *srcadr, 2192 struct interface *inter, 2193 struct req_pkt *inpkt, 2194 u_long trust 2195 ) 2196 { 2197 register u_long *kp; 2198 register int items; 2199 2200 items = INFO_NITEMS(inpkt->err_nitems); 2201 kp = (u_long *)inpkt->data; 2202 while (items-- > 0) { 2203 authtrust(*kp, trust); 2204 kp++; 2205 } 2206 2207 req_ack(srcadr, inter, inpkt, INFO_OKAY); 2208 } 2209 2210 2211 /* 2212 * get_auth_info - return some stats concerning the authentication module 2213 */ 2214 static void 2215 get_auth_info( 2216 struct sockaddr_storage *srcadr, 2217 struct interface *inter, 2218 struct req_pkt *inpkt 2219 ) 2220 { 2221 register struct info_auth *ia; 2222 2223 /* 2224 * Importations from the authentication module 2225 */ 2226 extern u_long authnumkeys; 2227 extern int authnumfreekeys; 2228 extern u_long authkeylookups; 2229 extern u_long authkeynotfound; 2230 extern u_long authencryptions; 2231 extern u_long authdecryptions; 2232 extern u_long authkeyuncached; 2233 extern u_long authkeyexpired; 2234 2235 ia = (struct info_auth *)prepare_pkt(srcadr, inter, inpkt, 2236 sizeof(struct info_auth)); 2237 2238 ia->numkeys = htonl((u_int32)authnumkeys); 2239 ia->numfreekeys = htonl((u_int32)authnumfreekeys); 2240 ia->keylookups = htonl((u_int32)authkeylookups); 2241 ia->keynotfound = htonl((u_int32)authkeynotfound); 2242 ia->encryptions = htonl((u_int32)authencryptions); 2243 ia->decryptions = htonl((u_int32)authdecryptions); 2244 ia->keyuncached = htonl((u_int32)authkeyuncached); 2245 ia->expired = htonl((u_int32)authkeyexpired); 2246 ia->timereset = htonl((u_int32)(current_time - auth_timereset)); 2247 2248 (void) more_pkt(); 2249 flush_pkt(); 2250 } 2251 2252 2253 2254 /* 2255 * reset_auth_stats - reset the authentication stat counters. Done here 2256 * to keep ntp-isms out of the authentication module 2257 */ 2258 static void 2259 reset_auth_stats(void) 2260 { 2261 /* 2262 * Importations from the authentication module 2263 */ 2264 extern u_long authkeylookups; 2265 extern u_long authkeynotfound; 2266 extern u_long authencryptions; 2267 extern u_long authdecryptions; 2268 extern u_long authkeyuncached; 2269 2270 authkeylookups = 0; 2271 authkeynotfound = 0; 2272 authencryptions = 0; 2273 authdecryptions = 0; 2274 authkeyuncached = 0; 2275 auth_timereset = current_time; 2276 } 2277 2278 2279 /* 2280 * req_get_traps - return information about current trap holders 2281 */ 2282 static void 2283 req_get_traps( 2284 struct sockaddr_storage *srcadr, 2285 struct interface *inter, 2286 struct req_pkt *inpkt 2287 ) 2288 { 2289 register struct info_trap *it; 2290 register struct ctl_trap *tr; 2291 register int i; 2292 2293 /* 2294 * Imported from the control module 2295 */ 2296 extern struct ctl_trap ctl_trap[]; 2297 extern int num_ctl_traps; 2298 2299 if (num_ctl_traps == 0) { 2300 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 2301 return; 2302 } 2303 2304 it = (struct info_trap *)prepare_pkt(srcadr, inter, inpkt, 2305 v6sizeof(struct info_trap)); 2306 2307 for (i = 0, tr = ctl_trap; i < CTL_MAXTRAPS; i++, tr++) { 2308 if (tr->tr_flags & TRAP_INUSE) { 2309 if (tr->tr_addr.ss_family == AF_INET) { 2310 if (tr->tr_localaddr == any_interface) 2311 it->local_address = 0; 2312 else 2313 it->local_address 2314 = GET_INADDR(tr->tr_localaddr->sin); 2315 it->trap_address = GET_INADDR(tr->tr_addr); 2316 if (client_v6_capable) 2317 it->v6_flag = 0; 2318 } else { 2319 if (!client_v6_capable) 2320 continue; 2321 it->local_address6 2322 = GET_INADDR6(tr->tr_localaddr->sin); 2323 it->trap_address6 = GET_INADDR6(tr->tr_addr); 2324 it->v6_flag = 1; 2325 } 2326 it->trap_port = NSRCPORT(&tr->tr_addr); 2327 it->sequence = htons(tr->tr_sequence); 2328 it->settime = htonl((u_int32)(current_time - tr->tr_settime)); 2329 it->origtime = htonl((u_int32)(current_time - tr->tr_origtime)); 2330 it->resets = htonl((u_int32)tr->tr_resets); 2331 it->flags = htonl((u_int32)tr->tr_flags); 2332 it = (struct info_trap *)more_pkt(); 2333 } 2334 } 2335 flush_pkt(); 2336 } 2337 2338 2339 /* 2340 * req_set_trap - configure a trap 2341 */ 2342 static void 2343 req_set_trap( 2344 struct sockaddr_storage *srcadr, 2345 struct interface *inter, 2346 struct req_pkt *inpkt 2347 ) 2348 { 2349 do_setclr_trap(srcadr, inter, inpkt, 1); 2350 } 2351 2352 2353 2354 /* 2355 * req_clr_trap - unconfigure a trap 2356 */ 2357 static void 2358 req_clr_trap( 2359 struct sockaddr_storage *srcadr, 2360 struct interface *inter, 2361 struct req_pkt *inpkt 2362 ) 2363 { 2364 do_setclr_trap(srcadr, inter, inpkt, 0); 2365 } 2366 2367 2368 2369 /* 2370 * do_setclr_trap - do the grunge work of (un)configuring a trap 2371 */ 2372 static void 2373 do_setclr_trap( 2374 struct sockaddr_storage *srcadr, 2375 struct interface *inter, 2376 struct req_pkt *inpkt, 2377 int set 2378 ) 2379 { 2380 register struct conf_trap *ct; 2381 register struct interface *linter; 2382 int res; 2383 struct sockaddr_storage laddr; 2384 2385 /* 2386 * Prepare sockaddr_storage structure 2387 */ 2388 memset((char *)&laddr, 0, sizeof laddr); 2389 laddr.ss_family = srcadr->ss_family; 2390 NSRCPORT(&laddr) = ntohs(NTP_PORT); 2391 2392 /* 2393 * Restrict ourselves to one item only. This eliminates 2394 * the error reporting problem. 2395 */ 2396 if (INFO_NITEMS(inpkt->err_nitems) > 1) { 2397 msyslog(LOG_ERR, "do_setclr_trap: err_nitems > 1"); 2398 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 2399 return; 2400 } 2401 ct = (struct conf_trap *)inpkt->data; 2402 2403 /* 2404 * Look for the local interface. If none, use the default. 2405 */ 2406 if (ct->local_address == 0) { 2407 linter = any_interface; 2408 } else { 2409 if (laddr.ss_family == AF_INET) 2410 GET_INADDR(laddr) = ct->local_address; 2411 else 2412 GET_INADDR6(laddr) = ct->local_address6; 2413 linter = findinterface(&laddr); 2414 if (linter == NULL) { 2415 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 2416 return; 2417 } 2418 } 2419 2420 if (laddr.ss_family == AF_INET) 2421 GET_INADDR(laddr) = ct->trap_address; 2422 else 2423 GET_INADDR6(laddr) = ct->trap_address6; 2424 if (ct->trap_port != 0) 2425 NSRCPORT(&laddr) = ct->trap_port; 2426 else 2427 NSRCPORT(&laddr) = htons(TRAPPORT); 2428 2429 if (set) { 2430 res = ctlsettrap(&laddr, linter, 0, 2431 INFO_VERSION(inpkt->rm_vn_mode)); 2432 } else { 2433 res = ctlclrtrap(&laddr, linter, 0); 2434 } 2435 2436 if (!res) { 2437 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 2438 } else { 2439 req_ack(srcadr, inter, inpkt, INFO_OKAY); 2440 } 2441 return; 2442 } 2443 2444 2445 2446 /* 2447 * set_request_keyid - set the keyid used to authenticate requests 2448 */ 2449 static void 2450 set_request_keyid( 2451 struct sockaddr_storage *srcadr, 2452 struct interface *inter, 2453 struct req_pkt *inpkt 2454 ) 2455 { 2456 keyid_t keyid; 2457 2458 /* 2459 * Restrict ourselves to one item only. 2460 */ 2461 if (INFO_NITEMS(inpkt->err_nitems) > 1) { 2462 msyslog(LOG_ERR, "set_request_keyid: err_nitems > 1"); 2463 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 2464 return; 2465 } 2466 2467 keyid = ntohl(*((u_int32 *)(inpkt->data))); 2468 info_auth_keyid = keyid; 2469 req_ack(srcadr, inter, inpkt, INFO_OKAY); 2470 } 2471 2472 2473 2474 /* 2475 * set_control_keyid - set the keyid used to authenticate requests 2476 */ 2477 static void 2478 set_control_keyid( 2479 struct sockaddr_storage *srcadr, 2480 struct interface *inter, 2481 struct req_pkt *inpkt 2482 ) 2483 { 2484 keyid_t keyid; 2485 extern keyid_t ctl_auth_keyid; 2486 2487 /* 2488 * Restrict ourselves to one item only. 2489 */ 2490 if (INFO_NITEMS(inpkt->err_nitems) > 1) { 2491 msyslog(LOG_ERR, "set_control_keyid: err_nitems > 1"); 2492 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 2493 return; 2494 } 2495 2496 keyid = ntohl(*((u_int32 *)(inpkt->data))); 2497 ctl_auth_keyid = keyid; 2498 req_ack(srcadr, inter, inpkt, INFO_OKAY); 2499 } 2500 2501 2502 2503 /* 2504 * get_ctl_stats - return some stats concerning the control message module 2505 */ 2506 static void 2507 get_ctl_stats( 2508 struct sockaddr_storage *srcadr, 2509 struct interface *inter, 2510 struct req_pkt *inpkt 2511 ) 2512 { 2513 register struct info_control *ic; 2514 2515 /* 2516 * Importations from the control module 2517 */ 2518 extern u_long ctltimereset; 2519 extern u_long numctlreq; 2520 extern u_long numctlbadpkts; 2521 extern u_long numctlresponses; 2522 extern u_long numctlfrags; 2523 extern u_long numctlerrors; 2524 extern u_long numctltooshort; 2525 extern u_long numctlinputresp; 2526 extern u_long numctlinputfrag; 2527 extern u_long numctlinputerr; 2528 extern u_long numctlbadoffset; 2529 extern u_long numctlbadversion; 2530 extern u_long numctldatatooshort; 2531 extern u_long numctlbadop; 2532 extern u_long numasyncmsgs; 2533 2534 ic = (struct info_control *)prepare_pkt(srcadr, inter, inpkt, 2535 sizeof(struct info_control)); 2536 2537 ic->ctltimereset = htonl((u_int32)(current_time - ctltimereset)); 2538 ic->numctlreq = htonl((u_int32)numctlreq); 2539 ic->numctlbadpkts = htonl((u_int32)numctlbadpkts); 2540 ic->numctlresponses = htonl((u_int32)numctlresponses); 2541 ic->numctlfrags = htonl((u_int32)numctlfrags); 2542 ic->numctlerrors = htonl((u_int32)numctlerrors); 2543 ic->numctltooshort = htonl((u_int32)numctltooshort); 2544 ic->numctlinputresp = htonl((u_int32)numctlinputresp); 2545 ic->numctlinputfrag = htonl((u_int32)numctlinputfrag); 2546 ic->numctlinputerr = htonl((u_int32)numctlinputerr); 2547 ic->numctlbadoffset = htonl((u_int32)numctlbadoffset); 2548 ic->numctlbadversion = htonl((u_int32)numctlbadversion); 2549 ic->numctldatatooshort = htonl((u_int32)numctldatatooshort); 2550 ic->numctlbadop = htonl((u_int32)numctlbadop); 2551 ic->numasyncmsgs = htonl((u_int32)numasyncmsgs); 2552 2553 (void) more_pkt(); 2554 flush_pkt(); 2555 } 2556 2557 2558 #ifdef KERNEL_PLL 2559 /* 2560 * get_kernel_info - get kernel pll/pps information 2561 */ 2562 static void 2563 get_kernel_info( 2564 struct sockaddr_storage *srcadr, 2565 struct interface *inter, 2566 struct req_pkt *inpkt 2567 ) 2568 { 2569 register struct info_kernel *ik; 2570 struct timex ntx; 2571 2572 if (!pll_control) { 2573 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 2574 return; 2575 } 2576 2577 memset((char *)&ntx, 0, sizeof(ntx)); 2578 if (ntp_adjtime(&ntx) < 0) 2579 msyslog(LOG_ERR, "get_kernel_info: ntp_adjtime() failed: %m"); 2580 ik = (struct info_kernel *)prepare_pkt(srcadr, inter, inpkt, 2581 sizeof(struct info_kernel)); 2582 2583 /* 2584 * pll variables 2585 */ 2586 ik->offset = htonl((u_int32)ntx.offset); 2587 ik->freq = htonl((u_int32)ntx.freq); 2588 ik->maxerror = htonl((u_int32)ntx.maxerror); 2589 ik->esterror = htonl((u_int32)ntx.esterror); 2590 ik->status = htons(ntx.status); 2591 ik->constant = htonl((u_int32)ntx.constant); 2592 ik->precision = htonl((u_int32)ntx.precision); 2593 ik->tolerance = htonl((u_int32)ntx.tolerance); 2594 2595 /* 2596 * pps variables 2597 */ 2598 ik->ppsfreq = htonl((u_int32)ntx.ppsfreq); 2599 ik->jitter = htonl((u_int32)ntx.jitter); 2600 ik->shift = htons(ntx.shift); 2601 ik->stabil = htonl((u_int32)ntx.stabil); 2602 ik->jitcnt = htonl((u_int32)ntx.jitcnt); 2603 ik->calcnt = htonl((u_int32)ntx.calcnt); 2604 ik->errcnt = htonl((u_int32)ntx.errcnt); 2605 ik->stbcnt = htonl((u_int32)ntx.stbcnt); 2606 2607 (void) more_pkt(); 2608 flush_pkt(); 2609 } 2610 #endif /* KERNEL_PLL */ 2611 2612 2613 #ifdef REFCLOCK 2614 /* 2615 * get_clock_info - get info about a clock 2616 */ 2617 static void 2618 get_clock_info( 2619 struct sockaddr_storage *srcadr, 2620 struct interface *inter, 2621 struct req_pkt *inpkt 2622 ) 2623 { 2624 register struct info_clock *ic; 2625 register u_int32 *clkaddr; 2626 register int items; 2627 struct refclockstat clock_stat; 2628 struct sockaddr_storage addr; 2629 struct sockaddr_in tmp_clock; 2630 l_fp ltmp; 2631 2632 memset((char *)&addr, 0, sizeof addr); 2633 addr.ss_family = AF_INET; 2634 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR 2635 addr.ss_len = SOCKLEN(&addr); 2636 #endif 2637 NSRCPORT(&addr) = htons(NTP_PORT); 2638 items = INFO_NITEMS(inpkt->err_nitems); 2639 clkaddr = (u_int32 *) inpkt->data; 2640 2641 ic = (struct info_clock *)prepare_pkt(srcadr, inter, inpkt, 2642 sizeof(struct info_clock)); 2643 2644 while (items-- > 0) { 2645 tmp_clock.sin_addr.s_addr = *clkaddr++; 2646 CAST_V4(addr)->sin_addr = tmp_clock.sin_addr; 2647 if (!ISREFCLOCKADR(&tmp_clock) || 2648 findexistingpeer(&addr, (struct peer *)0, -1) == 0) { 2649 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 2650 return; 2651 } 2652 2653 clock_stat.kv_list = (struct ctl_var *)0; 2654 2655 refclock_control(&addr, (struct refclockstat *)0, &clock_stat); 2656 2657 ic->clockadr = tmp_clock.sin_addr.s_addr; 2658 ic->type = clock_stat.type; 2659 ic->flags = clock_stat.flags; 2660 ic->lastevent = clock_stat.lastevent; 2661 ic->currentstatus = clock_stat.currentstatus; 2662 ic->polls = htonl((u_int32)clock_stat.polls); 2663 ic->noresponse = htonl((u_int32)clock_stat.noresponse); 2664 ic->badformat = htonl((u_int32)clock_stat.badformat); 2665 ic->baddata = htonl((u_int32)clock_stat.baddata); 2666 ic->timestarted = htonl((u_int32)clock_stat.timereset); 2667 DTOLFP(clock_stat.fudgetime1, <mp); 2668 HTONL_FP(<mp, &ic->fudgetime1); 2669 DTOLFP(clock_stat.fudgetime2, <mp); 2670 HTONL_FP(<mp, &ic->fudgetime2); 2671 ic->fudgeval1 = htonl((u_int32)clock_stat.fudgeval1); 2672 ic->fudgeval2 = htonl((u_int32)clock_stat.fudgeval2); 2673 2674 free_varlist(clock_stat.kv_list); 2675 2676 ic = (struct info_clock *)more_pkt(); 2677 } 2678 flush_pkt(); 2679 } 2680 2681 2682 2683 /* 2684 * set_clock_fudge - get a clock's fudge factors 2685 */ 2686 static void 2687 set_clock_fudge( 2688 struct sockaddr_storage *srcadr, 2689 struct interface *inter, 2690 struct req_pkt *inpkt 2691 ) 2692 { 2693 register struct conf_fudge *cf; 2694 register int items; 2695 struct refclockstat clock_stat; 2696 struct sockaddr_storage addr; 2697 struct sockaddr_in tmp_clock; 2698 l_fp ltmp; 2699 2700 memset((char *)&addr, 0, sizeof addr); 2701 memset((char *)&clock_stat, 0, sizeof clock_stat); 2702 items = INFO_NITEMS(inpkt->err_nitems); 2703 cf = (struct conf_fudge *) inpkt->data; 2704 2705 while (items-- > 0) { 2706 tmp_clock.sin_addr.s_addr = cf->clockadr; 2707 *CAST_V4(addr) = tmp_clock; 2708 addr.ss_family = AF_INET; 2709 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR 2710 addr.ss_len = SOCKLEN(&addr); 2711 #endif 2712 NSRCPORT(&addr) = htons(NTP_PORT); 2713 if (!ISREFCLOCKADR(&tmp_clock) || 2714 findexistingpeer(&addr, (struct peer *)0, -1) == 0) { 2715 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 2716 return; 2717 } 2718 2719 switch(ntohl(cf->which)) { 2720 case FUDGE_TIME1: 2721 NTOHL_FP(&cf->fudgetime, <mp); 2722 LFPTOD(<mp, clock_stat.fudgetime1); 2723 clock_stat.haveflags = CLK_HAVETIME1; 2724 break; 2725 case FUDGE_TIME2: 2726 NTOHL_FP(&cf->fudgetime, <mp); 2727 LFPTOD(<mp, clock_stat.fudgetime2); 2728 clock_stat.haveflags = CLK_HAVETIME2; 2729 break; 2730 case FUDGE_VAL1: 2731 clock_stat.fudgeval1 = ntohl(cf->fudgeval_flags); 2732 clock_stat.haveflags = CLK_HAVEVAL1; 2733 break; 2734 case FUDGE_VAL2: 2735 clock_stat.fudgeval2 = ntohl(cf->fudgeval_flags); 2736 clock_stat.haveflags = CLK_HAVEVAL2; 2737 break; 2738 case FUDGE_FLAGS: 2739 clock_stat.flags = (u_char) (ntohl(cf->fudgeval_flags) & 0xf); 2740 clock_stat.haveflags = 2741 (CLK_HAVEFLAG1|CLK_HAVEFLAG2|CLK_HAVEFLAG3|CLK_HAVEFLAG4); 2742 break; 2743 default: 2744 msyslog(LOG_ERR, "set_clock_fudge: default!"); 2745 req_ack(srcadr, inter, inpkt, INFO_ERR_FMT); 2746 return; 2747 } 2748 2749 refclock_control(&addr, &clock_stat, (struct refclockstat *)0); 2750 } 2751 2752 req_ack(srcadr, inter, inpkt, INFO_OKAY); 2753 } 2754 #endif 2755 2756 #ifdef REFCLOCK 2757 /* 2758 * get_clkbug_info - get debugging info about a clock 2759 */ 2760 static void 2761 get_clkbug_info( 2762 struct sockaddr_storage *srcadr, 2763 struct interface *inter, 2764 struct req_pkt *inpkt 2765 ) 2766 { 2767 register int i; 2768 register struct info_clkbug *ic; 2769 register u_int32 *clkaddr; 2770 register int items; 2771 struct refclockbug bug; 2772 struct sockaddr_storage addr; 2773 struct sockaddr_in tmp_clock; 2774 2775 memset((char *)&addr, 0, sizeof addr); 2776 addr.ss_family = AF_INET; 2777 #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR 2778 addr.ss_len = SOCKLEN(&addr); 2779 #endif 2780 NSRCPORT(&addr) = htons(NTP_PORT); 2781 items = INFO_NITEMS(inpkt->err_nitems); 2782 clkaddr = (u_int32 *) inpkt->data; 2783 2784 ic = (struct info_clkbug *)prepare_pkt(srcadr, inter, inpkt, 2785 sizeof(struct info_clkbug)); 2786 2787 while (items-- > 0) { 2788 tmp_clock.sin_addr.s_addr = *clkaddr++; 2789 GET_INADDR(addr) = tmp_clock.sin_addr.s_addr; 2790 if (!ISREFCLOCKADR(&tmp_clock) || 2791 findexistingpeer(&addr, (struct peer *)0, -1) == 0) { 2792 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 2793 return; 2794 } 2795 2796 memset((char *)&bug, 0, sizeof bug); 2797 refclock_buginfo(&addr, &bug); 2798 if (bug.nvalues == 0 && bug.ntimes == 0) { 2799 req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA); 2800 return; 2801 } 2802 2803 ic->clockadr = tmp_clock.sin_addr.s_addr; 2804 i = bug.nvalues; 2805 if (i > NUMCBUGVALUES) 2806 i = NUMCBUGVALUES; 2807 ic->nvalues = (u_char)i; 2808 ic->svalues = htons((u_short) (bug.svalues & ((1<<i)-1))); 2809 while (--i >= 0) 2810 ic->values[i] = htonl(bug.values[i]); 2811 2812 i = bug.ntimes; 2813 if (i > NUMCBUGTIMES) 2814 i = NUMCBUGTIMES; 2815 ic->ntimes = (u_char)i; 2816 ic->stimes = htonl(bug.stimes); 2817 while (--i >= 0) { 2818 HTONL_FP(&bug.times[i], &ic->times[i]); 2819 } 2820 2821 ic = (struct info_clkbug *)more_pkt(); 2822 } 2823 flush_pkt(); 2824 } 2825 #endif 2826 2827 /* 2828 * receiver of interface structures 2829 */ 2830 static void 2831 fill_info_if_stats(void *data, interface_info_t *interface_info) 2832 { 2833 struct info_if_stats **ifsp = (struct info_if_stats **)data; 2834 struct info_if_stats *ifs = *ifsp; 2835 struct interface *interface = interface_info->interface; 2836 2837 memset((char*)ifs, 0, sizeof(*ifs)); 2838 2839 if (interface->sin.ss_family == AF_INET6) { 2840 if (!client_v6_capable) { 2841 return; 2842 } 2843 ifs->v6_flag = 1; 2844 memcpy((char *)&ifs->unaddr.addr6, (char *)&CAST_V6(interface->sin)->sin6_addr, sizeof(struct in6_addr)); 2845 memcpy((char *)&ifs->unbcast.addr6, (char *)&CAST_V6(interface->bcast)->sin6_addr, sizeof(struct in6_addr)); 2846 memcpy((char *)&ifs->unmask.addr6, (char *)&CAST_V6(interface->mask)->sin6_addr, sizeof(struct in6_addr)); 2847 } else { 2848 ifs->v6_flag = 0; 2849 memcpy((char *)&ifs->unaddr.addr, (char *)&CAST_V4(interface->sin)->sin_addr, sizeof(struct in_addr)); 2850 memcpy((char *)&ifs->unbcast.addr, (char *)&CAST_V4(interface->bcast)->sin_addr, sizeof(struct in_addr)); 2851 memcpy((char *)&ifs->unmask.addr, (char *)&CAST_V4(interface->mask)->sin_addr, sizeof(struct in_addr)); 2852 } 2853 ifs->v6_flag = htonl(ifs->v6_flag); 2854 strcpy(ifs->name, interface->name); 2855 ifs->family = htons(interface->family); 2856 ifs->flags = htonl(interface->flags); 2857 ifs->last_ttl = htonl(interface->last_ttl); 2858 ifs->num_mcast = htonl(interface->num_mcast); 2859 ifs->received = htonl(interface->received); 2860 ifs->sent = htonl(interface->sent); 2861 ifs->notsent = htonl(interface->notsent); 2862 ifs->scopeid = htonl(interface->scopeid); 2863 ifs->ifindex = htonl(interface->ifindex); 2864 ifs->ifnum = htonl(interface->ifnum); 2865 ifs->uptime = htonl(current_time - interface->starttime); 2866 ifs->ignore_packets = interface->ignore_packets; 2867 ifs->peercnt = htonl(interface->peercnt); 2868 ifs->action = interface_info->action; 2869 2870 *ifsp = (struct info_if_stats *)more_pkt(); 2871 } 2872 2873 /* 2874 * get_if_stats - get interface statistics 2875 */ 2876 static void 2877 get_if_stats( 2878 struct sockaddr_storage *srcadr, 2879 struct interface *inter, 2880 struct req_pkt *inpkt 2881 ) 2882 { 2883 struct info_if_stats *ifs; 2884 2885 DPRINTF(3, ("wants interface statistics\n")); 2886 2887 ifs = (struct info_if_stats *)prepare_pkt(srcadr, inter, inpkt, 2888 v6sizeof(struct info_if_stats)); 2889 2890 interface_enumerate(fill_info_if_stats, &ifs); 2891 2892 flush_pkt(); 2893 } 2894 2895 static void 2896 do_if_reload( 2897 struct sockaddr_storage *srcadr, 2898 struct interface *inter, 2899 struct req_pkt *inpkt 2900 ) 2901 { 2902 struct info_if_stats *ifs; 2903 2904 DPRINTF(3, ("wants interface reload\n")); 2905 2906 ifs = (struct info_if_stats *)prepare_pkt(srcadr, inter, inpkt, 2907 v6sizeof(struct info_if_stats)); 2908 2909 interface_update(fill_info_if_stats, &ifs); 2910 2911 flush_pkt(); 2912 } 2913 2914