PageRenderTime 31ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 1ms

/contrib/ntp/ntpd/ntp_request.c

https://bitbucket.org/freebsd/freebsd-head/
C | 2913 lines | 2219 code | 305 blank | 389 comment | 397 complexity | 9858527709641a8baeefc751e99f2ed7 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, BSD-3-Clause, LGPL-2.0, LGPL-2.1, BSD-2-Clause, 0BSD, JSON, AGPL-1.0, GPL-2.0
  1. /*
  2. * ntp_request.c - respond to information requests
  3. */
  4. #ifdef HAVE_CONFIG_H
  5. # include <config.h>
  6. #endif
  7. #include "ntpd.h"
  8. #include "ntp_io.h"
  9. #include "ntp_request.h"
  10. #include "ntp_control.h"
  11. #include "ntp_refclock.h"
  12. #include "ntp_if.h"
  13. #include "ntp_stdlib.h"
  14. #include <stdio.h>
  15. #include <stddef.h>
  16. #include <signal.h>
  17. #include <netinet/in.h>
  18. #include <arpa/inet.h>
  19. #include "recvbuff.h"
  20. #ifdef KERNEL_PLL
  21. #include "ntp_syscall.h"
  22. #endif /* KERNEL_PLL */
  23. /*
  24. * Structure to hold request procedure information
  25. */
  26. #define NOAUTH 0
  27. #define AUTH 1
  28. #define NO_REQUEST (-1)
  29. /*
  30. * Because we now have v6 addresses in the messages, we need to compensate
  31. * for the larger size. Therefore, we introduce the alternate size to
  32. * keep us friendly with older implementations. A little ugly.
  33. */
  34. static int client_v6_capable = 0; /* the client can handle longer messages */
  35. #define v6sizeof(type) (client_v6_capable ? sizeof(type) : v4sizeof(type))
  36. struct req_proc {
  37. short request_code; /* defined request code */
  38. short needs_auth; /* true when authentication needed */
  39. short sizeofitem; /* size of request data item (older size)*/
  40. short v6_sizeofitem; /* size of request data item (new size)*/
  41. void (*handler) P((struct sockaddr_storage *, struct interface *,
  42. struct req_pkt *)); /* routine to handle request */
  43. };
  44. /*
  45. * Universal request codes
  46. */
  47. static struct req_proc univ_codes[] = {
  48. { NO_REQUEST, NOAUTH, 0, 0 }
  49. };
  50. static void req_ack P((struct sockaddr_storage *, struct interface *, struct req_pkt *, int));
  51. static char * prepare_pkt P((struct sockaddr_storage *, struct interface *, struct req_pkt *, u_int));
  52. static char * more_pkt P((void));
  53. static void flush_pkt P((void));
  54. static void peer_list P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  55. static void peer_list_sum P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  56. static void peer_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  57. static void peer_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  58. static void sys_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  59. static void sys_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  60. static void mem_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  61. static void io_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  62. static void timer_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  63. static void loop_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  64. static void do_conf P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  65. static void do_unconf P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  66. static void set_sys_flag P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  67. static void clr_sys_flag P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  68. static void setclr_flags P((struct sockaddr_storage *, struct interface *, struct req_pkt *, u_long));
  69. static void list_restrict P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  70. static void do_resaddflags P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  71. static void do_ressubflags P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  72. static void do_unrestrict P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  73. static void do_restrict P((struct sockaddr_storage *, struct interface *, struct req_pkt *, int));
  74. static void mon_getlist_0 P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  75. static void mon_getlist_1 P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  76. static void reset_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  77. static void reset_peer P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  78. static void do_key_reread P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  79. static void trust_key P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  80. static void untrust_key P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  81. static void do_trustkey P((struct sockaddr_storage *, struct interface *, struct req_pkt *, u_long));
  82. static void get_auth_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  83. static void reset_auth_stats P((void));
  84. static void req_get_traps P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  85. static void req_set_trap P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  86. static void req_clr_trap P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  87. static void do_setclr_trap P((struct sockaddr_storage *, struct interface *, struct req_pkt *, int));
  88. static void set_request_keyid P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  89. static void set_control_keyid P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  90. static void get_ctl_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  91. static void get_if_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  92. static void do_if_reload P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  93. #ifdef KERNEL_PLL
  94. static void get_kernel_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  95. #endif /* KERNEL_PLL */
  96. #ifdef REFCLOCK
  97. static void get_clock_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  98. static void set_clock_fudge P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  99. #endif /* REFCLOCK */
  100. #ifdef REFCLOCK
  101. static void get_clkbug_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
  102. #endif /* REFCLOCK */
  103. /*
  104. * ntpd request codes
  105. */
  106. static struct req_proc ntp_codes[] = {
  107. { REQ_PEER_LIST, NOAUTH, 0, 0, peer_list },
  108. { REQ_PEER_LIST_SUM, NOAUTH, 0, 0, peer_list_sum },
  109. { REQ_PEER_INFO, NOAUTH, v4sizeof(struct info_peer_list),
  110. sizeof(struct info_peer_list), peer_info},
  111. { REQ_PEER_STATS, NOAUTH, v4sizeof(struct info_peer_list),
  112. sizeof(struct info_peer_list), peer_stats},
  113. { REQ_SYS_INFO, NOAUTH, 0, 0, sys_info },
  114. { REQ_SYS_STATS, NOAUTH, 0, 0, sys_stats },
  115. { REQ_IO_STATS, NOAUTH, 0, 0, io_stats },
  116. { REQ_MEM_STATS, NOAUTH, 0, 0, mem_stats },
  117. { REQ_LOOP_INFO, NOAUTH, 0, 0, loop_info },
  118. { REQ_TIMER_STATS, NOAUTH, 0, 0, timer_stats },
  119. { REQ_CONFIG, AUTH, v4sizeof(struct conf_peer),
  120. sizeof(struct conf_peer), do_conf },
  121. { REQ_UNCONFIG, AUTH, v4sizeof(struct conf_unpeer),
  122. sizeof(struct conf_unpeer), do_unconf },
  123. { REQ_SET_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags),
  124. sizeof(struct conf_sys_flags), set_sys_flag },
  125. { REQ_CLR_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags),
  126. sizeof(struct conf_sys_flags), clr_sys_flag },
  127. { REQ_GET_RESTRICT, NOAUTH, 0, 0, list_restrict },
  128. { REQ_RESADDFLAGS, AUTH, v4sizeof(struct conf_restrict),
  129. sizeof(struct conf_restrict), do_resaddflags },
  130. { REQ_RESSUBFLAGS, AUTH, v4sizeof(struct conf_restrict),
  131. sizeof(struct conf_restrict), do_ressubflags },
  132. { REQ_UNRESTRICT, AUTH, v4sizeof(struct conf_restrict),
  133. sizeof(struct conf_restrict), do_unrestrict },
  134. { REQ_MON_GETLIST, NOAUTH, 0, 0, mon_getlist_0 },
  135. { REQ_MON_GETLIST_1, NOAUTH, 0, 0, mon_getlist_1 },
  136. { REQ_RESET_STATS, AUTH, sizeof(struct reset_flags), 0, reset_stats },
  137. { REQ_RESET_PEER, AUTH, v4sizeof(struct conf_unpeer),
  138. sizeof(struct conf_unpeer), reset_peer },
  139. { REQ_REREAD_KEYS, AUTH, 0, 0, do_key_reread },
  140. { REQ_TRUSTKEY, AUTH, sizeof(u_long), sizeof(u_long), trust_key },
  141. { REQ_UNTRUSTKEY, AUTH, sizeof(u_long), sizeof(u_long), untrust_key },
  142. { REQ_AUTHINFO, NOAUTH, 0, 0, get_auth_info },
  143. { REQ_TRAPS, NOAUTH, 0, 0, req_get_traps },
  144. { REQ_ADD_TRAP, AUTH, v4sizeof(struct conf_trap),
  145. sizeof(struct conf_trap), req_set_trap },
  146. { REQ_CLR_TRAP, AUTH, v4sizeof(struct conf_trap),
  147. sizeof(struct conf_trap), req_clr_trap },
  148. { REQ_REQUEST_KEY, AUTH, sizeof(u_long), sizeof(u_long),
  149. set_request_keyid },
  150. { REQ_CONTROL_KEY, AUTH, sizeof(u_long), sizeof(u_long),
  151. set_control_keyid },
  152. { REQ_GET_CTLSTATS, NOAUTH, 0, 0, get_ctl_stats },
  153. #ifdef KERNEL_PLL
  154. { REQ_GET_KERNEL, NOAUTH, 0, 0, get_kernel_info },
  155. #endif
  156. #ifdef REFCLOCK
  157. { REQ_GET_CLOCKINFO, NOAUTH, sizeof(u_int32), sizeof(u_int32),
  158. get_clock_info },
  159. { REQ_SET_CLKFUDGE, AUTH, sizeof(struct conf_fudge),
  160. sizeof(struct conf_fudge), set_clock_fudge },
  161. { REQ_GET_CLKBUGINFO, NOAUTH, sizeof(u_int32), sizeof(u_int32),
  162. get_clkbug_info },
  163. #endif
  164. { REQ_IF_STATS, AUTH, 0, 0, get_if_stats },
  165. { REQ_IF_RELOAD, AUTH, 0, 0, do_if_reload },
  166. { NO_REQUEST, NOAUTH, 0, 0, 0 }
  167. };
  168. /*
  169. * Authentication keyid used to authenticate requests. Zero means we
  170. * don't allow writing anything.
  171. */
  172. keyid_t info_auth_keyid;
  173. /*
  174. * Statistic counters to keep track of requests and responses.
  175. */
  176. u_long numrequests; /* number of requests we've received */
  177. u_long numresppkts; /* number of resp packets sent with data */
  178. u_long errorcounter[INFO_ERR_AUTH+1]; /* lazy way to count errors, indexed */
  179. /* by the error code */
  180. /*
  181. * A hack. To keep the authentication module clear of ntp-ism's, we
  182. * include a time reset variable for its stats here.
  183. */
  184. static u_long auth_timereset;
  185. /*
  186. * Response packet used by these routines. Also some state information
  187. * so that we can handle packet formatting within a common set of
  188. * subroutines. Note we try to enter data in place whenever possible,
  189. * but the need to set the more bit correctly means we occasionally
  190. * use the extra buffer and copy.
  191. */
  192. static struct resp_pkt rpkt;
  193. static int reqver;
  194. static int seqno;
  195. static int nitems;
  196. static int itemsize;
  197. static int databytes;
  198. static char exbuf[RESP_DATA_SIZE];
  199. static int usingexbuf;
  200. static struct sockaddr_storage *toaddr;
  201. static struct interface *frominter;
  202. /*
  203. * init_request - initialize request data
  204. */
  205. void
  206. init_request (void)
  207. {
  208. int i;
  209. numrequests = 0;
  210. numresppkts = 0;
  211. auth_timereset = 0;
  212. info_auth_keyid = 0; /* by default, can't do this */
  213. for (i = 0; i < sizeof(errorcounter)/sizeof(errorcounter[0]); i++)
  214. errorcounter[i] = 0;
  215. }
  216. /*
  217. * req_ack - acknowledge request with no data
  218. */
  219. static void
  220. req_ack(
  221. struct sockaddr_storage *srcadr,
  222. struct interface *inter,
  223. struct req_pkt *inpkt,
  224. int errcode
  225. )
  226. {
  227. /*
  228. * fill in the fields
  229. */
  230. rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, 0, reqver);
  231. rpkt.auth_seq = AUTH_SEQ(0, 0);
  232. rpkt.implementation = inpkt->implementation;
  233. rpkt.request = inpkt->request;
  234. rpkt.err_nitems = ERR_NITEMS(errcode, 0);
  235. rpkt.mbz_itemsize = MBZ_ITEMSIZE(0);
  236. /*
  237. * send packet and bump counters
  238. */
  239. sendpkt(srcadr, inter, -1, (struct pkt *)&rpkt, RESP_HEADER_SIZE);
  240. errorcounter[errcode]++;
  241. }
  242. /*
  243. * prepare_pkt - prepare response packet for transmission, return pointer
  244. * to storage for data item.
  245. */
  246. static char *
  247. prepare_pkt(
  248. struct sockaddr_storage *srcadr,
  249. struct interface *inter,
  250. struct req_pkt *pkt,
  251. u_int structsize
  252. )
  253. {
  254. #ifdef DEBUG
  255. if (debug > 3)
  256. printf("request: preparing pkt\n");
  257. #endif
  258. /*
  259. * Fill in the implementation, request and itemsize fields
  260. * since these won't change.
  261. */
  262. rpkt.implementation = pkt->implementation;
  263. rpkt.request = pkt->request;
  264. rpkt.mbz_itemsize = MBZ_ITEMSIZE(structsize);
  265. /*
  266. * Compute the static data needed to carry on.
  267. */
  268. toaddr = srcadr;
  269. frominter = inter;
  270. seqno = 0;
  271. nitems = 0;
  272. itemsize = structsize;
  273. databytes = 0;
  274. usingexbuf = 0;
  275. /*
  276. * return the beginning of the packet buffer.
  277. */
  278. return &rpkt.data[0];
  279. }
  280. /*
  281. * more_pkt - return a data pointer for a new item.
  282. */
  283. static char *
  284. more_pkt(void)
  285. {
  286. /*
  287. * If we were using the extra buffer, send the packet.
  288. */
  289. if (usingexbuf) {
  290. #ifdef DEBUG
  291. if (debug > 2)
  292. printf("request: sending pkt\n");
  293. #endif
  294. rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, MORE_BIT, reqver);
  295. rpkt.auth_seq = AUTH_SEQ(0, seqno);
  296. rpkt.err_nitems = htons((u_short)nitems);
  297. sendpkt(toaddr, frominter, -1, (struct pkt *)&rpkt,
  298. RESP_HEADER_SIZE+databytes);
  299. numresppkts++;
  300. /*
  301. * Copy data out of exbuf into the packet.
  302. */
  303. memmove(&rpkt.data[0], exbuf, (unsigned)itemsize);
  304. seqno++;
  305. databytes = 0;
  306. nitems = 0;
  307. usingexbuf = 0;
  308. }
  309. databytes += itemsize;
  310. nitems++;
  311. if (databytes + itemsize <= RESP_DATA_SIZE) {
  312. #ifdef DEBUG
  313. if (debug > 3)
  314. printf("request: giving him more data\n");
  315. #endif
  316. /*
  317. * More room in packet. Give him the
  318. * next address.
  319. */
  320. return &rpkt.data[databytes];
  321. } else {
  322. /*
  323. * No room in packet. Give him the extra
  324. * buffer unless this was the last in the sequence.
  325. */
  326. #ifdef DEBUG
  327. if (debug > 3)
  328. printf("request: into extra buffer\n");
  329. #endif
  330. if (seqno == MAXSEQ)
  331. return (char *)0;
  332. else {
  333. usingexbuf = 1;
  334. return exbuf;
  335. }
  336. }
  337. }
  338. /*
  339. * flush_pkt - we're done, return remaining information.
  340. */
  341. static void
  342. flush_pkt(void)
  343. {
  344. #ifdef DEBUG
  345. if (debug > 2)
  346. printf("request: flushing packet, %d items\n", nitems);
  347. #endif
  348. /*
  349. * Must send the last packet. If nothing in here and nothing
  350. * has been sent, send an error saying no data to be found.
  351. */
  352. if (seqno == 0 && nitems == 0)
  353. req_ack(toaddr, frominter, (struct req_pkt *)&rpkt,
  354. INFO_ERR_NODATA);
  355. else {
  356. rpkt.rm_vn_mode = RM_VN_MODE(RESP_BIT, 0, reqver);
  357. rpkt.auth_seq = AUTH_SEQ(0, seqno);
  358. rpkt.err_nitems = htons((u_short)nitems);
  359. sendpkt(toaddr, frominter, -1, (struct pkt *)&rpkt,
  360. RESP_HEADER_SIZE+databytes);
  361. numresppkts++;
  362. }
  363. }
  364. /*
  365. * process_private - process private mode (7) packets
  366. */
  367. void
  368. process_private(
  369. struct recvbuf *rbufp,
  370. int mod_okay
  371. )
  372. {
  373. static u_long quiet_until;
  374. struct req_pkt *inpkt;
  375. struct req_pkt_tail *tailinpkt;
  376. struct sockaddr_storage *srcadr;
  377. struct interface *inter;
  378. struct req_proc *proc;
  379. int ec;
  380. short temp_size;
  381. /*
  382. * Initialize pointers, for convenience
  383. */
  384. inpkt = (struct req_pkt *)&rbufp->recv_pkt;
  385. srcadr = &rbufp->recv_srcadr;
  386. inter = rbufp->dstadr;
  387. #ifdef DEBUG
  388. if (debug > 2)
  389. printf("process_private: impl %d req %d\n",
  390. inpkt->implementation, inpkt->request);
  391. #endif
  392. /*
  393. * Do some sanity checks on the packet. Return a format
  394. * error if it fails.
  395. */
  396. ec = 0;
  397. if ( (++ec, ISRESPONSE(inpkt->rm_vn_mode))
  398. || (++ec, ISMORE(inpkt->rm_vn_mode))
  399. || (++ec, INFO_VERSION(inpkt->rm_vn_mode) > NTP_VERSION)
  400. || (++ec, INFO_VERSION(inpkt->rm_vn_mode) < NTP_OLDVERSION)
  401. || (++ec, INFO_SEQ(inpkt->auth_seq) != 0)
  402. || (++ec, INFO_ERR(inpkt->err_nitems) != 0)
  403. || (++ec, INFO_MBZ(inpkt->mbz_itemsize) != 0)
  404. || (++ec, rbufp->recv_length < REQ_LEN_HDR)
  405. ) {
  406. NLOG(NLOG_SYSEVENT)
  407. if (current_time >= quiet_until) {
  408. msyslog(LOG_ERR,
  409. "process_private: drop test %d"
  410. " failed, pkt from %s",
  411. ec, stoa(srcadr));
  412. quiet_until = current_time + 60;
  413. }
  414. return;
  415. }
  416. reqver = INFO_VERSION(inpkt->rm_vn_mode);
  417. /*
  418. * Get the appropriate procedure list to search.
  419. */
  420. if (inpkt->implementation == IMPL_UNIV)
  421. proc = univ_codes;
  422. else if ((inpkt->implementation == IMPL_XNTPD) ||
  423. (inpkt->implementation == IMPL_XNTPD_OLD))
  424. proc = ntp_codes;
  425. else {
  426. req_ack(srcadr, inter, inpkt, INFO_ERR_IMPL);
  427. return;
  428. }
  429. /*
  430. * Search the list for the request codes. If it isn't one
  431. * we know, return an error.
  432. */
  433. while (proc->request_code != NO_REQUEST) {
  434. if (proc->request_code == (short) inpkt->request)
  435. break;
  436. proc++;
  437. }
  438. if (proc->request_code == NO_REQUEST) {
  439. req_ack(srcadr, inter, inpkt, INFO_ERR_REQ);
  440. return;
  441. }
  442. #ifdef DEBUG
  443. if (debug > 3)
  444. printf("found request in tables\n");
  445. #endif
  446. /*
  447. * If we need data, check to see if we have some. If we
  448. * don't, check to see that there is none (picky, picky).
  449. */
  450. /* This part is a bit tricky, we want to be sure that the size
  451. * returned is either the old or the new size. We also can find
  452. * out if the client can accept both types of messages this way.
  453. *
  454. * Handle the exception of REQ_CONFIG. It can have two data sizes.
  455. */
  456. temp_size = INFO_ITEMSIZE(inpkt->mbz_itemsize);
  457. if ((temp_size != proc->sizeofitem &&
  458. temp_size != proc->v6_sizeofitem) &&
  459. !(inpkt->implementation == IMPL_XNTPD &&
  460. inpkt->request == REQ_CONFIG &&
  461. temp_size == sizeof(struct old_conf_peer))) {
  462. #ifdef DEBUG
  463. if (debug > 2)
  464. printf("process_private: wrong item size, received %d, should be %d or %d\n",
  465. temp_size, proc->sizeofitem, proc->v6_sizeofitem);
  466. #endif
  467. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  468. return;
  469. }
  470. if ((proc->sizeofitem != 0) &&
  471. ((temp_size * INFO_NITEMS(inpkt->err_nitems)) >
  472. (rbufp->recv_length - REQ_LEN_HDR))) {
  473. #ifdef DEBUG
  474. if (debug > 2)
  475. printf("process_private: not enough data\n");
  476. #endif
  477. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  478. return;
  479. }
  480. switch (inpkt->implementation) {
  481. case IMPL_XNTPD:
  482. client_v6_capable = 1;
  483. break;
  484. case IMPL_XNTPD_OLD:
  485. client_v6_capable = 0;
  486. break;
  487. default:
  488. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  489. return;
  490. }
  491. /*
  492. * If we need to authenticate, do so. Note that an
  493. * authenticatable packet must include a mac field, must
  494. * have used key info_auth_keyid and must have included
  495. * a time stamp in the appropriate field. The time stamp
  496. * must be within INFO_TS_MAXSKEW of the receive
  497. * time stamp.
  498. */
  499. if (proc->needs_auth && sys_authenticate) {
  500. l_fp ftmp;
  501. double dtemp;
  502. if (rbufp->recv_length < (int)((REQ_LEN_HDR +
  503. (INFO_ITEMSIZE(inpkt->mbz_itemsize) *
  504. INFO_NITEMS(inpkt->err_nitems))
  505. + sizeof(struct req_pkt_tail)))) {
  506. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  507. }
  508. tailinpkt = (struct req_pkt_tail *)((char *)&rbufp->recv_pkt +
  509. rbufp->recv_length - sizeof(struct req_pkt_tail));
  510. /*
  511. * If this guy is restricted from doing this, don't let him
  512. * If wrong key was used, or packet doesn't have mac, return.
  513. */
  514. if (!INFO_IS_AUTH(inpkt->auth_seq) || info_auth_keyid == 0
  515. || ntohl(tailinpkt->keyid) != info_auth_keyid) {
  516. #ifdef DEBUG
  517. if (debug > 4)
  518. printf("failed auth %d info_auth_keyid %lu pkt keyid %lu\n",
  519. INFO_IS_AUTH(inpkt->auth_seq),
  520. (u_long)info_auth_keyid,
  521. (u_long)ntohl(tailinpkt->keyid));
  522. msyslog(LOG_DEBUG,
  523. "process_private: failed auth %d info_auth_keyid %lu pkt keyid %lu\n",
  524. INFO_IS_AUTH(inpkt->auth_seq),
  525. (u_long)info_auth_keyid,
  526. (u_long)ntohl(tailinpkt->keyid));
  527. #endif
  528. req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
  529. return;
  530. }
  531. if (rbufp->recv_length > REQ_LEN_MAC) {
  532. #ifdef DEBUG
  533. if (debug > 4)
  534. printf("bad pkt length %d\n",
  535. rbufp->recv_length);
  536. #endif
  537. msyslog(LOG_ERR, "process_private: bad pkt length %d",
  538. rbufp->recv_length);
  539. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  540. return;
  541. }
  542. if (!mod_okay || !authhavekey(info_auth_keyid)) {
  543. #ifdef DEBUG
  544. if (debug > 4)
  545. printf("failed auth mod_okay %d\n", mod_okay);
  546. msyslog(LOG_DEBUG,
  547. "process_private: failed auth mod_okay %d\n",
  548. mod_okay);
  549. #endif
  550. req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
  551. return;
  552. }
  553. /*
  554. * calculate absolute time difference between xmit time stamp
  555. * and receive time stamp. If too large, too bad.
  556. */
  557. NTOHL_FP(&tailinpkt->tstamp, &ftmp);
  558. L_SUB(&ftmp, &rbufp->recv_time);
  559. LFPTOD(&ftmp, dtemp);
  560. if (fabs(dtemp) >= INFO_TS_MAXSKEW) {
  561. /*
  562. * He's a loser. Tell him.
  563. */
  564. #ifdef DEBUG
  565. if (debug > 4)
  566. printf("xmit/rcv timestamp delta > INFO_TS_MAXSKEW\n");
  567. #endif
  568. req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
  569. return;
  570. }
  571. /*
  572. * So far so good. See if decryption works out okay.
  573. */
  574. if (!authdecrypt(info_auth_keyid, (u_int32 *)inpkt,
  575. rbufp->recv_length - sizeof(struct req_pkt_tail) +
  576. REQ_LEN_HDR, sizeof(struct req_pkt_tail) - REQ_LEN_HDR)) {
  577. #ifdef DEBUG
  578. if (debug > 4)
  579. printf("authdecrypt failed\n");
  580. #endif
  581. req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
  582. return;
  583. }
  584. }
  585. #ifdef DEBUG
  586. if (debug > 3)
  587. printf("process_private: all okay, into handler\n");
  588. #endif
  589. /*
  590. * Packet is okay. Call the handler to send him data.
  591. */
  592. (proc->handler)(srcadr, inter, inpkt);
  593. }
  594. /*
  595. * peer_list - send a list of the peers
  596. */
  597. static void
  598. peer_list(
  599. struct sockaddr_storage *srcadr,
  600. struct interface *inter,
  601. struct req_pkt *inpkt
  602. )
  603. {
  604. register struct info_peer_list *ip;
  605. register struct peer *pp;
  606. register int i;
  607. register int skip = 0;
  608. ip = (struct info_peer_list *)prepare_pkt(srcadr, inter, inpkt,
  609. v6sizeof(struct info_peer_list));
  610. for (i = 0; i < NTP_HASH_SIZE && ip != 0; i++) {
  611. pp = peer_hash[i];
  612. while (pp != 0 && ip != 0) {
  613. if (pp->srcadr.ss_family == AF_INET6) {
  614. if (client_v6_capable) {
  615. ip->addr6 = GET_INADDR6(pp->srcadr);
  616. ip->v6_flag = 1;
  617. skip = 0;
  618. } else {
  619. skip = 1;
  620. break;
  621. }
  622. } else {
  623. ip->addr = GET_INADDR(pp->srcadr);
  624. if (client_v6_capable)
  625. ip->v6_flag = 0;
  626. skip = 0;
  627. }
  628. if(!skip) {
  629. ip->port = NSRCPORT(&pp->srcadr);
  630. ip->hmode = pp->hmode;
  631. ip->flags = 0;
  632. if (pp->flags & FLAG_CONFIG)
  633. ip->flags |= INFO_FLAG_CONFIG;
  634. if (pp == sys_peer)
  635. ip->flags |= INFO_FLAG_SYSPEER;
  636. if (pp->status == CTL_PST_SEL_SYNCCAND)
  637. ip->flags |= INFO_FLAG_SEL_CANDIDATE;
  638. if (pp->status >= CTL_PST_SEL_SYSPEER)
  639. ip->flags |= INFO_FLAG_SHORTLIST;
  640. ip = (struct info_peer_list *)more_pkt();
  641. }
  642. pp = pp->next;
  643. }
  644. }
  645. flush_pkt();
  646. }
  647. /*
  648. * peer_list_sum - return extended peer list
  649. */
  650. static void
  651. peer_list_sum(
  652. struct sockaddr_storage *srcadr,
  653. struct interface *inter,
  654. struct req_pkt *inpkt
  655. )
  656. {
  657. register struct info_peer_summary *ips;
  658. register struct peer *pp;
  659. register int i;
  660. l_fp ltmp;
  661. register int skip;
  662. #ifdef DEBUG
  663. if (debug > 2)
  664. printf("wants peer list summary\n");
  665. #endif
  666. ips = (struct info_peer_summary *)prepare_pkt(srcadr, inter, inpkt,
  667. v6sizeof(struct info_peer_summary));
  668. for (i = 0; i < NTP_HASH_SIZE && ips != 0; i++) {
  669. pp = peer_hash[i];
  670. while (pp != 0 && ips != 0) {
  671. #ifdef DEBUG
  672. if (debug > 3)
  673. printf("sum: got one\n");
  674. #endif
  675. /*
  676. * Be careful here not to return v6 peers when we
  677. * want only v4.
  678. */
  679. if (pp->srcadr.ss_family == AF_INET6) {
  680. if (client_v6_capable) {
  681. ips->srcadr6 = GET_INADDR6(pp->srcadr);
  682. ips->v6_flag = 1;
  683. if (pp->dstadr)
  684. ips->dstadr6 = GET_INADDR6(pp->dstadr->sin);
  685. else
  686. memset(&ips->dstadr6, 0, sizeof(ips->dstadr6));
  687. skip = 0;
  688. } else {
  689. skip = 1;
  690. break;
  691. }
  692. } else {
  693. ips->srcadr = GET_INADDR(pp->srcadr);
  694. if (client_v6_capable)
  695. ips->v6_flag = 0;
  696. /* XXX PDM This code is buggy. Need to replace with a straightforward assignment */
  697. if (pp->dstadr)
  698. ips->dstadr = (pp->processed) ?
  699. pp->cast_flags == MDF_BCAST ?
  700. GET_INADDR(pp->dstadr->bcast):
  701. pp->cast_flags ?
  702. GET_INADDR(pp->dstadr->sin) ?
  703. GET_INADDR(pp->dstadr->sin):
  704. GET_INADDR(pp->dstadr->bcast):
  705. 1 : GET_INADDR(pp->dstadr->sin);
  706. else
  707. memset(&ips->dstadr, 0, sizeof(ips->dstadr));
  708. skip = 0;
  709. }
  710. if (!skip){
  711. ips->srcport = NSRCPORT(&pp->srcadr);
  712. ips->stratum = pp->stratum;
  713. ips->hpoll = pp->hpoll;
  714. ips->ppoll = pp->ppoll;
  715. ips->reach = pp->reach;
  716. ips->flags = 0;
  717. if (pp == sys_peer)
  718. ips->flags |= INFO_FLAG_SYSPEER;
  719. if (pp->flags & FLAG_CONFIG)
  720. ips->flags |= INFO_FLAG_CONFIG;
  721. if (pp->flags & FLAG_REFCLOCK)
  722. ips->flags |= INFO_FLAG_REFCLOCK;
  723. if (pp->flags & FLAG_AUTHENABLE)
  724. ips->flags |= INFO_FLAG_AUTHENABLE;
  725. if (pp->flags & FLAG_PREFER)
  726. ips->flags |= INFO_FLAG_PREFER;
  727. if (pp->flags & FLAG_BURST)
  728. ips->flags |= INFO_FLAG_BURST;
  729. if (pp->status == CTL_PST_SEL_SYNCCAND)
  730. ips->flags |= INFO_FLAG_SEL_CANDIDATE;
  731. if (pp->status >= CTL_PST_SEL_SYSPEER)
  732. ips->flags |= INFO_FLAG_SHORTLIST;
  733. ips->hmode = pp->hmode;
  734. ips->delay = HTONS_FP(DTOFP(pp->delay));
  735. DTOLFP(pp->offset, &ltmp);
  736. HTONL_FP(&ltmp, &ips->offset);
  737. ips->dispersion = HTONS_FP(DTOUFP(SQRT(pp->disp)));
  738. }
  739. pp = pp->next;
  740. ips = (struct info_peer_summary *)more_pkt();
  741. }
  742. }
  743. flush_pkt();
  744. }
  745. /*
  746. * peer_info - send information for one or more peers
  747. */
  748. static void
  749. peer_info (
  750. struct sockaddr_storage *srcadr,
  751. struct interface *inter,
  752. struct req_pkt *inpkt
  753. )
  754. {
  755. register struct info_peer_list *ipl;
  756. register struct peer *pp;
  757. register struct info_peer *ip;
  758. register int items;
  759. register int i, j;
  760. struct sockaddr_storage addr;
  761. extern struct peer *sys_peer;
  762. l_fp ltmp;
  763. memset((char *)&addr, 0, sizeof addr);
  764. items = INFO_NITEMS(inpkt->err_nitems);
  765. ipl = (struct info_peer_list *) inpkt->data;
  766. ip = (struct info_peer *)prepare_pkt(srcadr, inter, inpkt,
  767. v6sizeof(struct info_peer));
  768. while (items-- > 0 && ip != 0) {
  769. memset((char *)&addr, 0, sizeof(addr));
  770. NSRCPORT(&addr) = ipl->port;
  771. if (client_v6_capable && ipl->v6_flag != 0) {
  772. addr.ss_family = AF_INET6;
  773. GET_INADDR6(addr) = ipl->addr6;
  774. } else {
  775. addr.ss_family = AF_INET;
  776. GET_INADDR(addr) = ipl->addr;
  777. }
  778. #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
  779. addr.ss_len = SOCKLEN(&addr);
  780. #endif
  781. ipl++;
  782. if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0)
  783. continue;
  784. if (pp->srcadr.ss_family == AF_INET6) {
  785. if (pp->dstadr)
  786. ip->dstadr6 = pp->cast_flags == MDF_BCAST ?
  787. GET_INADDR6(pp->dstadr->bcast) :
  788. GET_INADDR6(pp->dstadr->sin);
  789. else
  790. memset(&ip->dstadr6, 0, sizeof(ip->dstadr6));
  791. ip->srcadr6 = GET_INADDR6(pp->srcadr);
  792. ip->v6_flag = 1;
  793. } else {
  794. /* XXX PDM This code is buggy. Need to replace with a straightforward assignment */
  795. if (pp->dstadr)
  796. ip->dstadr = (pp->processed) ?
  797. pp->cast_flags == MDF_BCAST ?
  798. GET_INADDR(pp->dstadr->bcast):
  799. pp->cast_flags ?
  800. GET_INADDR(pp->dstadr->sin) ?
  801. GET_INADDR(pp->dstadr->sin):
  802. GET_INADDR(pp->dstadr->bcast):
  803. 2 : GET_INADDR(pp->dstadr->sin);
  804. else
  805. memset(&ip->dstadr, 0, sizeof(ip->dstadr));
  806. ip->srcadr = GET_INADDR(pp->srcadr);
  807. if (client_v6_capable)
  808. ip->v6_flag = 0;
  809. }
  810. ip->srcport = NSRCPORT(&pp->srcadr);
  811. ip->flags = 0;
  812. if (pp == sys_peer)
  813. ip->flags |= INFO_FLAG_SYSPEER;
  814. if (pp->flags & FLAG_CONFIG)
  815. ip->flags |= INFO_FLAG_CONFIG;
  816. if (pp->flags & FLAG_REFCLOCK)
  817. ip->flags |= INFO_FLAG_REFCLOCK;
  818. if (pp->flags & FLAG_AUTHENABLE)
  819. ip->flags |= INFO_FLAG_AUTHENABLE;
  820. if (pp->flags & FLAG_PREFER)
  821. ip->flags |= INFO_FLAG_PREFER;
  822. if (pp->flags & FLAG_BURST)
  823. ip->flags |= INFO_FLAG_BURST;
  824. if (pp->status == CTL_PST_SEL_SYNCCAND)
  825. ip->flags |= INFO_FLAG_SEL_CANDIDATE;
  826. if (pp->status >= CTL_PST_SEL_SYSPEER)
  827. ip->flags |= INFO_FLAG_SHORTLIST;
  828. ip->leap = pp->leap;
  829. ip->hmode = pp->hmode;
  830. ip->keyid = pp->keyid;
  831. ip->stratum = pp->stratum;
  832. ip->ppoll = pp->ppoll;
  833. ip->hpoll = pp->hpoll;
  834. ip->precision = pp->precision;
  835. ip->version = pp->version;
  836. ip->reach = pp->reach;
  837. ip->unreach = (u_char) pp->unreach;
  838. ip->flash = (u_char)pp->flash;
  839. ip->flash2 = (u_short) pp->flash;
  840. ip->estbdelay = HTONS_FP(DTOFP(pp->estbdelay));
  841. ip->ttl = pp->ttl;
  842. ip->associd = htons(pp->associd);
  843. ip->rootdelay = HTONS_FP(DTOUFP(pp->rootdelay));
  844. ip->rootdispersion = HTONS_FP(DTOUFP(pp->rootdispersion));
  845. ip->refid = pp->refid;
  846. HTONL_FP(&pp->reftime, &ip->reftime);
  847. HTONL_FP(&pp->org, &ip->org);
  848. HTONL_FP(&pp->rec, &ip->rec);
  849. HTONL_FP(&pp->xmt, &ip->xmt);
  850. j = pp->filter_nextpt - 1;
  851. for (i = 0; i < NTP_SHIFT; i++, j--) {
  852. if (j < 0)
  853. j = NTP_SHIFT-1;
  854. ip->filtdelay[i] = HTONS_FP(DTOFP(pp->filter_delay[j]));
  855. DTOLFP(pp->filter_offset[j], &ltmp);
  856. HTONL_FP(&ltmp, &ip->filtoffset[i]);
  857. ip->order[i] = (u_char)((pp->filter_nextpt+NTP_SHIFT-1)
  858. - pp->filter_order[i]);
  859. if (ip->order[i] >= NTP_SHIFT)
  860. ip->order[i] -= NTP_SHIFT;
  861. }
  862. DTOLFP(pp->offset, &ltmp);
  863. HTONL_FP(&ltmp, &ip->offset);
  864. ip->delay = HTONS_FP(DTOFP(pp->delay));
  865. ip->dispersion = HTONS_FP(DTOUFP(SQRT(pp->disp)));
  866. ip->selectdisp = HTONS_FP(DTOUFP(SQRT(pp->jitter)));
  867. ip = (struct info_peer *)more_pkt();
  868. }
  869. flush_pkt();
  870. }
  871. /*
  872. * peer_stats - send statistics for one or more peers
  873. */
  874. static void
  875. peer_stats (
  876. struct sockaddr_storage *srcadr,
  877. struct interface *inter,
  878. struct req_pkt *inpkt
  879. )
  880. {
  881. register struct info_peer_list *ipl;
  882. register struct peer *pp;
  883. register struct info_peer_stats *ip;
  884. register int items;
  885. struct sockaddr_storage addr;
  886. extern struct peer *sys_peer;
  887. #ifdef DEBUG
  888. if (debug)
  889. printf("peer_stats: called\n");
  890. #endif
  891. items = INFO_NITEMS(inpkt->err_nitems);
  892. ipl = (struct info_peer_list *) inpkt->data;
  893. ip = (struct info_peer_stats *)prepare_pkt(srcadr, inter, inpkt,
  894. v6sizeof(struct info_peer_stats));
  895. while (items-- > 0 && ip != 0) {
  896. memset((char *)&addr, 0, sizeof(addr));
  897. NSRCPORT(&addr) = ipl->port;
  898. if (client_v6_capable && ipl->v6_flag) {
  899. addr.ss_family = AF_INET6;
  900. GET_INADDR6(addr) = ipl->addr6;
  901. } else {
  902. addr.ss_family = AF_INET;
  903. GET_INADDR(addr) = ipl->addr;
  904. }
  905. #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
  906. addr.ss_len = SOCKLEN(&addr);
  907. #endif
  908. #ifdef DEBUG
  909. if (debug)
  910. printf("peer_stats: looking for %s, %d, %d\n", stoa(&addr),
  911. ipl->port, ((struct sockaddr_in6 *)&addr)->sin6_port);
  912. #endif
  913. ipl = (struct info_peer_list *)((char *)ipl +
  914. INFO_ITEMSIZE(inpkt->mbz_itemsize));
  915. if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0)
  916. continue;
  917. #ifdef DEBUG
  918. if (debug)
  919. printf("peer_stats: found %s\n", stoa(&addr));
  920. #endif
  921. if (pp->srcadr.ss_family == AF_INET) {
  922. if (pp->dstadr)
  923. ip->dstadr = (pp->processed) ?
  924. pp->cast_flags == MDF_BCAST ?
  925. GET_INADDR(pp->dstadr->bcast):
  926. pp->cast_flags ?
  927. GET_INADDR(pp->dstadr->sin) ?
  928. GET_INADDR(pp->dstadr->sin):
  929. GET_INADDR(pp->dstadr->bcast):
  930. 3 : 7;
  931. else
  932. memset(&ip->dstadr, 0, sizeof(ip->dstadr));
  933. ip->srcadr = GET_INADDR(pp->srcadr);
  934. if (client_v6_capable)
  935. ip->v6_flag = 0;
  936. } else {
  937. if (pp->dstadr)
  938. ip->dstadr6 = pp->cast_flags == MDF_BCAST ?
  939. GET_INADDR6(pp->dstadr->bcast):
  940. GET_INADDR6(pp->dstadr->sin);
  941. else
  942. memset(&ip->dstadr6, 0, sizeof(ip->dstadr6));
  943. ip->srcadr6 = GET_INADDR6(pp->srcadr);
  944. ip->v6_flag = 1;
  945. }
  946. ip->srcport = NSRCPORT(&pp->srcadr);
  947. ip->flags = 0;
  948. if (pp == sys_peer)
  949. ip->flags |= INFO_FLAG_SYSPEER;
  950. if (pp->flags & FLAG_CONFIG)
  951. ip->flags |= INFO_FLAG_CONFIG;
  952. if (pp->flags & FLAG_REFCLOCK)
  953. ip->flags |= INFO_FLAG_REFCLOCK;
  954. if (pp->flags & FLAG_AUTHENABLE)
  955. ip->flags |= INFO_FLAG_AUTHENABLE;
  956. if (pp->flags & FLAG_PREFER)
  957. ip->flags |= INFO_FLAG_PREFER;
  958. if (pp->flags & FLAG_BURST)
  959. ip->flags |= INFO_FLAG_BURST;
  960. if (pp->flags & FLAG_IBURST)
  961. ip->flags |= INFO_FLAG_IBURST;
  962. if (pp->status == CTL_PST_SEL_SYNCCAND)
  963. ip->flags |= INFO_FLAG_SEL_CANDIDATE;
  964. if (pp->status >= CTL_PST_SEL_SYSPEER)
  965. ip->flags |= INFO_FLAG_SHORTLIST;
  966. ip->flags = htons(ip->flags);
  967. ip->timereceived = htonl((u_int32)(current_time - pp->timereceived));
  968. ip->timetosend = htonl(pp->nextdate - current_time);
  969. ip->timereachable = htonl((u_int32)(current_time - pp->timereachable));
  970. ip->sent = htonl((u_int32)(pp->sent));
  971. ip->processed = htonl((u_int32)(pp->processed));
  972. ip->badauth = htonl((u_int32)(pp->badauth));
  973. ip->bogusorg = htonl((u_int32)(pp->bogusorg));
  974. ip->oldpkt = htonl((u_int32)(pp->oldpkt));
  975. ip->seldisp = htonl((u_int32)(pp->seldisptoolarge));
  976. ip->selbroken = htonl((u_int32)(pp->selbroken));
  977. ip->candidate = pp->status;
  978. ip = (struct info_peer_stats *)more_pkt();
  979. }
  980. flush_pkt();
  981. }
  982. /*
  983. * sys_info - return system info
  984. */
  985. static void
  986. sys_info(
  987. struct sockaddr_storage *srcadr,
  988. struct interface *inter,
  989. struct req_pkt *inpkt
  990. )
  991. {
  992. register struct info_sys *is;
  993. is = (struct info_sys *)prepare_pkt(srcadr, inter, inpkt,
  994. v6sizeof(struct info_sys));
  995. if (sys_peer != 0) {
  996. if (sys_peer->srcadr.ss_family == AF_INET) {
  997. is->peer = GET_INADDR(sys_peer->srcadr);
  998. if (client_v6_capable)
  999. is->v6_flag = 0;
  1000. } else if (client_v6_capable) {
  1001. is->peer6 = GET_INADDR6(sys_peer->srcadr);
  1002. is->v6_flag = 1;
  1003. }
  1004. is->peer_mode = sys_peer->hmode;
  1005. } else {
  1006. is->peer = 0;
  1007. if (client_v6_capable) {
  1008. is->v6_flag = 0;
  1009. }
  1010. is->peer_mode = 0;
  1011. }
  1012. is->leap = sys_leap;
  1013. is->stratum = sys_stratum;
  1014. is->precision = sys_precision;
  1015. is->rootdelay = htonl(DTOFP(sys_rootdelay));
  1016. is->rootdispersion = htonl(DTOUFP(sys_rootdispersion));
  1017. is->frequency = htonl(DTOFP(sys_jitter));
  1018. is->stability = htonl(DTOUFP(clock_stability));
  1019. is->refid = sys_refid;
  1020. HTONL_FP(&sys_reftime, &is->reftime);
  1021. is->poll = sys_poll;
  1022. is->flags = 0;
  1023. if (sys_authenticate)
  1024. is->flags |= INFO_FLAG_AUTHENTICATE;
  1025. if (sys_bclient)
  1026. is->flags |= INFO_FLAG_BCLIENT;
  1027. #ifdef REFCLOCK
  1028. if (cal_enable)
  1029. is->flags |= INFO_FLAG_CAL;
  1030. #endif /* REFCLOCK */
  1031. if (kern_enable)
  1032. is->flags |= INFO_FLAG_KERNEL;
  1033. if (mon_enabled != MON_OFF)
  1034. is->flags |= INFO_FLAG_MONITOR;
  1035. if (ntp_enable)
  1036. is->flags |= INFO_FLAG_NTP;
  1037. if (pps_enable)
  1038. is->flags |= INFO_FLAG_PPS_SYNC;
  1039. if (stats_control)
  1040. is->flags |= INFO_FLAG_FILEGEN;
  1041. is->bdelay = HTONS_FP(DTOFP(sys_bdelay));
  1042. HTONL_UF(sys_authdelay.l_f, &is->authdelay);
  1043. (void) more_pkt();
  1044. flush_pkt();
  1045. }
  1046. /*
  1047. * sys_stats - return system statistics
  1048. */
  1049. static void
  1050. sys_stats(
  1051. struct sockaddr_storage *srcadr,
  1052. struct interface *inter,
  1053. struct req_pkt *inpkt
  1054. )
  1055. {
  1056. register struct info_sys_stats *ss;
  1057. /*
  1058. * Importations from the protocol module
  1059. */
  1060. ss = (struct info_sys_stats *)prepare_pkt(srcadr, inter, inpkt,
  1061. sizeof(struct info_sys_stats));
  1062. ss->timeup = htonl((u_int32)current_time);
  1063. ss->timereset = htonl((u_int32)(current_time - sys_stattime));
  1064. ss->denied = htonl((u_int32)sys_restricted);
  1065. ss->oldversionpkt = htonl((u_int32)sys_oldversionpkt);
  1066. ss->newversionpkt = htonl((u_int32)sys_newversionpkt);
  1067. ss->unknownversion = htonl((u_int32)sys_unknownversion);
  1068. ss->badlength = htonl((u_int32)sys_badlength);
  1069. ss->processed = htonl((u_int32)sys_processed);
  1070. ss->badauth = htonl((u_int32)sys_badauth);
  1071. ss->limitrejected = htonl((u_int32)sys_limitrejected);
  1072. ss->received = htonl((u_int32)sys_received);
  1073. (void) more_pkt();
  1074. flush_pkt();
  1075. }
  1076. /*
  1077. * mem_stats - return memory statistics
  1078. */
  1079. static void
  1080. mem_stats(
  1081. struct sockaddr_storage *srcadr,
  1082. struct interface *inter,
  1083. struct req_pkt *inpkt
  1084. )
  1085. {
  1086. register struct info_mem_stats *ms;
  1087. register int i;
  1088. /*
  1089. * Importations from the peer module
  1090. */
  1091. extern int peer_hash_count[NTP_HASH_SIZE];
  1092. extern int peer_free_count;
  1093. extern u_long peer_timereset;
  1094. extern u_long findpeer_calls;
  1095. extern u_long peer_allocations;
  1096. extern u_long peer_demobilizations;
  1097. extern int total_peer_structs;
  1098. ms = (struct info_mem_stats *)prepare_pkt(srcadr, inter, inpkt,
  1099. sizeof(struct info_mem_stats));
  1100. ms->timereset = htonl((u_int32)(current_time - peer_timereset));
  1101. ms->totalpeermem = htons((u_short)total_peer_structs);
  1102. ms->freepeermem = htons((u_short)peer_free_count);
  1103. ms->findpeer_calls = htonl((u_int32)findpeer_calls);
  1104. ms->allocations = htonl((u_int32)peer_allocations);
  1105. ms->demobilizations = htonl((u_int32)peer_demobilizations);
  1106. for (i = 0; i < NTP_HASH_SIZE; i++) {
  1107. if (peer_hash_count[i] > 255)
  1108. ms->hashcount[i] = 255;
  1109. else
  1110. ms->hashcount[i] = (u_char)peer_hash_count[i];
  1111. }
  1112. (void) more_pkt();
  1113. flush_pkt();
  1114. }
  1115. /*
  1116. * io_stats - return io statistics
  1117. */
  1118. static void
  1119. io_stats(
  1120. struct sockaddr_storage *srcadr,
  1121. struct interface *inter,
  1122. struct req_pkt *inpkt
  1123. )
  1124. {
  1125. register struct info_io_stats *io;
  1126. /*
  1127. * Importations from the io module
  1128. */
  1129. extern u_long io_timereset;
  1130. io = (struct info_io_stats *)prepare_pkt(srcadr, inter, inpkt,
  1131. sizeof(struct info_io_stats));
  1132. io->timereset = htonl((u_int32)(current_time - io_timereset));
  1133. io->totalrecvbufs = htons((u_short) total_recvbuffs());
  1134. io->freerecvbufs = htons((u_short) free_recvbuffs());
  1135. io->fullrecvbufs = htons((u_short) full_recvbuffs());
  1136. io->lowwater = htons((u_short) lowater_additions());
  1137. io->dropped = htonl((u_int32)packets_dropped);
  1138. io->ignored = htonl((u_int32)packets_ignored);
  1139. io->received = htonl((u_int32)packets_received);
  1140. io->sent = htonl((u_int32)packets_sent);
  1141. io->notsent = htonl((u_int32)packets_notsent);
  1142. io->interrupts = htonl((u_int32)handler_calls);
  1143. io->int_received = htonl((u_int32)handler_pkts);
  1144. (void) more_pkt();
  1145. flush_pkt();
  1146. }
  1147. /*
  1148. * timer_stats - return timer statistics
  1149. */
  1150. static void
  1151. timer_stats(
  1152. struct sockaddr_storage *srcadr,
  1153. struct interface *inter,
  1154. struct req_pkt *inpkt
  1155. )
  1156. {
  1157. register struct info_timer_stats *ts;
  1158. /*
  1159. * Importations from the timer module
  1160. */
  1161. extern u_long timer_timereset;
  1162. extern u_long timer_overflows;
  1163. extern u_long timer_xmtcalls;
  1164. ts = (struct info_timer_stats *)prepare_pkt(srcadr, inter, inpkt,
  1165. sizeof(struct info_timer_stats));
  1166. ts->timereset = htonl((u_int32)(current_time - timer_timereset));
  1167. ts->alarms = htonl((u_int32)alarm_overflow);
  1168. ts->overflows = htonl((u_int32)timer_overflows);
  1169. ts->xmtcalls = htonl((u_int32)timer_xmtcalls);
  1170. (void) more_pkt();
  1171. flush_pkt();
  1172. }
  1173. /*
  1174. * loop_info - return the current state of the loop filter
  1175. */
  1176. static void
  1177. loop_info(
  1178. struct sockaddr_storage *srcadr,
  1179. struct interface *inter,
  1180. struct req_pkt *inpkt
  1181. )
  1182. {
  1183. register struct info_loop *li;
  1184. l_fp ltmp;
  1185. /*
  1186. * Importations from the loop filter module
  1187. */
  1188. extern double last_offset;
  1189. extern double drift_comp;
  1190. extern int tc_counter;
  1191. extern u_long sys_clocktime;
  1192. li = (struct info_loop *)prepare_pkt(srcadr, inter, inpkt,
  1193. sizeof(struct info_loop));
  1194. DTOLFP(last_offset, &ltmp);
  1195. HTONL_FP(&ltmp, &li->last_offset);
  1196. DTOLFP(drift_comp * 1e6, &ltmp);
  1197. HTONL_FP(&ltmp, &li->drift_comp);
  1198. li->compliance = htonl((u_int32)(tc_counter));
  1199. li->watchdog_timer = htonl((u_int32)(current_time - sys_clocktime));
  1200. (void) more_pkt();
  1201. flush_pkt();
  1202. }
  1203. /*
  1204. * do_conf - add a peer to the configuration list
  1205. */
  1206. static void
  1207. do_conf(
  1208. struct sockaddr_storage *srcadr,
  1209. struct interface *inter,
  1210. struct req_pkt *inpkt
  1211. )
  1212. {
  1213. static u_long soonest_ifrescan_time = 0;
  1214. int items;
  1215. u_int fl;
  1216. struct conf_peer *cp;
  1217. struct conf_peer temp_cp;
  1218. struct sockaddr_storage peeraddr;
  1219. struct sockaddr_in tmp_clock;
  1220. /*
  1221. * Do a check of everything to see that it looks
  1222. * okay. If not, complain about it. Note we are
  1223. * very picky here.
  1224. */
  1225. items = INFO_NITEMS(inpkt->err_nitems);
  1226. cp = (struct conf_peer *)inpkt->data;
  1227. memset(&temp_cp, 0, sizeof(struct conf_peer));
  1228. memcpy(&temp_cp, (char *)cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1229. fl = 0;
  1230. while (items-- > 0 && !fl) {
  1231. if (((temp_cp.version) > NTP_VERSION)
  1232. || ((temp_cp.version) < NTP_OLDVERSION))
  1233. fl = 1;
  1234. if (temp_cp.hmode != MODE_ACTIVE
  1235. && temp_cp.hmode != MODE_CLIENT
  1236. && temp_cp.hmode != MODE_BROADCAST)
  1237. fl = 1;
  1238. if (temp_cp.flags & ~(CONF_FLAG_AUTHENABLE | CONF_FLAG_PREFER
  1239. | CONF_FLAG_BURST | CONF_FLAG_IBURST | CONF_FLAG_SKEY))
  1240. fl = 1;
  1241. cp = (struct conf_peer *)
  1242. ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1243. }
  1244. if (fl) {
  1245. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  1246. return;
  1247. }
  1248. /*
  1249. * Looks okay, try it out
  1250. */
  1251. items = INFO_NITEMS(inpkt->err_nitems);
  1252. cp = (struct conf_peer *)inpkt->data;
  1253. while (items-- > 0) {
  1254. memset(&temp_cp, 0, sizeof(struct conf_peer));
  1255. memcpy(&temp_cp, (char *)cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1256. memset((char *)&peeraddr, 0, sizeof(struct sockaddr_storage));
  1257. fl = 0;
  1258. if (temp_cp.flags & CONF_FLAG_AUTHENABLE)
  1259. fl |= FLAG_AUTHENABLE;
  1260. if (temp_cp.flags & CONF_FLAG_PREFER)
  1261. fl |= FLAG_PREFER;
  1262. if (temp_cp.flags & CONF_FLAG_BURST)
  1263. fl |= FLAG_BURST;
  1264. if (temp_cp.flags & CONF_FLAG_IBURST)
  1265. fl |= FLAG_IBURST;
  1266. if (temp_cp.flags & CONF_FLAG_SKEY)
  1267. fl |= FLAG_SKEY;
  1268. if (client_v6_capable && temp_cp.v6_flag != 0) {
  1269. peeraddr.ss_family = AF_INET6;
  1270. GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
  1271. } else {
  1272. peeraddr.ss_family = AF_INET;
  1273. GET_INADDR(peeraddr) = temp_cp.peeraddr;
  1274. /*
  1275. * Make sure the address is valid
  1276. */
  1277. tmp_clock = *CAST_V4(peeraddr);
  1278. if (
  1279. #ifdef REFCLOCK
  1280. !ISREFCLOCKADR(&tmp_clock) &&
  1281. #endif
  1282. ISBADADR(&tmp_clock)) {
  1283. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  1284. return;
  1285. }
  1286. }
  1287. NSRCPORT(&peeraddr) = htons(NTP_PORT);
  1288. #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
  1289. peeraddr.ss_len = SOCKLEN(&peeraddr);
  1290. #endif
  1291. /* XXX W2DO? minpoll/maxpoll arguments ??? */
  1292. if (peer_config(&peeraddr, (struct interface *)0,
  1293. temp_cp.hmode, temp_cp.version, temp_cp.minpoll,
  1294. temp_cp.maxpoll, fl, temp_cp.ttl, temp_cp.keyid,
  1295. NULL) == 0) {
  1296. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  1297. return;
  1298. }
  1299. /*
  1300. * ntp_intres.c uses REQ_CONFIG/doconf() to add each
  1301. * server after its name is resolved. If we have been
  1302. * disconnected from the network, it may notice the
  1303. * network has returned and add the first server while
  1304. * the relevant interface is still disabled, awaiting
  1305. * the next interface rescan. To get things moving
  1306. * more quickly, trigger an interface scan now, except
  1307. * if we have done so in the last half minute.
  1308. */
  1309. if (soonest_ifrescan_time < current_time) {
  1310. soonest_ifrescan_time = current_time + 30;
  1311. timer_interfacetimeout(current_time);
  1312. DPRINTF(1, ("do_conf triggering interface rescan\n"));
  1313. }
  1314. cp = (struct conf_peer *)
  1315. ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1316. }
  1317. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  1318. }
  1319. #if 0
  1320. /* XXX */
  1321. /*
  1322. * dns_a - Snarf DNS info for an association ID
  1323. */
  1324. static void
  1325. dns_a(
  1326. struct sockaddr_storage *srcadr,
  1327. struct interface *inter,
  1328. struct req_pkt *inpkt
  1329. )
  1330. {
  1331. register struct info_dns_assoc *dp;
  1332. register int items;
  1333. struct sockaddr_in peeraddr;
  1334. /*
  1335. * Do a check of everything to see that it looks
  1336. * okay. If not, complain about it. Note we are
  1337. * very picky here.
  1338. */
  1339. items = INFO_NITEMS(inpkt->err_nitems);
  1340. dp = (struct info_dns_assoc *)inpkt->data;
  1341. /*
  1342. * Looks okay, try it out
  1343. */
  1344. items = INFO_NITEMS(inpkt->err_nitems);
  1345. dp = (struct info_dns_assoc *)inpkt->data;
  1346. memset((char *)&peeraddr, 0, sizeof(struct sockaddr_in));
  1347. peeraddr.sin_family = AF_INET;
  1348. peeraddr.sin_port = htons(NTP_PORT);
  1349. /*
  1350. * Make sure the address is valid
  1351. */
  1352. if (
  1353. #ifdef REFCLOCK
  1354. !ISREFCLOCKADR(&peeraddr) &&
  1355. #endif
  1356. ISBADADR(&peeraddr)) {
  1357. #ifdef REFCLOCK
  1358. msyslog(LOG_ERR, "dns_a: !ISREFCLOCK && ISBADADR");
  1359. #else
  1360. msyslog(LOG_ERR, "dns_a: ISBADADR");
  1361. #endif
  1362. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  1363. return;
  1364. }
  1365. while (items-- > 0) {
  1366. associd_t associd;
  1367. size_t hnl;
  1368. struct peer *peer;
  1369. int bogon = 0;
  1370. associd = dp->associd;
  1371. peer = findpeerbyassoc(associd);
  1372. if (peer == 0 || peer->flags & FLAG_REFCLOCK) {
  1373. msyslog(LOG_ERR, "dns_a: %s",
  1374. (peer == 0)
  1375. ? "peer == 0"
  1376. : "peer->flags & FLAG_REFCLOCK");
  1377. ++bogon;
  1378. }
  1379. peeraddr.sin_addr.s_addr = dp->peeraddr;
  1380. for (hnl = 0; dp->hostname[hnl] && hnl < sizeof dp->hostname; ++hnl) ;
  1381. if (hnl >= sizeof dp->hostname) {
  1382. msyslog(LOG_ERR, "dns_a: hnl (%ld) >= %ld",
  1383. (long)hnl, (long)sizeof dp->hostname);
  1384. ++bogon;
  1385. }
  1386. msyslog(LOG_INFO, "dns_a: <%s> for %s, AssocID %d, bogon %d",
  1387. dp->hostname,
  1388. stoa((struct sockaddr_storage *)&peeraddr), associd,
  1389. bogon);
  1390. if (bogon) {
  1391. /* If it didn't work */
  1392. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  1393. return;
  1394. } else {
  1395. #if 0
  1396. #ifdef PUBKEY
  1397. crypto_public(peer, dp->hostname);
  1398. #endif /* PUBKEY */
  1399. #endif
  1400. }
  1401. dp++;
  1402. }
  1403. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  1404. }
  1405. #endif /* 0 */
  1406. /*
  1407. * do_unconf - remove a peer from the configuration list
  1408. */
  1409. static void
  1410. do_unconf(
  1411. struct sockaddr_storage *srcadr,
  1412. struct interface *inter,
  1413. struct req_pkt *inpkt
  1414. )
  1415. {
  1416. register struct conf_unpeer *cp;
  1417. struct conf_unpeer temp_cp;
  1418. register int items;
  1419. register struct peer *peer;
  1420. struct sockaddr_storage peeraddr;
  1421. int bad, found;
  1422. /*
  1423. * This is a bit unstructured, but I like to be careful.
  1424. * We check to see that every peer exists and is actually
  1425. * configured. If so, we remove them. If not, we return
  1426. * an error.
  1427. */
  1428. items = INFO_NITEMS(inpkt->err_nitems);
  1429. cp = (struct conf_unpeer *)inpkt->data;
  1430. bad = 0;
  1431. while (items-- > 0 && !bad) {
  1432. memset(&temp_cp, 0, sizeof(temp_cp));
  1433. memset(&peeraddr, 0, sizeof(peeraddr));
  1434. memcpy(&temp_cp, cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1435. if (client_v6_capable && temp_cp.v6_flag != 0) {
  1436. peeraddr.ss_family = AF_INET6;
  1437. GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
  1438. } else {
  1439. peeraddr.ss_family = AF_INET;
  1440. GET_INADDR(peeraddr) = temp_cp.peeraddr;
  1441. }
  1442. NSRCPORT(&peeraddr) = htons(NTP_PORT);
  1443. #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
  1444. peeraddr.ss_len = SOCKLEN(&peeraddr);
  1445. #endif
  1446. found = 0;
  1447. peer = (struct peer *)0;
  1448. #ifdef DEBUG
  1449. if (debug)
  1450. printf("searching for %s\n", stoa(&peeraddr));
  1451. #endif
  1452. while (!found) {
  1453. peer = findexistingpeer(&peeraddr, peer, -1);
  1454. if (peer == (struct peer *)0)
  1455. break;
  1456. if (peer->flags & FLAG_CONFIG)
  1457. found = 1;
  1458. }
  1459. if (!found)
  1460. bad = 1;
  1461. cp = (struct conf_unpeer *)
  1462. ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1463. }
  1464. if (bad) {
  1465. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  1466. return;
  1467. }
  1468. /*
  1469. * Now do it in earnest.
  1470. */
  1471. items = INFO_NITEMS(inpkt->err_nitems);
  1472. cp = (struct conf_unpeer *)inpkt->data;
  1473. while (items-- > 0) {
  1474. memset(&temp_cp, 0, sizeof(temp_cp));
  1475. memset(&peeraddr, 0, sizeof(peeraddr));
  1476. memcpy(&temp_cp, cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1477. if (client_v6_capable && temp_cp.v6_flag != 0) {
  1478. peeraddr.ss_family = AF_INET6;
  1479. GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
  1480. } else {
  1481. peeraddr.ss_family = AF_INET;
  1482. GET_INADDR(peeraddr) = temp_cp.peeraddr;
  1483. }
  1484. NSRCPORT(&peeraddr) = htons(NTP_PORT);
  1485. #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
  1486. peeraddr.ss_len = SOCKLEN(&peeraddr);
  1487. #endif
  1488. peer_unconfig(&peeraddr, (struct interface *)0, -1);
  1489. cp = (struct conf_unpeer *)
  1490. ((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1491. }
  1492. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  1493. }
  1494. /*
  1495. * set_sys_flag - set system flags
  1496. */
  1497. static void
  1498. set_sys_flag(
  1499. struct sockaddr_storage *srcadr,
  1500. struct interface *inter,
  1501. struct req_pkt *inpkt
  1502. )
  1503. {
  1504. setclr_flags(srcadr, inter, inpkt, 1);
  1505. }
  1506. /*
  1507. * clr_sys_flag - clear system flags
  1508. */
  1509. static void
  1510. clr_sys_flag(
  1511. struct sockaddr_storage *srcadr,
  1512. struct interface *inter,
  1513. struct req_pkt *inpkt
  1514. )
  1515. {
  1516. setclr_flags(srcadr, inter, inpkt, 0);
  1517. }
  1518. /*
  1519. * setclr_flags - do the grunge work of flag setting/clearing
  1520. */
  1521. static void
  1522. setclr_flags(
  1523. struct sockaddr_storage *srcadr,
  1524. struct interface *inter,
  1525. struct req_pkt *inpkt,
  1526. u_long set
  1527. )
  1528. {
  1529. register u_int flags;
  1530. int prev_kern_enable;
  1531. prev_kern_enable = kern_enable;
  1532. if (INFO_NITEMS(inpkt->err_nitems) > 1) {
  1533. msyslog(LOG_ERR, "setclr_flags: err_nitems > 1");
  1534. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  1535. return;
  1536. }
  1537. flags = ((struct conf_sys_flags *)inpkt->data)->flags;
  1538. flags = ntohl(flags);
  1539. if (flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
  1540. SYS_FLAG_NTP | SYS_FLAG_KERNEL | SYS_FLAG_MONITOR |
  1541. SYS_FLAG_FILEGEN | SYS_FLAG_AUTH | SYS_FLAG_CAL)) {
  1542. msyslog(LOG_ERR, "setclr_flags: extra flags: %#x",
  1543. flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
  1544. SYS_FLAG_NTP | SYS_FLAG_KERNEL |
  1545. SYS_FLAG_MONITOR | SYS_FLAG_FILEGEN |
  1546. SYS_FLAG_AUTH | SYS_FLAG_CAL));
  1547. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  1548. return;
  1549. }
  1550. if (flags & SYS_FLAG_BCLIENT)
  1551. proto_config(PROTO_BROADCLIENT, set, 0., NULL);
  1552. if (flags & SYS_FLAG_PPS)
  1553. proto_config(PROTO_PPS, set, 0., NULL);
  1554. if (flags & SYS_FLAG_NTP)
  1555. proto_config(PROTO_NTP, set, 0., NULL);
  1556. if (flags & SYS_FLAG_KERNEL)
  1557. proto_config(PROTO_KERNEL, set, 0., NULL);
  1558. if (flags & SYS_FLAG_MONITOR)
  1559. proto_config(PROTO_MONITOR, set, 0., NULL);
  1560. if (flags & SYS_FLAG_FILEGEN)
  1561. proto_config(PROTO_FILEGEN, set, 0., NULL);
  1562. if (flags & SYS_FLAG_AUTH)
  1563. proto_config(PROTO_AUTHENTICATE, set, 0., NULL);
  1564. if (flags & SYS_FLAG_CAL)
  1565. proto_config(PROTO_CAL, set, 0., NULL);
  1566. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  1567. /* Reset the kernel ntp parameters if the kernel flag changed. */
  1568. if (prev_kern_enable && !kern_enable)
  1569. loop_config(LOOP_KERN_CLEAR, 0.0);
  1570. if (!prev_kern_enable && kern_enable)
  1571. loop_config(LOOP_DRIFTCOMP, drift_comp);
  1572. }
  1573. /*
  1574. * list_restrict - return the restrict list
  1575. */
  1576. static void
  1577. list_restrict(
  1578. struct sockaddr_storage *srcadr,
  1579. struct interface *inter,
  1580. struct req_pkt *inpkt
  1581. )
  1582. {
  1583. register struct info_restrict *ir;
  1584. register struct restrictlist *rl;
  1585. register struct restrictlist6 *rl6;
  1586. #ifdef DEBUG
  1587. if (debug > 2)
  1588. printf("wants restrict list summary\n");
  1589. #endif
  1590. ir = (struct info_restrict *)prepare_pkt(srcadr, inter, inpkt,
  1591. v6sizeof(struct info_restrict));
  1592. for (rl = restrictlist; rl != 0 && ir != 0; rl = rl->next) {
  1593. ir->addr = htonl(rl->addr);
  1594. if (client_v6_capable)
  1595. ir->v6_flag = 0;
  1596. ir->mask = htonl(rl->mask);
  1597. ir->count = htonl((u_int32)rl->count);
  1598. ir->flags = htons(rl->flags);
  1599. ir->mflags = htons(rl->mflags);
  1600. ir = (struct info_restrict *)more_pkt();
  1601. }
  1602. if (client_v6_capable)
  1603. for (rl6 = restrictlist6; rl6 != 0 && ir != 0; rl6 = rl6->next) {
  1604. ir->addr6 = rl6->addr6;
  1605. ir->mask6 = rl6->mask6;
  1606. ir->v6_flag = 1;
  1607. ir->count = htonl((u_int32)rl6->count);
  1608. ir->flags = htons(rl6->flags);
  1609. ir->mflags = htons(rl6->mflags);
  1610. ir = (struct info_restrict *)more_pkt();
  1611. }
  1612. flush_pkt();
  1613. }
  1614. /*
  1615. * do_resaddflags - add flags to a restrict entry (or create one)
  1616. */
  1617. static void
  1618. do_resaddflags(
  1619. struct sockaddr_storage *srcadr,
  1620. struct interface *inter,
  1621. struct req_pkt *inpkt
  1622. )
  1623. {
  1624. do_restrict(srcadr, inter, inpkt, RESTRICT_FLAGS);
  1625. }
  1626. /*
  1627. * do_ressubflags - remove flags from a restrict entry
  1628. */
  1629. static void
  1630. do_ressubflags(
  1631. struct sockaddr_storage *srcadr,
  1632. struct interface *inter,
  1633. struct req_pkt *inpkt
  1634. )
  1635. {
  1636. do_restrict(srcadr, inter, inpkt, RESTRICT_UNFLAG);
  1637. }
  1638. /*
  1639. * do_unrestrict - remove a restrict entry from the list
  1640. */
  1641. static void
  1642. do_unrestrict(
  1643. struct sockaddr_storage *srcadr,
  1644. struct interface *inter,
  1645. struct req_pkt *inpkt
  1646. )
  1647. {
  1648. do_restrict(srcadr, inter, inpkt, RESTRICT_REMOVE);
  1649. }
  1650. /*
  1651. * do_restrict - do the dirty stuff of dealing with restrictions
  1652. */
  1653. static void
  1654. do_restrict(
  1655. struct sockaddr_storage *srcadr,
  1656. struct interface *inter,
  1657. struct req_pkt *inpkt,
  1658. int op
  1659. )
  1660. {
  1661. register struct conf_restrict *cr;
  1662. register int items;
  1663. struct sockaddr_storage matchaddr;
  1664. struct sockaddr_storage matchmask;
  1665. int bad;
  1666. /*
  1667. * Do a check of the flags to make sure that only
  1668. * the NTPPORT flag is set, if any. If not, complain
  1669. * about it. Note we are very picky here.
  1670. */
  1671. items = INFO_NITEMS(inpkt->err_nitems);
  1672. cr = (struct conf_restrict *)inpkt->data;
  1673. bad = 0;
  1674. cr->flags = ntohs(cr->flags);
  1675. cr->mflags = ntohs(cr->mflags);
  1676. while (items-- > 0 && !bad) {
  1677. if (cr->mflags & ~(RESM_NTPONLY))
  1678. bad |= 1;
  1679. if (cr->flags & ~(RES_ALLFLAGS))
  1680. bad |= 2;
  1681. if (cr->mask != htonl(INADDR_ANY)) {
  1682. if (client_v6_capable && cr->v6_flag != 0) {
  1683. if (IN6_IS_ADDR_UNSPECIFIED(&cr->addr6))
  1684. bad |= 4;
  1685. } else
  1686. if (cr->addr == htonl(INADDR_ANY))
  1687. bad |= 8;
  1688. }
  1689. cr = (struct conf_restrict *)((char *)cr +
  1690. INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1691. }
  1692. if (bad) {
  1693. msyslog(LOG_ERR, "do_restrict: bad = %#x", bad);
  1694. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  1695. return;
  1696. }
  1697. /*
  1698. * Looks okay, try it out
  1699. */
  1700. items = INFO_NITEMS(inpkt->err_nitems);
  1701. cr = (struct conf_restrict *)inpkt->data;
  1702. memset((char *)&matchaddr, 0, sizeof(struct sockaddr_storage));
  1703. memset((char *)&matchmask, 0, sizeof(struct sockaddr_storage));
  1704. while (items-- > 0) {
  1705. if (client_v6_capable && cr->v6_flag != 0) {
  1706. GET_INADDR6(matchaddr) = cr->addr6;
  1707. GET_INADDR6(matchmask) = cr->mask6;
  1708. matchaddr.ss_family = AF_INET6;
  1709. matchmask.ss_family = AF_INET6;
  1710. } else {
  1711. GET_INADDR(matchaddr) = cr->addr;
  1712. GET_INADDR(matchmask) = cr->mask;
  1713. matchaddr.ss_family = AF_INET;
  1714. matchmask.ss_family = AF_INET;
  1715. }
  1716. hack_restrict(op, &matchaddr, &matchmask, cr->mflags,
  1717. cr->flags);
  1718. cr++;
  1719. }
  1720. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  1721. }
  1722. /*
  1723. * mon_getlist - return monitor data
  1724. */
  1725. static void
  1726. mon_getlist_0(
  1727. struct sockaddr_storage *srcadr,
  1728. struct interface *inter,
  1729. struct req_pkt *inpkt
  1730. )
  1731. {
  1732. register struct info_monitor *im;
  1733. register struct mon_data *md;
  1734. extern struct mon_data mon_mru_list;
  1735. extern int mon_enabled;
  1736. #ifdef DEBUG
  1737. if (debug > 2)
  1738. printf("wants monitor 0 list\n");
  1739. #endif
  1740. if (!mon_enabled) {
  1741. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  1742. return;
  1743. }
  1744. im = (struct info_monitor *)prepare_pkt(srcadr, inter, inpkt,
  1745. v6sizeof(struct info_monitor));
  1746. for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0;
  1747. md = md->mru_next) {
  1748. im->lasttime = htonl((u_int32)md->avg_interval);
  1749. im->firsttime = htonl((u_int32)(current_time - md->lasttime));
  1750. im->lastdrop = htonl((u_int32)md->drop_count);
  1751. im->count = htonl((u_int32)(md->count));
  1752. if (md->rmtadr.ss_family == AF_INET6) {
  1753. if (!client_v6_capable)
  1754. continue;
  1755. im->addr6 = GET_INADDR6(md->rmtadr);
  1756. im->v6_flag = 1;
  1757. } else {
  1758. im->addr = GET_INADDR(md->rmtadr);
  1759. if (client_v6_capable)
  1760. im->v6_flag = 0;
  1761. }
  1762. im->port = md->rmtport;
  1763. im->mode = md->mode;
  1764. im->version = md->version;
  1765. im = (struct info_monitor *)more_pkt();
  1766. }
  1767. flush_pkt();
  1768. }
  1769. /*
  1770. * mon_getlist - return monitor data
  1771. */
  1772. static void
  1773. mon_getlist_1(
  1774. struct sockaddr_storage *srcadr,
  1775. struct interface *inter,
  1776. struct req_pkt *inpkt
  1777. )
  1778. {
  1779. register struct info_monitor_1 *im;
  1780. register struct mon_data *md;
  1781. extern struct mon_data mon_mru_list;
  1782. extern int mon_enabled;
  1783. if (!mon_enabled) {
  1784. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  1785. return;
  1786. }
  1787. im = (struct info_monitor_1 *)prepare_pkt(srcadr, inter, inpkt,
  1788. v6sizeof(struct info_monitor_1));
  1789. for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0;
  1790. md = md->mru_next) {
  1791. im->lasttime = htonl((u_int32)md->avg_interval);
  1792. im->firsttime = htonl((u_int32)(current_time - md->lasttime));
  1793. im->lastdrop = htonl((u_int32)md->drop_count);
  1794. im->count = htonl((u_int32)md->count);
  1795. if (md->rmtadr.ss_family == AF_INET6) {
  1796. if (!client_v6_capable)
  1797. continue;
  1798. im->addr6 = GET_INADDR6(md->rmtadr);
  1799. im->v6_flag = 1;
  1800. im->daddr6 = GET_INADDR6(md->interface->sin);
  1801. } else {
  1802. im->addr = GET_INADDR(md->rmtadr);
  1803. if (client_v6_capable)
  1804. im->v6_flag = 0;
  1805. im->daddr = (md->cast_flags == MDF_BCAST)
  1806. ? GET_INADDR(md->interface->bcast)
  1807. : (md->cast_flags
  1808. ? (GET_INADDR(md->interface->sin)
  1809. ? GET_INADDR(md->interface->sin)
  1810. : GET_INADDR(md->interface->bcast))
  1811. : 4);
  1812. }
  1813. im->flags = htonl(md->cast_flags);
  1814. im->port = md->rmtport;
  1815. im->mode = md->mode;
  1816. im->version = md->version;
  1817. im = (struct info_monitor_1 *)more_pkt();
  1818. }
  1819. flush_pkt();
  1820. }
  1821. /*
  1822. * Module entry points and the flags they correspond with
  1823. */
  1824. struct reset_entry {
  1825. int flag; /* flag this corresponds to */
  1826. void (*handler) P((void)); /* routine to handle request */
  1827. };
  1828. struct reset_entry reset_entries[] = {
  1829. { RESET_FLAG_ALLPEERS, peer_all_reset },
  1830. { RESET_FLAG_IO, io_clr_stats },
  1831. { RESET_FLAG_SYS, proto_clr_stats },
  1832. { RESET_FLAG_MEM, peer_clr_stats },
  1833. { RESET_FLAG_TIMER, timer_clr_stats },
  1834. { RESET_FLAG_AUTH, reset_auth_stats },
  1835. { RESET_FLAG_CTL, ctl_clr_stats },
  1836. { 0, 0 }
  1837. };
  1838. /*
  1839. * reset_stats - reset statistic counters here and there
  1840. */
  1841. static void
  1842. reset_stats(
  1843. struct sockaddr_storage *srcadr,
  1844. struct interface *inter,
  1845. struct req_pkt *inpkt
  1846. )
  1847. {
  1848. u_long flags;
  1849. struct reset_entry *rent;
  1850. if (INFO_NITEMS(inpkt->err_nitems) > 1) {
  1851. msyslog(LOG_ERR, "reset_stats: err_nitems > 1");
  1852. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  1853. return;
  1854. }
  1855. flags = ((struct reset_flags *)inpkt->data)->flags;
  1856. flags = ntohl(flags);
  1857. if (flags & ~RESET_ALLFLAGS) {
  1858. msyslog(LOG_ERR, "reset_stats: reset leaves %#lx",
  1859. flags & ~RESET_ALLFLAGS);
  1860. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  1861. return;
  1862. }
  1863. for (rent = reset_entries; rent->flag != 0; rent++) {
  1864. if (flags & rent->flag)
  1865. (rent->handler)();
  1866. }
  1867. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  1868. }
  1869. /*
  1870. * reset_peer - clear a peer's statistics
  1871. */
  1872. static void
  1873. reset_peer(
  1874. struct sockaddr_storage *srcadr,
  1875. struct interface *inter,
  1876. struct req_pkt *inpkt
  1877. )
  1878. {
  1879. register struct conf_unpeer *cp;
  1880. register int items;
  1881. register struct peer *peer;
  1882. struct sockaddr_storage peeraddr;
  1883. int bad;
  1884. /*
  1885. * We check first to see that every peer exists. If not,
  1886. * we return an error.
  1887. */
  1888. items = INFO_NITEMS(inpkt->err_nitems);
  1889. cp = (struct conf_unpeer *)inpkt->data;
  1890. bad = 0;
  1891. while (items-- > 0 && !bad) {
  1892. memset((char *)&peeraddr, 0, sizeof(peeraddr));
  1893. if (client_v6_capable && cp->v6_flag != 0) {
  1894. GET_INADDR6(peeraddr) = cp->peeraddr6;
  1895. peeraddr.ss_family = AF_INET6;
  1896. } else {
  1897. GET_INADDR(peeraddr) = cp->peeraddr;
  1898. peeraddr.ss_family = AF_INET;
  1899. }
  1900. NSRCPORT(&peeraddr) = htons(NTP_PORT);
  1901. #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
  1902. peeraddr.ss_len = SOCKLEN(&peeraddr);
  1903. #endif
  1904. peer = findexistingpeer(&peeraddr, (struct peer *)0, -1);
  1905. if (peer == (struct peer *)0)
  1906. bad++;
  1907. cp = (struct conf_unpeer *)((char *)cp +
  1908. INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1909. }
  1910. if (bad) {
  1911. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  1912. return;
  1913. }
  1914. /*
  1915. * Now do it in earnest.
  1916. */
  1917. items = INFO_NITEMS(inpkt->err_nitems);
  1918. cp = (struct conf_unpeer *)inpkt->data;
  1919. while (items-- > 0) {
  1920. memset((char *)&peeraddr, 0, sizeof(peeraddr));
  1921. if (client_v6_capable && cp->v6_flag != 0) {
  1922. GET_INADDR6(peeraddr) = cp->peeraddr6;
  1923. peeraddr.ss_family = AF_INET6;
  1924. } else {
  1925. GET_INADDR(peeraddr) = cp->peeraddr;
  1926. peeraddr.ss_family = AF_INET;
  1927. }
  1928. #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
  1929. peeraddr.ss_len = SOCKLEN(&peeraddr);
  1930. #endif
  1931. peer = findexistingpeer(&peeraddr, (struct peer *)0, -1);
  1932. while (peer != 0) {
  1933. peer_reset(peer);
  1934. peer = findexistingpeer(&peeraddr, (struct peer *)peer, -1);
  1935. }
  1936. cp = (struct conf_unpeer *)((char *)cp +
  1937. INFO_ITEMSIZE(inpkt->mbz_itemsize));
  1938. }
  1939. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  1940. }
  1941. /*
  1942. * do_key_reread - reread the encryption key file
  1943. */
  1944. static void
  1945. do_key_reread(
  1946. struct sockaddr_storage *srcadr,
  1947. struct interface *inter,
  1948. struct req_pkt *inpkt
  1949. )
  1950. {
  1951. rereadkeys();
  1952. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  1953. }
  1954. /*
  1955. * trust_key - make one or more keys trusted
  1956. */
  1957. static void
  1958. trust_key(
  1959. struct sockaddr_storage *srcadr,
  1960. struct interface *inter,
  1961. struct req_pkt *inpkt
  1962. )
  1963. {
  1964. do_trustkey(srcadr, inter, inpkt, 1);
  1965. }
  1966. /*
  1967. * untrust_key - make one or more keys untrusted
  1968. */
  1969. static void
  1970. untrust_key(
  1971. struct sockaddr_storage *srcadr,
  1972. struct interface *inter,
  1973. struct req_pkt *inpkt
  1974. )
  1975. {
  1976. do_trustkey(srcadr, inter, inpkt, 0);
  1977. }
  1978. /*
  1979. * do_trustkey - make keys either trustable or untrustable
  1980. */
  1981. static void
  1982. do_trustkey(
  1983. struct sockaddr_storage *srcadr,
  1984. struct interface *inter,
  1985. struct req_pkt *inpkt,
  1986. u_long trust
  1987. )
  1988. {
  1989. register u_long *kp;
  1990. register int items;
  1991. items = INFO_NITEMS(inpkt->err_nitems);
  1992. kp = (u_long *)inpkt->data;
  1993. while (items-- > 0) {
  1994. authtrust(*kp, trust);
  1995. kp++;
  1996. }
  1997. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  1998. }
  1999. /*
  2000. * get_auth_info - return some stats concerning the authentication module
  2001. */
  2002. static void
  2003. get_auth_info(
  2004. struct sockaddr_storage *srcadr,
  2005. struct interface *inter,
  2006. struct req_pkt *inpkt
  2007. )
  2008. {
  2009. register struct info_auth *ia;
  2010. /*
  2011. * Importations from the authentication module
  2012. */
  2013. extern u_long authnumkeys;
  2014. extern int authnumfreekeys;
  2015. extern u_long authkeylookups;
  2016. extern u_long authkeynotfound;
  2017. extern u_long authencryptions;
  2018. extern u_long authdecryptions;
  2019. extern u_long authkeyuncached;
  2020. extern u_long authkeyexpired;
  2021. ia = (struct info_auth *)prepare_pkt(srcadr, inter, inpkt,
  2022. sizeof(struct info_auth));
  2023. ia->numkeys = htonl((u_int32)authnumkeys);
  2024. ia->numfreekeys = htonl((u_int32)authnumfreekeys);
  2025. ia->keylookups = htonl((u_int32)authkeylookups);
  2026. ia->keynotfound = htonl((u_int32)authkeynotfound);
  2027. ia->encryptions = htonl((u_int32)authencryptions);
  2028. ia->decryptions = htonl((u_int32)authdecryptions);
  2029. ia->keyuncached = htonl((u_int32)authkeyuncached);
  2030. ia->expired = htonl((u_int32)authkeyexpired);
  2031. ia->timereset = htonl((u_int32)(current_time - auth_timereset));
  2032. (void) more_pkt();
  2033. flush_pkt();
  2034. }
  2035. /*
  2036. * reset_auth_stats - reset the authentication stat counters. Done here
  2037. * to keep ntp-isms out of the authentication module
  2038. */
  2039. static void
  2040. reset_auth_stats(void)
  2041. {
  2042. /*
  2043. * Importations from the authentication module
  2044. */
  2045. extern u_long authkeylookups;
  2046. extern u_long authkeynotfound;
  2047. extern u_long authencryptions;
  2048. extern u_long authdecryptions;
  2049. extern u_long authkeyuncached;
  2050. authkeylookups = 0;
  2051. authkeynotfound = 0;
  2052. authencryptions = 0;
  2053. authdecryptions = 0;
  2054. authkeyuncached = 0;
  2055. auth_timereset = current_time;
  2056. }
  2057. /*
  2058. * req_get_traps - return information about current trap holders
  2059. */
  2060. static void
  2061. req_get_traps(
  2062. struct sockaddr_storage *srcadr,
  2063. struct interface *inter,
  2064. struct req_pkt *inpkt
  2065. )
  2066. {
  2067. register struct info_trap *it;
  2068. register struct ctl_trap *tr;
  2069. register int i;
  2070. /*
  2071. * Imported from the control module
  2072. */
  2073. extern struct ctl_trap ctl_trap[];
  2074. extern int num_ctl_traps;
  2075. if (num_ctl_traps == 0) {
  2076. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  2077. return;
  2078. }
  2079. it = (struct info_trap *)prepare_pkt(srcadr, inter, inpkt,
  2080. v6sizeof(struct info_trap));
  2081. for (i = 0, tr = ctl_trap; i < CTL_MAXTRAPS; i++, tr++) {
  2082. if (tr->tr_flags & TRAP_INUSE) {
  2083. if (tr->tr_addr.ss_family == AF_INET) {
  2084. if (tr->tr_localaddr == any_interface)
  2085. it->local_address = 0;
  2086. else
  2087. it->local_address
  2088. = GET_INADDR(tr->tr_localaddr->sin);
  2089. it->trap_address = GET_INADDR(tr->tr_addr);
  2090. if (client_v6_capable)
  2091. it->v6_flag = 0;
  2092. } else {
  2093. if (!client_v6_capable)
  2094. continue;
  2095. it->local_address6
  2096. = GET_INADDR6(tr->tr_localaddr->sin);
  2097. it->trap_address6 = GET_INADDR6(tr->tr_addr);
  2098. it->v6_flag = 1;
  2099. }
  2100. it->trap_port = NSRCPORT(&tr->tr_addr);
  2101. it->sequence = htons(tr->tr_sequence);
  2102. it->settime = htonl((u_int32)(current_time - tr->tr_settime));
  2103. it->origtime = htonl((u_int32)(current_time - tr->tr_origtime));
  2104. it->resets = htonl((u_int32)tr->tr_resets);
  2105. it->flags = htonl((u_int32)tr->tr_flags);
  2106. it = (struct info_trap *)more_pkt();
  2107. }
  2108. }
  2109. flush_pkt();
  2110. }
  2111. /*
  2112. * req_set_trap - configure a trap
  2113. */
  2114. static void
  2115. req_set_trap(
  2116. struct sockaddr_storage *srcadr,
  2117. struct interface *inter,
  2118. struct req_pkt *inpkt
  2119. )
  2120. {
  2121. do_setclr_trap(srcadr, inter, inpkt, 1);
  2122. }
  2123. /*
  2124. * req_clr_trap - unconfigure a trap
  2125. */
  2126. static void
  2127. req_clr_trap(
  2128. struct sockaddr_storage *srcadr,
  2129. struct interface *inter,
  2130. struct req_pkt *inpkt
  2131. )
  2132. {
  2133. do_setclr_trap(srcadr, inter, inpkt, 0);
  2134. }
  2135. /*
  2136. * do_setclr_trap - do the grunge work of (un)configuring a trap
  2137. */
  2138. static void
  2139. do_setclr_trap(
  2140. struct sockaddr_storage *srcadr,
  2141. struct interface *inter,
  2142. struct req_pkt *inpkt,
  2143. int set
  2144. )
  2145. {
  2146. register struct conf_trap *ct;
  2147. register struct interface *linter;
  2148. int res;
  2149. struct sockaddr_storage laddr;
  2150. /*
  2151. * Prepare sockaddr_storage structure
  2152. */
  2153. memset((char *)&laddr, 0, sizeof laddr);
  2154. laddr.ss_family = srcadr->ss_family;
  2155. NSRCPORT(&laddr) = ntohs(NTP_PORT);
  2156. /*
  2157. * Restrict ourselves to one item only. This eliminates
  2158. * the error reporting problem.
  2159. */
  2160. if (INFO_NITEMS(inpkt->err_nitems) > 1) {
  2161. msyslog(LOG_ERR, "do_setclr_trap: err_nitems > 1");
  2162. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  2163. return;
  2164. }
  2165. ct = (struct conf_trap *)inpkt->data;
  2166. /*
  2167. * Look for the local interface. If none, use the default.
  2168. */
  2169. if (ct->local_address == 0) {
  2170. linter = any_interface;
  2171. } else {
  2172. if (laddr.ss_family == AF_INET)
  2173. GET_INADDR(laddr) = ct->local_address;
  2174. else
  2175. GET_INADDR6(laddr) = ct->local_address6;
  2176. linter = findinterface(&laddr);
  2177. if (linter == NULL) {
  2178. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  2179. return;
  2180. }
  2181. }
  2182. if (laddr.ss_family == AF_INET)
  2183. GET_INADDR(laddr) = ct->trap_address;
  2184. else
  2185. GET_INADDR6(laddr) = ct->trap_address6;
  2186. if (ct->trap_port != 0)
  2187. NSRCPORT(&laddr) = ct->trap_port;
  2188. else
  2189. NSRCPORT(&laddr) = htons(TRAPPORT);
  2190. if (set) {
  2191. res = ctlsettrap(&laddr, linter, 0,
  2192. INFO_VERSION(inpkt->rm_vn_mode));
  2193. } else {
  2194. res = ctlclrtrap(&laddr, linter, 0);
  2195. }
  2196. if (!res) {
  2197. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  2198. } else {
  2199. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  2200. }
  2201. return;
  2202. }
  2203. /*
  2204. * set_request_keyid - set the keyid used to authenticate requests
  2205. */
  2206. static void
  2207. set_request_keyid(
  2208. struct sockaddr_storage *srcadr,
  2209. struct interface *inter,
  2210. struct req_pkt *inpkt
  2211. )
  2212. {
  2213. keyid_t keyid;
  2214. /*
  2215. * Restrict ourselves to one item only.
  2216. */
  2217. if (INFO_NITEMS(inpkt->err_nitems) > 1) {
  2218. msyslog(LOG_ERR, "set_request_keyid: err_nitems > 1");
  2219. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  2220. return;
  2221. }
  2222. keyid = ntohl(*((u_int32 *)(inpkt->data)));
  2223. info_auth_keyid = keyid;
  2224. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  2225. }
  2226. /*
  2227. * set_control_keyid - set the keyid used to authenticate requests
  2228. */
  2229. static void
  2230. set_control_keyid(
  2231. struct sockaddr_storage *srcadr,
  2232. struct interface *inter,
  2233. struct req_pkt *inpkt
  2234. )
  2235. {
  2236. keyid_t keyid;
  2237. extern keyid_t ctl_auth_keyid;
  2238. /*
  2239. * Restrict ourselves to one item only.
  2240. */
  2241. if (INFO_NITEMS(inpkt->err_nitems) > 1) {
  2242. msyslog(LOG_ERR, "set_control_keyid: err_nitems > 1");
  2243. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  2244. return;
  2245. }
  2246. keyid = ntohl(*((u_int32 *)(inpkt->data)));
  2247. ctl_auth_keyid = keyid;
  2248. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  2249. }
  2250. /*
  2251. * get_ctl_stats - return some stats concerning the control message module
  2252. */
  2253. static void
  2254. get_ctl_stats(
  2255. struct sockaddr_storage *srcadr,
  2256. struct interface *inter,
  2257. struct req_pkt *inpkt
  2258. )
  2259. {
  2260. register struct info_control *ic;
  2261. /*
  2262. * Importations from the control module
  2263. */
  2264. extern u_long ctltimereset;
  2265. extern u_long numctlreq;
  2266. extern u_long numctlbadpkts;
  2267. extern u_long numctlresponses;
  2268. extern u_long numctlfrags;
  2269. extern u_long numctlerrors;
  2270. extern u_long numctltooshort;
  2271. extern u_long numctlinputresp;
  2272. extern u_long numctlinputfrag;
  2273. extern u_long numctlinputerr;
  2274. extern u_long numctlbadoffset;
  2275. extern u_long numctlbadversion;
  2276. extern u_long numctldatatooshort;
  2277. extern u_long numctlbadop;
  2278. extern u_long numasyncmsgs;
  2279. ic = (struct info_control *)prepare_pkt(srcadr, inter, inpkt,
  2280. sizeof(struct info_control));
  2281. ic->ctltimereset = htonl((u_int32)(current_time - ctltimereset));
  2282. ic->numctlreq = htonl((u_int32)numctlreq);
  2283. ic->numctlbadpkts = htonl((u_int32)numctlbadpkts);
  2284. ic->numctlresponses = htonl((u_int32)numctlresponses);
  2285. ic->numctlfrags = htonl((u_int32)numctlfrags);
  2286. ic->numctlerrors = htonl((u_int32)numctlerrors);
  2287. ic->numctltooshort = htonl((u_int32)numctltooshort);
  2288. ic->numctlinputresp = htonl((u_int32)numctlinputresp);
  2289. ic->numctlinputfrag = htonl((u_int32)numctlinputfrag);
  2290. ic->numctlinputerr = htonl((u_int32)numctlinputerr);
  2291. ic->numctlbadoffset = htonl((u_int32)numctlbadoffset);
  2292. ic->numctlbadversion = htonl((u_int32)numctlbadversion);
  2293. ic->numctldatatooshort = htonl((u_int32)numctldatatooshort);
  2294. ic->numctlbadop = htonl((u_int32)numctlbadop);
  2295. ic->numasyncmsgs = htonl((u_int32)numasyncmsgs);
  2296. (void) more_pkt();
  2297. flush_pkt();
  2298. }
  2299. #ifdef KERNEL_PLL
  2300. /*
  2301. * get_kernel_info - get kernel pll/pps information
  2302. */
  2303. static void
  2304. get_kernel_info(
  2305. struct sockaddr_storage *srcadr,
  2306. struct interface *inter,
  2307. struct req_pkt *inpkt
  2308. )
  2309. {
  2310. register struct info_kernel *ik;
  2311. struct timex ntx;
  2312. if (!pll_control) {
  2313. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  2314. return;
  2315. }
  2316. memset((char *)&ntx, 0, sizeof(ntx));
  2317. if (ntp_adjtime(&ntx) < 0)
  2318. msyslog(LOG_ERR, "get_kernel_info: ntp_adjtime() failed: %m");
  2319. ik = (struct info_kernel *)prepare_pkt(srcadr, inter, inpkt,
  2320. sizeof(struct info_kernel));
  2321. /*
  2322. * pll variables
  2323. */
  2324. ik->offset = htonl((u_int32)ntx.offset);
  2325. ik->freq = htonl((u_int32)ntx.freq);
  2326. ik->maxerror = htonl((u_int32)ntx.maxerror);
  2327. ik->esterror = htonl((u_int32)ntx.esterror);
  2328. ik->status = htons(ntx.status);
  2329. ik->constant = htonl((u_int32)ntx.constant);
  2330. ik->precision = htonl((u_int32)ntx.precision);
  2331. ik->tolerance = htonl((u_int32)ntx.tolerance);
  2332. /*
  2333. * pps variables
  2334. */
  2335. ik->ppsfreq = htonl((u_int32)ntx.ppsfreq);
  2336. ik->jitter = htonl((u_int32)ntx.jitter);
  2337. ik->shift = htons(ntx.shift);
  2338. ik->stabil = htonl((u_int32)ntx.stabil);
  2339. ik->jitcnt = htonl((u_int32)ntx.jitcnt);
  2340. ik->calcnt = htonl((u_int32)ntx.calcnt);
  2341. ik->errcnt = htonl((u_int32)ntx.errcnt);
  2342. ik->stbcnt = htonl((u_int32)ntx.stbcnt);
  2343. (void) more_pkt();
  2344. flush_pkt();
  2345. }
  2346. #endif /* KERNEL_PLL */
  2347. #ifdef REFCLOCK
  2348. /*
  2349. * get_clock_info - get info about a clock
  2350. */
  2351. static void
  2352. get_clock_info(
  2353. struct sockaddr_storage *srcadr,
  2354. struct interface *inter,
  2355. struct req_pkt *inpkt
  2356. )
  2357. {
  2358. register struct info_clock *ic;
  2359. register u_int32 *clkaddr;
  2360. register int items;
  2361. struct refclockstat clock_stat;
  2362. struct sockaddr_storage addr;
  2363. struct sockaddr_in tmp_clock;
  2364. l_fp ltmp;
  2365. memset((char *)&addr, 0, sizeof addr);
  2366. addr.ss_family = AF_INET;
  2367. #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
  2368. addr.ss_len = SOCKLEN(&addr);
  2369. #endif
  2370. NSRCPORT(&addr) = htons(NTP_PORT);
  2371. items = INFO_NITEMS(inpkt->err_nitems);
  2372. clkaddr = (u_int32 *) inpkt->data;
  2373. ic = (struct info_clock *)prepare_pkt(srcadr, inter, inpkt,
  2374. sizeof(struct info_clock));
  2375. while (items-- > 0) {
  2376. tmp_clock.sin_addr.s_addr = *clkaddr++;
  2377. CAST_V4(addr)->sin_addr = tmp_clock.sin_addr;
  2378. if (!ISREFCLOCKADR(&tmp_clock) ||
  2379. findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
  2380. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  2381. return;
  2382. }
  2383. clock_stat.kv_list = (struct ctl_var *)0;
  2384. refclock_control(&addr, (struct refclockstat *)0, &clock_stat);
  2385. ic->clockadr = tmp_clock.sin_addr.s_addr;
  2386. ic->type = clock_stat.type;
  2387. ic->flags = clock_stat.flags;
  2388. ic->lastevent = clock_stat.lastevent;
  2389. ic->currentstatus = clock_stat.currentstatus;
  2390. ic->polls = htonl((u_int32)clock_stat.polls);
  2391. ic->noresponse = htonl((u_int32)clock_stat.noresponse);
  2392. ic->badformat = htonl((u_int32)clock_stat.badformat);
  2393. ic->baddata = htonl((u_int32)clock_stat.baddata);
  2394. ic->timestarted = htonl((u_int32)clock_stat.timereset);
  2395. DTOLFP(clock_stat.fudgetime1, &ltmp);
  2396. HTONL_FP(&ltmp, &ic->fudgetime1);
  2397. DTOLFP(clock_stat.fudgetime2, &ltmp);
  2398. HTONL_FP(&ltmp, &ic->fudgetime2);
  2399. ic->fudgeval1 = htonl((u_int32)clock_stat.fudgeval1);
  2400. ic->fudgeval2 = htonl((u_int32)clock_stat.fudgeval2);
  2401. free_varlist(clock_stat.kv_list);
  2402. ic = (struct info_clock *)more_pkt();
  2403. }
  2404. flush_pkt();
  2405. }
  2406. /*
  2407. * set_clock_fudge - get a clock's fudge factors
  2408. */
  2409. static void
  2410. set_clock_fudge(
  2411. struct sockaddr_storage *srcadr,
  2412. struct interface *inter,
  2413. struct req_pkt *inpkt
  2414. )
  2415. {
  2416. register struct conf_fudge *cf;
  2417. register int items;
  2418. struct refclockstat clock_stat;
  2419. struct sockaddr_storage addr;
  2420. struct sockaddr_in tmp_clock;
  2421. l_fp ltmp;
  2422. memset((char *)&addr, 0, sizeof addr);
  2423. memset((char *)&clock_stat, 0, sizeof clock_stat);
  2424. items = INFO_NITEMS(inpkt->err_nitems);
  2425. cf = (struct conf_fudge *) inpkt->data;
  2426. while (items-- > 0) {
  2427. tmp_clock.sin_addr.s_addr = cf->clockadr;
  2428. *CAST_V4(addr) = tmp_clock;
  2429. addr.ss_family = AF_INET;
  2430. #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
  2431. addr.ss_len = SOCKLEN(&addr);
  2432. #endif
  2433. NSRCPORT(&addr) = htons(NTP_PORT);
  2434. if (!ISREFCLOCKADR(&tmp_clock) ||
  2435. findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
  2436. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  2437. return;
  2438. }
  2439. switch(ntohl(cf->which)) {
  2440. case FUDGE_TIME1:
  2441. NTOHL_FP(&cf->fudgetime, &ltmp);
  2442. LFPTOD(&ltmp, clock_stat.fudgetime1);
  2443. clock_stat.haveflags = CLK_HAVETIME1;
  2444. break;
  2445. case FUDGE_TIME2:
  2446. NTOHL_FP(&cf->fudgetime, &ltmp);
  2447. LFPTOD(&ltmp, clock_stat.fudgetime2);
  2448. clock_stat.haveflags = CLK_HAVETIME2;
  2449. break;
  2450. case FUDGE_VAL1:
  2451. clock_stat.fudgeval1 = ntohl(cf->fudgeval_flags);
  2452. clock_stat.haveflags = CLK_HAVEVAL1;
  2453. break;
  2454. case FUDGE_VAL2:
  2455. clock_stat.fudgeval2 = ntohl(cf->fudgeval_flags);
  2456. clock_stat.haveflags = CLK_HAVEVAL2;
  2457. break;
  2458. case FUDGE_FLAGS:
  2459. clock_stat.flags = (u_char) (ntohl(cf->fudgeval_flags) & 0xf);
  2460. clock_stat.haveflags =
  2461. (CLK_HAVEFLAG1|CLK_HAVEFLAG2|CLK_HAVEFLAG3|CLK_HAVEFLAG4);
  2462. break;
  2463. default:
  2464. msyslog(LOG_ERR, "set_clock_fudge: default!");
  2465. req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
  2466. return;
  2467. }
  2468. refclock_control(&addr, &clock_stat, (struct refclockstat *)0);
  2469. }
  2470. req_ack(srcadr, inter, inpkt, INFO_OKAY);
  2471. }
  2472. #endif
  2473. #ifdef REFCLOCK
  2474. /*
  2475. * get_clkbug_info - get debugging info about a clock
  2476. */
  2477. static void
  2478. get_clkbug_info(
  2479. struct sockaddr_storage *srcadr,
  2480. struct interface *inter,
  2481. struct req_pkt *inpkt
  2482. )
  2483. {
  2484. register int i;
  2485. register struct info_clkbug *ic;
  2486. register u_int32 *clkaddr;
  2487. register int items;
  2488. struct refclockbug bug;
  2489. struct sockaddr_storage addr;
  2490. struct sockaddr_in tmp_clock;
  2491. memset((char *)&addr, 0, sizeof addr);
  2492. addr.ss_family = AF_INET;
  2493. #ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
  2494. addr.ss_len = SOCKLEN(&addr);
  2495. #endif
  2496. NSRCPORT(&addr) = htons(NTP_PORT);
  2497. items = INFO_NITEMS(inpkt->err_nitems);
  2498. clkaddr = (u_int32 *) inpkt->data;
  2499. ic = (struct info_clkbug *)prepare_pkt(srcadr, inter, inpkt,
  2500. sizeof(struct info_clkbug));
  2501. while (items-- > 0) {
  2502. tmp_clock.sin_addr.s_addr = *clkaddr++;
  2503. GET_INADDR(addr) = tmp_clock.sin_addr.s_addr;
  2504. if (!ISREFCLOCKADR(&tmp_clock) ||
  2505. findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
  2506. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  2507. return;
  2508. }
  2509. memset((char *)&bug, 0, sizeof bug);
  2510. refclock_buginfo(&addr, &bug);
  2511. if (bug.nvalues == 0 && bug.ntimes == 0) {
  2512. req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
  2513. return;
  2514. }
  2515. ic->clockadr = tmp_clock.sin_addr.s_addr;
  2516. i = bug.nvalues;
  2517. if (i > NUMCBUGVALUES)
  2518. i = NUMCBUGVALUES;
  2519. ic->nvalues = (u_char)i;
  2520. ic->svalues = htons((u_short) (bug.svalues & ((1<<i)-1)));
  2521. while (--i >= 0)
  2522. ic->values[i] = htonl(bug.values[i]);
  2523. i = bug.ntimes;
  2524. if (i > NUMCBUGTIMES)
  2525. i = NUMCBUGTIMES;
  2526. ic->ntimes = (u_char)i;
  2527. ic->stimes = htonl(bug.stimes);
  2528. while (--i >= 0) {
  2529. HTONL_FP(&bug.times[i], &ic->times[i]);
  2530. }
  2531. ic = (struct info_clkbug *)more_pkt();
  2532. }
  2533. flush_pkt();
  2534. }
  2535. #endif
  2536. /*
  2537. * receiver of interface structures
  2538. */
  2539. static void
  2540. fill_info_if_stats(void *data, interface_info_t *interface_info)
  2541. {
  2542. struct info_if_stats **ifsp = (struct info_if_stats **)data;
  2543. struct info_if_stats *ifs = *ifsp;
  2544. struct interface *interface = interface_info->interface;
  2545. memset((char*)ifs, 0, sizeof(*ifs));
  2546. if (interface->sin.ss_family == AF_INET6) {
  2547. if (!client_v6_capable) {
  2548. return;
  2549. }
  2550. ifs->v6_flag = 1;
  2551. memcpy((char *)&ifs->unaddr.addr6, (char *)&CAST_V6(interface->sin)->sin6_addr, sizeof(struct in6_addr));
  2552. memcpy((char *)&ifs->unbcast.addr6, (char *)&CAST_V6(interface->bcast)->sin6_addr, sizeof(struct in6_addr));
  2553. memcpy((char *)&ifs->unmask.addr6, (char *)&CAST_V6(interface->mask)->sin6_addr, sizeof(struct in6_addr));
  2554. } else {
  2555. ifs->v6_flag = 0;
  2556. memcpy((char *)&ifs->unaddr.addr, (char *)&CAST_V4(interface->sin)->sin_addr, sizeof(struct in_addr));
  2557. memcpy((char *)&ifs->unbcast.addr, (char *)&CAST_V4(interface->bcast)->sin_addr, sizeof(struct in_addr));
  2558. memcpy((char *)&ifs->unmask.addr, (char *)&CAST_V4(interface->mask)->sin_addr, sizeof(struct in_addr));
  2559. }
  2560. ifs->v6_flag = htonl(ifs->v6_flag);
  2561. strcpy(ifs->name, interface->name);
  2562. ifs->family = htons(interface->family);
  2563. ifs->flags = htonl(interface->flags);
  2564. ifs->last_ttl = htonl(interface->last_ttl);
  2565. ifs->num_mcast = htonl(interface->num_mcast);
  2566. ifs->received = htonl(interface->received);
  2567. ifs->sent = htonl(interface->sent);
  2568. ifs->notsent = htonl(interface->notsent);
  2569. ifs->scopeid = htonl(interface->scopeid);
  2570. ifs->ifindex = htonl(interface->ifindex);
  2571. ifs->ifnum = htonl(interface->ifnum);
  2572. ifs->uptime = htonl(current_time - interface->starttime);
  2573. ifs->ignore_packets = interface->ignore_packets;
  2574. ifs->peercnt = htonl(interface->peercnt);
  2575. ifs->action = interface_info->action;
  2576. *ifsp = (struct info_if_stats *)more_pkt();
  2577. }
  2578. /*
  2579. * get_if_stats - get interface statistics
  2580. */
  2581. static void
  2582. get_if_stats(
  2583. struct sockaddr_storage *srcadr,
  2584. struct interface *inter,
  2585. struct req_pkt *inpkt
  2586. )
  2587. {
  2588. struct info_if_stats *ifs;
  2589. DPRINTF(3, ("wants interface statistics\n"));
  2590. ifs = (struct info_if_stats *)prepare_pkt(srcadr, inter, inpkt,
  2591. v6sizeof(struct info_if_stats));
  2592. interface_enumerate(fill_info_if_stats, &ifs);
  2593. flush_pkt();
  2594. }
  2595. static void
  2596. do_if_reload(
  2597. struct sockaddr_storage *srcadr,
  2598. struct interface *inter,
  2599. struct req_pkt *inpkt
  2600. )
  2601. {
  2602. struct info_if_stats *ifs;
  2603. DPRINTF(3, ("wants interface reload\n"));
  2604. ifs = (struct info_if_stats *)prepare_pkt(srcadr, inter, inpkt,
  2605. v6sizeof(struct info_if_stats));
  2606. interface_update(fill_info_if_stats, &ifs);
  2607. flush_pkt();
  2608. }