1: /*
2: * ntp_control.c - respond to control messages and send async traps
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_refclock.h"
12: #include "ntp_control.h"
13: #include "ntp_unixtime.h"
14: #include "ntp_stdlib.h"
15: #include "ntp_config.h"
16: #include "ntp_crypto.h"
17: #include "ntp_assert.h"
18:
19: #include <stdio.h>
20: #include <ctype.h>
21: #include <signal.h>
22: #include <sys/stat.h>
23:
24: #ifdef HAVE_NETINET_IN_H
25: #include <netinet/in.h>
26: #endif
27: #include <arpa/inet.h>
28:
29: /*
30: * Structure to hold request procedure information
31: */
32:
33: struct ctl_proc {
34: short control_code; /* defined request code */
35: #define NO_REQUEST (-1)
36: u_short flags; /* flags word */
37: /* Only one flag. Authentication required or not. */
38: #define NOAUTH 0
39: #define AUTH 1
40: void (*handler) (struct recvbuf *, int); /* handle request */
41: };
42:
43:
44: /*
45: * Request processing routines
46: */
47: static void ctl_error (int);
48: #ifdef REFCLOCK
49: static u_short ctlclkstatus (struct refclockstat *);
50: #endif
51: static void ctl_flushpkt (int);
52: static void ctl_putdata (const char *, unsigned int, int);
53: static void ctl_putstr (const char *, const char *,
54: unsigned int);
55: static void ctl_putdbl (const char *, double);
56: static void ctl_putuint (const char *, u_long);
57: static void ctl_puthex (const char *, u_long);
58: static void ctl_putint (const char *, long);
59: static void ctl_putts (const char *, l_fp *);
60: static void ctl_putadr (const char *, u_int32,
61: sockaddr_u *);
62: static void ctl_putrefid (const char *, u_int32);
63: static void ctl_putarray (const char *, double *, int);
64: static void ctl_putsys (int);
65: static void ctl_putpeer (int, struct peer *);
66: static void ctl_putfs (const char *, tstamp_t);
67: #ifdef REFCLOCK
68: static void ctl_putclock (int, struct refclockstat *, int);
69: #endif /* REFCLOCK */
70: static struct ctl_var *ctl_getitem (struct ctl_var *, char **);
71: static u_long count_var (struct ctl_var *);
72: static void control_unspec (struct recvbuf *, int);
73: static void read_status (struct recvbuf *, int);
74: static void read_variables (struct recvbuf *, int);
75: static void write_variables (struct recvbuf *, int);
76: static void read_clock_status (struct recvbuf *, int);
77: static void write_clock_status (struct recvbuf *, int);
78: static void set_trap (struct recvbuf *, int);
79: static void unset_trap (struct recvbuf *, int);
80: static void configure (struct recvbuf *, int);
81: static void save_config (struct recvbuf *, int);
82: static struct ctl_trap *ctlfindtrap (sockaddr_u *,
83: struct interface *);
84:
85: static struct ctl_proc control_codes[] = {
86: { CTL_OP_UNSPEC, NOAUTH, control_unspec },
87: { CTL_OP_READSTAT, NOAUTH, read_status },
88: { CTL_OP_READVAR, NOAUTH, read_variables },
89: { CTL_OP_WRITEVAR, AUTH, write_variables },
90: { CTL_OP_READCLOCK, NOAUTH, read_clock_status },
91: { CTL_OP_WRITECLOCK, NOAUTH, write_clock_status },
92: { CTL_OP_SETTRAP, NOAUTH, set_trap },
93: { CTL_OP_UNSETTRAP, NOAUTH, unset_trap },
94: { CTL_OP_SAVECONFIG, AUTH, save_config },
95: { CTL_OP_CONFIGURE, AUTH, configure },
96: { NO_REQUEST, 0 }
97: };
98:
99: /*
100: * System variable values. The array can be indexed by the variable
101: * index to find the textual name.
102: */
103: static struct ctl_var sys_var[] = {
104: { 0, PADDING, "" }, /* 0 */
105: { CS_LEAP, RW, "leap" }, /* 1 */
106: { CS_STRATUM, RO, "stratum" }, /* 2 */
107: { CS_PRECISION, RO, "precision" }, /* 3 */
108: { CS_ROOTDELAY, RO, "rootdelay" }, /* 4 */
109: { CS_ROOTDISPERSION, RO, "rootdisp" }, /* 5 */
110: { CS_REFID, RO, "refid" }, /* 6 */
111: { CS_REFTIME, RO, "reftime" }, /* 7 */
112: { CS_POLL, RO, "tc" }, /* 8 */
113: { CS_PEERID, RO, "peer" }, /* 9 */
114: { CS_OFFSET, RO, "offset" }, /* 10 */
115: { CS_DRIFT, RO, "frequency" }, /* 11 */
116: { CS_JITTER, RO, "sys_jitter" }, /* 12 */
117: { CS_ERROR, RO, "clk_jitter" }, /* 13 */
118: { CS_CLOCK, RO, "clock" }, /* 14 */
119: { CS_PROCESSOR, RO, "processor" }, /* 15 */
120: { CS_SYSTEM, RO, "system" }, /* 16 */
121: { CS_VERSION, RO, "version" }, /* 17 */
122: { CS_STABIL, RO, "clk_wander" }, /* 18 */
123: { CS_VARLIST, RO, "sys_var_list" }, /* 19 */
124: { CS_TAI, RO, "tai" }, /* 20 */
125: { CS_LEAPTAB, RO, "leapsec" }, /* 21 */
126: { CS_LEAPEND, RO, "expire" }, /* 22 */
127: { CS_RATE, RO, "mintc" }, /* 23 */
128: #ifdef OPENSSL
129: { CS_FLAGS, RO, "flags" }, /* 24 */
130: { CS_HOST, RO, "host" }, /* 25 */
131: { CS_PUBLIC, RO, "update" }, /* 26 */
132: { CS_CERTIF, RO, "cert" }, /* 27 */
133: { CS_SIGNATURE, RO, "signature" }, /* 28 */
134: { CS_REVTIME, RO, "until" }, /* 29 */
135: { CS_GROUP, RO, "group" }, /* 30 */
136: { CS_DIGEST, RO, "digest" }, /* 31 */
137: #endif /* OPENSSL */
138: { 0, EOV, "" } /* 24/3 2*/
139: };
140:
141: static struct ctl_var *ext_sys_var = (struct ctl_var *)0;
142:
143: /*
144: * System variables we print by default (in fuzzball order,
145: * more-or-less)
146: */
147: static u_char def_sys_var[] = {
148: CS_VERSION,
149: CS_PROCESSOR,
150: CS_SYSTEM,
151: CS_LEAP,
152: CS_STRATUM,
153: CS_PRECISION,
154: CS_ROOTDELAY,
155: CS_ROOTDISPERSION,
156: CS_REFID,
157: CS_REFTIME,
158: CS_CLOCK,
159: CS_PEERID,
160: CS_POLL,
161: CS_RATE,
162: CS_OFFSET,
163: CS_DRIFT,
164: CS_JITTER,
165: CS_ERROR,
166: CS_STABIL,
167: CS_TAI,
168: CS_LEAPTAB,
169: CS_LEAPEND,
170: #ifdef OPENSSL
171: CS_HOST,
172: CS_GROUP,
173: CS_FLAGS,
174: CS_DIGEST,
175: CS_SIGNATURE,
176: CS_PUBLIC,
177: CS_CERTIF,
178: #endif /* OPENSSL */
179: 0
180: };
181:
182:
183: /*
184: * Peer variable list
185: */
186: static struct ctl_var peer_var[] = {
187: { 0, PADDING, "" }, /* 0 */
188: { CP_CONFIG, RO, "config" }, /* 1 */
189: { CP_AUTHENABLE, RO, "authenable" }, /* 2 */
190: { CP_AUTHENTIC, RO, "authentic" }, /* 3 */
191: { CP_SRCADR, RO, "srcadr" }, /* 4 */
192: { CP_SRCPORT, RO, "srcport" }, /* 5 */
193: { CP_DSTADR, RO, "dstadr" }, /* 6 */
194: { CP_DSTPORT, RO, "dstport" }, /* 7 */
195: { CP_LEAP, RO, "leap" }, /* 8 */
196: { CP_HMODE, RO, "hmode" }, /* 9 */
197: { CP_STRATUM, RO, "stratum" }, /* 10 */
198: { CP_PPOLL, RO, "ppoll" }, /* 11 */
199: { CP_HPOLL, RO, "hpoll" }, /* 12 */
200: { CP_PRECISION, RO, "precision" }, /* 13 */
201: { CP_ROOTDELAY, RO, "rootdelay" }, /* 14 */
202: { CP_ROOTDISPERSION, RO, "rootdisp" }, /* 15 */
203: { CP_REFID, RO, "refid" }, /* 16 */
204: { CP_REFTIME, RO, "reftime" }, /* 17 */
205: { CP_ORG, RO, "org" }, /* 18 */
206: { CP_REC, RO, "rec" }, /* 19 */
207: { CP_XMT, RO, "xleave" }, /* 20 */
208: { CP_REACH, RO, "reach" }, /* 21 */
209: { CP_UNREACH, RO, "unreach" }, /* 22 */
210: { CP_TIMER, RO, "timer" }, /* 23 */
211: { CP_DELAY, RO, "delay" }, /* 24 */
212: { CP_OFFSET, RO, "offset" }, /* 25 */
213: { CP_JITTER, RO, "jitter" }, /* 26 */
214: { CP_DISPERSION, RO, "dispersion" }, /* 27 */
215: { CP_KEYID, RO, "keyid" }, /* 28 */
216: { CP_FILTDELAY, RO, "filtdelay=" }, /* 29 */
217: { CP_FILTOFFSET, RO, "filtoffset=" }, /* 30 */
218: { CP_PMODE, RO, "pmode" }, /* 31 */
219: { CP_RECEIVED, RO, "received"}, /* 32 */
220: { CP_SENT, RO, "sent" }, /* 33 */
221: { CP_FILTERROR, RO, "filtdisp=" }, /* 34 */
222: { CP_FLASH, RO, "flash" }, /* 35 */
223: { CP_TTL, RO, "ttl" }, /* 36 */
224: { CP_VARLIST, RO, "peer_var_list" }, /* 37 */
225: { CP_IN, RO, "in" }, /* 38 */
226: { CP_OUT, RO, "out" }, /* 39 */
227: { CP_RATE, RO, "headway" }, /* 40 */
228: { CP_BIAS, RO, "bias" }, /* 41 */
229: #ifdef OPENSSL
230: { CP_FLAGS, RO, "flags" }, /* 42 */
231: { CP_HOST, RO, "host" }, /* 43 */
232: { CP_VALID, RO, "valid" }, /* 44 */
233: { CP_INITSEQ, RO, "initsequence" }, /* 45 */
234: { CP_INITKEY, RO, "initkey" }, /* 46 */
235: { CP_INITTSP, RO, "timestamp" }, /* 47 */
236: { CP_SIGNATURE, RO, "signature" }, /* 48 */
237: #endif /* OPENSSL */
238: { 0, EOV, "" } /* 42/49 */
239: };
240:
241:
242: /*
243: * Peer variables we print by default
244: */
245: static u_char def_peer_var[] = {
246: CP_SRCADR,
247: CP_SRCPORT,
248: CP_DSTADR,
249: CP_DSTPORT,
250: CP_OUT,
251: CP_IN,
252: CP_LEAP,
253: CP_STRATUM,
254: CP_PRECISION,
255: CP_ROOTDELAY,
256: CP_ROOTDISPERSION,
257: CP_REFID,
258: CP_REFTIME,
259: CP_REC,
260: CP_REACH,
261: CP_UNREACH,
262: CP_HMODE,
263: CP_PMODE,
264: CP_HPOLL,
265: CP_PPOLL,
266: CP_RATE,
267: CP_FLASH,
268: CP_KEYID,
269: CP_TTL,
270: CP_OFFSET,
271: CP_DELAY,
272: CP_DISPERSION,
273: CP_JITTER,
274: CP_XMT,
275: CP_BIAS,
276: CP_FILTDELAY,
277: CP_FILTOFFSET,
278: CP_FILTERROR,
279: #ifdef OPENSSL
280: CP_HOST,
281: CP_FLAGS,
282: CP_SIGNATURE,
283: CP_VALID,
284: CP_INITSEQ,
285: #endif /* OPENSSL */
286: 0
287: };
288:
289:
290: #ifdef REFCLOCK
291: /*
292: * Clock variable list
293: */
294: static struct ctl_var clock_var[] = {
295: { 0, PADDING, "" }, /* 0 */
296: { CC_TYPE, RO, "type" }, /* 1 */
297: { CC_TIMECODE, RO, "timecode" }, /* 2 */
298: { CC_POLL, RO, "poll" }, /* 3 */
299: { CC_NOREPLY, RO, "noreply" }, /* 4 */
300: { CC_BADFORMAT, RO, "badformat" }, /* 5 */
301: { CC_BADDATA, RO, "baddata" }, /* 6 */
302: { CC_FUDGETIME1, RO, "fudgetime1" }, /* 7 */
303: { CC_FUDGETIME2, RO, "fudgetime2" }, /* 8 */
304: { CC_FUDGEVAL1, RO, "stratum" }, /* 9 */
305: { CC_FUDGEVAL2, RO, "refid" }, /* 10 */
306: { CC_FLAGS, RO, "flags" }, /* 11 */
307: { CC_DEVICE, RO, "device" }, /* 12 */
308: { CC_VARLIST, RO, "clock_var_list" }, /* 13 */
309: { 0, EOV, "" } /* 14 */
310: };
311:
312:
313: /*
314: * Clock variables printed by default
315: */
316: static u_char def_clock_var[] = {
317: CC_DEVICE,
318: CC_TYPE, /* won't be output if device = known */
319: CC_TIMECODE,
320: CC_POLL,
321: CC_NOREPLY,
322: CC_BADFORMAT,
323: CC_BADDATA,
324: CC_FUDGETIME1,
325: CC_FUDGETIME2,
326: CC_FUDGEVAL1,
327: CC_FUDGEVAL2,
328: CC_FLAGS,
329: 0
330: };
331: #endif
332:
333:
334: /*
335: * System and processor definitions.
336: */
337: #ifndef HAVE_UNAME
338: # ifndef STR_SYSTEM
339: # define STR_SYSTEM "UNIX"
340: # endif
341: # ifndef STR_PROCESSOR
342: # define STR_PROCESSOR "unknown"
343: # endif
344:
345: static char str_system[] = STR_SYSTEM;
346: static char str_processor[] = STR_PROCESSOR;
347: #else
348: # include <sys/utsname.h>
349: static struct utsname utsnamebuf;
350: #endif /* HAVE_UNAME */
351:
352: /*
353: * Trap structures. We only allow a few of these, and send a copy of
354: * each async message to each live one. Traps time out after an hour, it
355: * is up to the trap receipient to keep resetting it to avoid being
356: * timed out.
357: */
358: /* ntp_request.c */
359: struct ctl_trap ctl_trap[CTL_MAXTRAPS];
360: int num_ctl_traps;
361:
362: /*
363: * Type bits, for ctlsettrap() call.
364: */
365: #define TRAP_TYPE_CONFIG 0 /* used by configuration code */
366: #define TRAP_TYPE_PRIO 1 /* priority trap */
367: #define TRAP_TYPE_NONPRIO 2 /* nonpriority trap */
368:
369:
370: /*
371: * List relating reference clock types to control message time sources.
372: * Index by the reference clock type. This list will only be used iff
373: * the reference clock driver doesn't set peer->sstclktype to something
374: * different than CTL_SST_TS_UNSPEC.
375: */
376: static u_char clocktypes[] = {
377: CTL_SST_TS_NTP, /* REFCLK_NONE (0) */
378: CTL_SST_TS_LOCAL, /* REFCLK_LOCALCLOCK (1) */
379: CTL_SST_TS_UHF, /* deprecated REFCLK_GPS_TRAK (2) */
380: CTL_SST_TS_HF, /* REFCLK_WWV_PST (3) */
381: CTL_SST_TS_LF, /* REFCLK_WWVB_SPECTRACOM (4) */
382: CTL_SST_TS_UHF, /* REFCLK_TRUETIME (5) */
383: CTL_SST_TS_UHF, /* REFCLK_GOES_TRAK (6) IRIG_AUDIO? */
384: CTL_SST_TS_HF, /* REFCLK_CHU (7) */
385: CTL_SST_TS_LF, /* REFCLOCK_PARSE (default) (8) */
386: CTL_SST_TS_LF, /* REFCLK_GPS_MX4200 (9) */
387: CTL_SST_TS_UHF, /* REFCLK_GPS_AS2201 (10) */
388: CTL_SST_TS_UHF, /* REFCLK_GPS_ARBITER (11) */
389: CTL_SST_TS_UHF, /* REFCLK_IRIG_TPRO (12) */
390: CTL_SST_TS_ATOM, /* REFCLK_ATOM_LEITCH (13) */
391: CTL_SST_TS_LF, /* deprecated REFCLK_MSF_EES (14) */
392: CTL_SST_TS_NTP, /* not used (15) */
393: CTL_SST_TS_UHF, /* REFCLK_IRIG_BANCOMM (16) */
394: CTL_SST_TS_UHF, /* REFCLK_GPS_DATU (17) */
395: CTL_SST_TS_TELEPHONE, /* REFCLK_NIST_ACTS (18) */
396: CTL_SST_TS_HF, /* REFCLK_WWV_HEATH (19) */
397: CTL_SST_TS_UHF, /* REFCLK_GPS_NMEA (20) */
398: CTL_SST_TS_UHF, /* REFCLK_GPS_VME (21) */
399: CTL_SST_TS_ATOM, /* REFCLK_ATOM_PPS (22) */
400: CTL_SST_TS_NTP, /* not used (23) */
401: CTL_SST_TS_NTP, /* not used (24) */
402: CTL_SST_TS_NTP, /* not used (25) */
403: CTL_SST_TS_UHF, /* REFCLK_GPS_HP (26) */
404: CTL_SST_TS_LF, /* REFCLK_ARCRON_MSF (27) */
405: CTL_SST_TS_UHF, /* REFCLK_SHM (28) */
406: CTL_SST_TS_UHF, /* REFCLK_PALISADE (29) */
407: CTL_SST_TS_UHF, /* REFCLK_ONCORE (30) */
408: CTL_SST_TS_UHF, /* REFCLK_JUPITER (31) */
409: CTL_SST_TS_LF, /* REFCLK_CHRONOLOG (32) */
410: CTL_SST_TS_LF, /* REFCLK_DUMBCLOCK (33) */
411: CTL_SST_TS_LF, /* REFCLK_ULINK (34) */
412: CTL_SST_TS_LF, /* REFCLK_PCF (35) */
413: CTL_SST_TS_HF, /* REFCLK_WWV (36) */
414: CTL_SST_TS_LF, /* REFCLK_FG (37) */
415: CTL_SST_TS_UHF, /* REFCLK_HOPF_SERIAL (38) */
416: CTL_SST_TS_UHF, /* REFCLK_HOPF_PCI (39) */
417: CTL_SST_TS_LF, /* REFCLK_JJY (40) */
418: CTL_SST_TS_UHF, /* REFCLK_TT560 (41) */
419: CTL_SST_TS_UHF, /* REFCLK_ZYFER (42) */
420: CTL_SST_TS_UHF, /* REFCLK_RIPENCC (43) */
421: CTL_SST_TS_UHF, /* REFCLK_NEOCLOCK4X (44) */
422: };
423:
424:
425: /*
426: * Keyid used for authenticating write requests.
427: */
428: keyid_t ctl_auth_keyid;
429:
430: /*
431: * We keep track of the last error reported by the system internally
432: */
433: static u_char ctl_sys_last_event;
434: static u_char ctl_sys_num_events;
435:
436:
437: /*
438: * Statistic counters to keep track of requests and responses.
439: */
440: u_long ctltimereset; /* time stats reset */
441: u_long numctlreq; /* number of requests we've received */
442: u_long numctlbadpkts; /* number of bad control packets */
443: u_long numctlresponses; /* number of resp packets sent with data */
444: u_long numctlfrags; /* number of fragments sent */
445: u_long numctlerrors; /* number of error responses sent */
446: u_long numctltooshort; /* number of too short input packets */
447: u_long numctlinputresp; /* number of responses on input */
448: u_long numctlinputfrag; /* number of fragments on input */
449: u_long numctlinputerr; /* number of input pkts with err bit set */
450: u_long numctlbadoffset; /* number of input pkts with nonzero offset */
451: u_long numctlbadversion; /* number of input pkts with unknown version */
452: u_long numctldatatooshort; /* data too short for count */
453: u_long numctlbadop; /* bad op code found in packet */
454: u_long numasyncmsgs; /* number of async messages we've sent */
455:
456: /*
457: * Response packet used by these routines. Also some state information
458: * so that we can handle packet formatting within a common set of
459: * subroutines. Note we try to enter data in place whenever possible,
460: * but the need to set the more bit correctly means we occasionally
461: * use the extra buffer and copy.
462: */
463: static struct ntp_control rpkt;
464: static u_char res_version;
465: static u_char res_opcode;
466: static associd_t res_associd;
467: static int res_offset;
468: static u_char * datapt;
469: static u_char * dataend;
470: static int datalinelen;
471: static int datanotbinflag;
472: static sockaddr_u *rmt_addr;
473: static struct interface *lcl_inter;
474:
475: static u_char res_authenticate;
476: static u_char res_authokay;
477: static keyid_t res_keyid;
478:
479: #define MAXDATALINELEN (72)
480:
481: static u_char res_async; /* set to 1 if this is async trap response */
482:
483: /*
484: * Pointers for saving state when decoding request packets
485: */
486: static char *reqpt;
487: static char *reqend;
488:
489: /*
490: * init_control - initialize request data
491: */
492: void
493: init_control(void)
494: {
495: int i;
496:
497: #ifdef HAVE_UNAME
498: uname(&utsnamebuf);
499: #endif /* HAVE_UNAME */
500:
501: ctl_clr_stats();
502:
503: ctl_auth_keyid = 0;
504: ctl_sys_last_event = EVNT_UNSPEC;
505: ctl_sys_num_events = 0;
506:
507: num_ctl_traps = 0;
508: for (i = 0; i < CTL_MAXTRAPS; i++)
509: ctl_trap[i].tr_flags = 0;
510: }
511:
512:
513: /*
514: * ctl_error - send an error response for the current request
515: */
516: static void
517: ctl_error(
518: int errcode
519: )
520: {
521: DPRINTF(3, ("sending control error %d\n", errcode));
522:
523: /*
524: * Fill in the fields. We assume rpkt.sequence and rpkt.associd
525: * have already been filled in.
526: */
527: rpkt.r_m_e_op = (u_char) (CTL_RESPONSE|CTL_ERROR|(res_opcode &
528: CTL_OP_MASK));
529: rpkt.status = htons((u_short) ((errcode<<8) & 0xff00));
530: rpkt.count = 0;
531:
532: /*
533: * send packet and bump counters
534: */
535: if (res_authenticate && sys_authenticate) {
536: int maclen;
537:
538: maclen = authencrypt(res_keyid, (u_int32 *)&rpkt,
539: CTL_HEADER_LEN);
540: sendpkt(rmt_addr, lcl_inter, -2, (struct pkt *)&rpkt,
541: CTL_HEADER_LEN + maclen);
542: } else {
543: sendpkt(rmt_addr, lcl_inter, -3, (struct pkt *)&rpkt,
544: CTL_HEADER_LEN);
545: }
546: numctlerrors++;
547: }
548:
549: /*
550: * save_config - Implements ntpq -c "saveconfig <filename>"
551: * Writes current configuration including any runtime
552: * changes by ntpq's :config or config-from-file
553: */
554: void
555: save_config(
556: struct recvbuf *rbufp,
557: int restrict_mask
558: )
559: {
560: char reply[128];
561: #ifdef SAVECONFIG
562: char filespec[128];
563: char filename[128];
564: char fullpath[512];
565: const char savedconfig_eq[] = "savedconfig=";
566: char savedconfig[sizeof(savedconfig_eq) + sizeof(filename)];
567: time_t now;
568: int fd;
569: FILE *fptr;
570: #endif
571:
572: if (restrict_mask & RES_NOMODIFY) {
573: snprintf(reply, sizeof(reply),
574: "saveconfig prohibited by restrict ... nomodify");
575: ctl_putdata(reply, strlen(reply), 0);
576: ctl_flushpkt(0);
577: msyslog(LOG_NOTICE,
578: "saveconfig from %s rejected due to nomodify restriction",
579: stoa(&rbufp->recv_srcadr));
580: return;
581: }
582:
583: #ifdef SAVECONFIG
584: if (NULL == saveconfigdir) {
585: snprintf(reply, sizeof(reply),
586: "saveconfig prohibited, no saveconfigdir configured");
587: ctl_putdata(reply, strlen(reply), 0);
588: ctl_flushpkt(0);
589: msyslog(LOG_NOTICE,
590: "saveconfig from %s rejected, no saveconfigdir",
591: stoa(&rbufp->recv_srcadr));
592: return;
593: }
594:
595: if (0 == reqend - reqpt)
596: return;
597:
598: strncpy(filespec, reqpt, sizeof(filespec));
599: filespec[sizeof(filespec) - 1] = '\0';
600:
601: time(&now);
602:
603: /*
604: * allow timestamping of the saved config filename with
605: * strftime() format such as:
606: * ntpq -c "saveconfig ntp-%Y%m%d-%H%M%S.conf"
607: */
608: if (0 == strftime(filename, sizeof(filename), filespec,
609: localtime(&now)))
610: strncpy(filename, filespec, sizeof(filename));
611:
612: filename[sizeof(filename) - 1] = '\0';
613:
614: if (strchr(filename, '\\') || strchr(filename, '/')) {
615: snprintf(reply, sizeof(reply),
616: "saveconfig does not allow directory in filename");
617: ctl_putdata(reply, strlen(reply), 0);
618: ctl_flushpkt(0);
619: msyslog(LOG_NOTICE,
620: "saveconfig with path from %s rejected",
621: stoa(&rbufp->recv_srcadr));
622: return;
623: }
624:
625: snprintf(fullpath, sizeof(fullpath), "%s%s",
626: saveconfigdir, filename);
627:
628: fd = open(fullpath, O_CREAT | O_TRUNC | O_WRONLY,
629: S_IRUSR | S_IWUSR);
630: if (-1 == fd)
631: fptr = NULL;
632: else
633: fptr = fdopen(fd, "w");
634:
635: if (NULL == fptr || -1 == dump_all_config_trees(fptr, 1)) {
636: snprintf(reply, sizeof(reply),
637: "Unable to save configuration to file %s",
638: filename);
639: msyslog(LOG_ERR,
640: "saveconfig %s from %s failed", filename,
641: stoa(&rbufp->recv_srcadr));
642: } else {
643: snprintf(reply, sizeof(reply),
644: "Configuration saved to %s", filename);
645: msyslog(LOG_NOTICE,
646: "Configuration saved to %s (requested by %s)",
647: fullpath, stoa(&rbufp->recv_srcadr));
648: /*
649: * save the output filename in system variable
650: * savedconfig, retrieved with:
651: * ntpq -c "rv 0 savedconfig"
652: */
653: snprintf(savedconfig, sizeof(savedconfig), "%s%s",
654: savedconfig_eq, filename);
655: set_sys_var(savedconfig, strlen(savedconfig) + 1, RO);
656: }
657:
658: if (NULL != fptr)
659: fclose(fptr);
660: #else /* !SAVECONFIG follows */
661: snprintf(reply, sizeof(reply),
662: "saveconfig unavailable, configured with --disable-saveconfig");
663: #endif
664:
665: ctl_putdata(reply, strlen(reply), 0);
666: ctl_flushpkt(0);
667: }
668:
669:
670: /*
671: * process_control - process an incoming control message
672: */
673: void
674: process_control(
675: struct recvbuf *rbufp,
676: int restrict_mask
677: )
678: {
679: register struct ntp_control *pkt;
680: register int req_count;
681: register int req_data;
682: register struct ctl_proc *cc;
683: int properlen;
684: int maclen;
685:
686: DPRINTF(3, ("in process_control()\n"));
687:
688: /*
689: * Save the addresses for error responses
690: */
691: numctlreq++;
692: rmt_addr = &rbufp->recv_srcadr;
693: lcl_inter = rbufp->dstadr;
694: pkt = (struct ntp_control *)&rbufp->recv_pkt;
695:
696: /*
697: * If the length is less than required for the header, or
698: * it is a response or a fragment, ignore this.
699: */
700: if (rbufp->recv_length < CTL_HEADER_LEN
701: || pkt->r_m_e_op & (CTL_RESPONSE|CTL_MORE|CTL_ERROR)
702: || pkt->offset != 0) {
703: DPRINTF(1, ("invalid format in control packet\n"));
704: if (rbufp->recv_length < CTL_HEADER_LEN)
705: numctltooshort++;
706: if (pkt->r_m_e_op & CTL_RESPONSE)
707: numctlinputresp++;
708: if (pkt->r_m_e_op & CTL_MORE)
709: numctlinputfrag++;
710: if (pkt->r_m_e_op & CTL_ERROR)
711: numctlinputerr++;
712: if (pkt->offset != 0)
713: numctlbadoffset++;
714: return;
715: }
716: res_version = PKT_VERSION(pkt->li_vn_mode);
717: if (res_version > NTP_VERSION || res_version < NTP_OLDVERSION) {
718: DPRINTF(1, ("unknown version %d in control packet\n",
719: res_version));
720: numctlbadversion++;
721: return;
722: }
723:
724: /*
725: * Pull enough data from the packet to make intelligent
726: * responses
727: */
728: rpkt.li_vn_mode = PKT_LI_VN_MODE(sys_leap, res_version,
729: MODE_CONTROL);
730: res_opcode = pkt->r_m_e_op;
731: rpkt.sequence = pkt->sequence;
732: rpkt.associd = pkt->associd;
733: rpkt.status = 0;
734: res_offset = 0;
735: res_associd = htons(pkt->associd);
736: res_async = 0;
737: res_authenticate = 0;
738: res_keyid = 0;
739: res_authokay = 0;
740: req_count = (int)ntohs(pkt->count);
741: datanotbinflag = 0;
742: datalinelen = 0;
743: datapt = rpkt.data;
744: dataend = &(rpkt.data[CTL_MAX_DATA_LEN]);
745:
746: if ((rbufp->recv_length & 0x3) != 0)
747: DPRINTF(3, ("Control packet length %d unrounded\n",
748: rbufp->recv_length));
749:
750: /*
751: * We're set up now. Make sure we've got at least enough
752: * incoming data space to match the count.
753: */
754: req_data = rbufp->recv_length - CTL_HEADER_LEN;
755: if (req_data < req_count || rbufp->recv_length & 0x3) {
756: ctl_error(CERR_BADFMT);
757: numctldatatooshort++;
758: return;
759: }
760:
761: properlen = req_count + CTL_HEADER_LEN;
762: /* round up proper len to a 8 octet boundary */
763:
764: properlen = (properlen + 7) & ~7;
765: maclen = rbufp->recv_length - properlen;
766: if ((rbufp->recv_length & 3) == 0 &&
767: maclen >= MIN_MAC_LEN && maclen <= MAX_MAC_LEN &&
768: sys_authenticate) {
769: res_authenticate = 1;
770: res_keyid = ntohl(*(u_int32 *)((u_char *)pkt +
771: properlen));
772:
773: DPRINTF(3, ("recv_len %d, properlen %d, wants auth with keyid %08x, MAC length=%d\n",
774: rbufp->recv_length, properlen, res_keyid,
775: maclen));
776:
777: if (!authistrusted(res_keyid))
778: DPRINTF(3, ("invalid keyid %08x\n", res_keyid));
779: else if (authdecrypt(res_keyid, (u_int32 *)pkt,
780: rbufp->recv_length - maclen,
781: maclen)) {
782: DPRINTF(3, ("authenticated okay\n"));
783: res_authokay = 1;
784: } else {
785: DPRINTF(3, ("authentication failed\n"));
786: res_keyid = 0;
787: }
788: }
789:
790: /*
791: * Set up translate pointers
792: */
793: reqpt = (char *)pkt->data;
794: reqend = reqpt + req_count;
795:
796: /*
797: * Look for the opcode processor
798: */
799: for (cc = control_codes; cc->control_code != NO_REQUEST; cc++) {
800: if (cc->control_code == res_opcode) {
801: DPRINTF(3, ("opcode %d, found command handler\n",
802: res_opcode));
803: if (cc->flags == AUTH
804: && (!res_authokay
805: || res_keyid != ctl_auth_keyid)) {
806: ctl_error(CERR_PERMISSION);
807: return;
808: }
809: (cc->handler)(rbufp, restrict_mask);
810: return;
811: }
812: }
813:
814: /*
815: * Can't find this one, return an error.
816: */
817: numctlbadop++;
818: ctl_error(CERR_BADOP);
819: return;
820: }
821:
822:
823: /*
824: * ctlpeerstatus - return a status word for this peer
825: */
826: u_short
827: ctlpeerstatus(
828: register struct peer *peer
829: )
830: {
831: u_short status;
832:
833: status = peer->status;
834: if (!(peer->flags & FLAG_PREEMPT))
835: status |= CTL_PST_CONFIG;
836: if (peer->keyid != 0)
837: status |= CTL_PST_AUTHENABLE;
838: if (peer->flags & FLAG_AUTHENTIC)
839: status |= CTL_PST_AUTHENTIC;
840: if (peer->reach != 0)
841: status |= CTL_PST_REACH;
842: if (peer->cast_flags & (MDF_BCAST | MDF_MCAST | MDF_ACAST))
843: status |= CTL_PST_BCAST;
844: return (u_short)CTL_PEER_STATUS(status, peer->num_events,
845: peer->last_event);
846: }
847:
848:
849: /*
850: * ctlclkstatus - return a status word for this clock
851: */
852: #ifdef REFCLOCK
853: static u_short
854: ctlclkstatus(
855: struct refclockstat *this_clock
856: )
857: {
858: return (u_short)CTL_PEER_STATUS(0, this_clock->lastevent,
859: this_clock->currentstatus);
860: }
861: #endif
862:
863:
864: /*
865: * ctlsysstatus - return the system status word
866: */
867: u_short
868: ctlsysstatus(void)
869: {
870: register u_char this_clock;
871:
872: this_clock = CTL_SST_TS_UNSPEC;
873: #ifdef REFCLOCK
874: if (sys_peer != 0) {
875: if (sys_peer->sstclktype != CTL_SST_TS_UNSPEC) {
876: this_clock = sys_peer->sstclktype;
877: } else {
878: if (sys_peer->refclktype < sizeof(clocktypes))
879: this_clock =
880: clocktypes[sys_peer->refclktype];
881: }
882: }
883: #else /* REFCLOCK */
884: if (sys_peer != 0)
885: this_clock = CTL_SST_TS_NTP;
886: #endif /* REFCLOCK */
887: return (u_short)CTL_SYS_STATUS(sys_leap, this_clock,
888: ctl_sys_num_events, ctl_sys_last_event);
889: }
890:
891:
892: /*
893: * ctl_flushpkt - write out the current packet and prepare
894: * another if necessary.
895: */
896: static void
897: ctl_flushpkt(
898: int more
899: )
900: {
901: int dlen;
902: int sendlen;
903:
904: if (!more && datanotbinflag) {
905: /*
906: * Big hack, output a trailing \r\n
907: */
908: *datapt++ = '\r';
909: *datapt++ = '\n';
910: }
911: dlen = datapt - (u_char *)rpkt.data;
912: sendlen = dlen + CTL_HEADER_LEN;
913:
914: /*
915: * Pad to a multiple of 32 bits
916: */
917: while (sendlen & 0x3) {
918: *datapt++ = '\0';
919: sendlen++;
920: }
921:
922: /*
923: * Fill in the packet with the current info
924: */
925: rpkt.r_m_e_op = (u_char)(CTL_RESPONSE|more|(res_opcode &
926: CTL_OP_MASK));
927: rpkt.count = htons((u_short) dlen);
928: rpkt.offset = htons( (u_short) res_offset);
929: if (res_async) {
930: register int i;
931:
932: for (i = 0; i < CTL_MAXTRAPS; i++) {
933: if (ctl_trap[i].tr_flags & TRAP_INUSE) {
934: rpkt.li_vn_mode =
935: PKT_LI_VN_MODE(sys_leap,
936: ctl_trap[i].tr_version,
937: MODE_CONTROL);
938: rpkt.sequence =
939: htons(ctl_trap[i].tr_sequence);
940: sendpkt(&ctl_trap[i].tr_addr,
941: ctl_trap[i].tr_localaddr, -4,
942: (struct pkt *)&rpkt, sendlen);
943: if (!more)
944: ctl_trap[i].tr_sequence++;
945: numasyncmsgs++;
946: }
947: }
948: } else {
949: if (res_authenticate && sys_authenticate) {
950: int maclen;
951: int totlen = sendlen;
952: keyid_t keyid = htonl(res_keyid);
953:
954: /*
955: * If we are going to authenticate, then there
956: * is an additional requirement that the MAC
957: * begin on a 64 bit boundary.
958: */
959: while (totlen & 7) {
960: *datapt++ = '\0';
961: totlen++;
962: }
963: memcpy(datapt, &keyid, sizeof keyid);
964: maclen = authencrypt(res_keyid,
965: (u_int32 *)&rpkt, totlen);
966: sendpkt(rmt_addr, lcl_inter, -5,
967: (struct pkt *)&rpkt, totlen + maclen);
968: } else {
969: sendpkt(rmt_addr, lcl_inter, -6,
970: (struct pkt *)&rpkt, sendlen);
971: }
972: if (more)
973: numctlfrags++;
974: else
975: numctlresponses++;
976: }
977:
978: /*
979: * Set us up for another go around.
980: */
981: res_offset += dlen;
982: datapt = (u_char *)rpkt.data;
983: }
984:
985:
986: /*
987: * ctl_putdata - write data into the packet, fragmenting and starting
988: * another if this one is full.
989: */
990: static void
991: ctl_putdata(
992: const char *dp,
993: unsigned int dlen,
994: int bin /* set to 1 when data is binary */
995: )
996: {
997: int overhead;
998:
999: overhead = 0;
1000: if (!bin) {
1001: datanotbinflag = 1;
1002: overhead = 3;
1003: if (datapt != rpkt.data) {
1004: *datapt++ = ',';
1005: datalinelen++;
1006: if ((dlen + datalinelen + 1) >= MAXDATALINELEN)
1007: {
1008: *datapt++ = '\r';
1009: *datapt++ = '\n';
1010: datalinelen = 0;
1011: } else {
1012: *datapt++ = ' ';
1013: datalinelen++;
1014: }
1015: }
1016: }
1017:
1018: /*
1019: * Save room for trailing junk
1020: */
1021: if (dlen + overhead + datapt > dataend) {
1022: /*
1023: * Not enough room in this one, flush it out.
1024: */
1025: ctl_flushpkt(CTL_MORE);
1026: }
1027: memmove((char *)datapt, dp, (unsigned)dlen);
1028: datapt += dlen;
1029: datalinelen += dlen;
1030: }
1031:
1032:
1033: /*
1034: * ctl_putstr - write a tagged string into the response packet
1035: */
1036: static void
1037: ctl_putstr(
1038: const char *tag,
1039: const char *data,
1040: unsigned int len
1041: )
1042: {
1043: register char *cp;
1044: register const char *cq;
1045: char buffer[400];
1046:
1047: cp = buffer;
1048: cq = tag;
1049: while (*cq != '\0')
1050: *cp++ = *cq++;
1051: if (len > 0) {
1052: *cp++ = '=';
1053: *cp++ = '"';
1054: if (len > (int) (sizeof(buffer) - (cp - buffer) - 1))
1055: len = sizeof(buffer) - (cp - buffer) - 1;
1056: memmove(cp, data, (unsigned)len);
1057: cp += len;
1058: *cp++ = '"';
1059: }
1060: ctl_putdata(buffer, (unsigned)( cp - buffer ), 0);
1061: }
1062:
1063:
1064: /*
1065: * ctl_putdbl - write a tagged, signed double into the response packet
1066: */
1067: static void
1068: ctl_putdbl(
1069: const char *tag,
1070: double ts
1071: )
1072: {
1073: register char *cp;
1074: register const char *cq;
1075: char buffer[200];
1076:
1077: cp = buffer;
1078: cq = tag;
1079: while (*cq != '\0')
1080: *cp++ = *cq++;
1081: *cp++ = '=';
1082: NTP_INSIST((cp - buffer) < sizeof(buffer));
1083: snprintf(cp, sizeof(buffer) - (cp - buffer), "%.3f", ts);
1084: cp += strlen(cp);
1085: ctl_putdata(buffer, (unsigned)(cp - buffer), 0);
1086: }
1087:
1088: /*
1089: * ctl_putuint - write a tagged unsigned integer into the response
1090: */
1091: static void
1092: ctl_putuint(
1093: const char *tag,
1094: u_long uval
1095: )
1096: {
1097: register char *cp;
1098: register const char *cq;
1099: char buffer[200];
1100:
1101: cp = buffer;
1102: cq = tag;
1103: while (*cq != '\0')
1104: *cp++ = *cq++;
1105:
1106: *cp++ = '=';
1107: NTP_INSIST((cp - buffer) < sizeof(buffer));
1108: snprintf(cp, sizeof(buffer) - (cp - buffer), "%lu", uval);
1109: cp += strlen(cp);
1110: ctl_putdata(buffer, (unsigned)( cp - buffer ), 0);
1111: }
1112:
1113: /*
1114: * ctl_putfs - write a decoded filestamp into the response
1115: */
1116: static void
1117: ctl_putfs(
1118: const char *tag,
1119: tstamp_t uval
1120: )
1121: {
1122: register char *cp;
1123: register const char *cq;
1124: char buffer[200];
1125: struct tm *tm = NULL;
1126: time_t fstamp;
1127:
1128: cp = buffer;
1129: cq = tag;
1130: while (*cq != '\0')
1131: *cp++ = *cq++;
1132:
1133: *cp++ = '=';
1134: fstamp = uval - JAN_1970;
1135: tm = gmtime(&fstamp);
1136: if (NULL == tm)
1137: return;
1138: NTP_INSIST((cp - buffer) < sizeof(buffer));
1139: snprintf(cp, sizeof(buffer) - (cp - buffer),
1140: "%04d%02d%02d%02d%02d", tm->tm_year + 1900,
1141: tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min);
1142: cp += strlen(cp);
1143: ctl_putdata(buffer, (unsigned)( cp - buffer ), 0);
1144: }
1145:
1146:
1147: /*
1148: * ctl_puthex - write a tagged unsigned integer, in hex, into the
1149: * response
1150: */
1151: static void
1152: ctl_puthex(
1153: const char *tag,
1154: u_long uval
1155: )
1156: {
1157: register char *cp;
1158: register const char *cq;
1159: char buffer[200];
1160:
1161: cp = buffer;
1162: cq = tag;
1163: while (*cq != '\0')
1164: *cp++ = *cq++;
1165:
1166: *cp++ = '=';
1167: NTP_INSIST((cp - buffer) < sizeof(buffer));
1168: snprintf(cp, sizeof(buffer) - (cp - buffer), "0x%lx", uval);
1169: cp += strlen(cp);
1170: ctl_putdata(buffer,(unsigned)( cp - buffer ), 0);
1171: }
1172:
1173:
1174: /*
1175: * ctl_putint - write a tagged signed integer into the response
1176: */
1177: static void
1178: ctl_putint(
1179: const char *tag,
1180: long ival
1181: )
1182: {
1183: register char *cp;
1184: register const char *cq;
1185: char buffer[200];
1186:
1187: cp = buffer;
1188: cq = tag;
1189: while (*cq != '\0')
1190: *cp++ = *cq++;
1191:
1192: *cp++ = '=';
1193: NTP_INSIST((cp - buffer) < sizeof(buffer));
1194: snprintf(cp, sizeof(buffer) - (cp - buffer), "%ld", ival);
1195: cp += strlen(cp);
1196: ctl_putdata(buffer, (unsigned)( cp - buffer ), 0);
1197: }
1198:
1199:
1200: /*
1201: * ctl_putts - write a tagged timestamp, in hex, into the response
1202: */
1203: static void
1204: ctl_putts(
1205: const char *tag,
1206: l_fp *ts
1207: )
1208: {
1209: register char *cp;
1210: register const char *cq;
1211: char buffer[200];
1212:
1213: cp = buffer;
1214: cq = tag;
1215: while (*cq != '\0')
1216: *cp++ = *cq++;
1217:
1218: *cp++ = '=';
1219: NTP_INSIST((cp - buffer) < sizeof(buffer));
1220: snprintf(cp, sizeof(buffer) - (cp - buffer), "0x%08lx.%08lx",
1221: ts->l_ui & 0xffffffffUL, ts->l_uf & 0xffffffffUL);
1222: cp += strlen(cp);
1223: ctl_putdata(buffer, (unsigned)( cp - buffer ), 0);
1224: }
1225:
1226:
1227: /*
1228: * ctl_putadr - write an IP address into the response
1229: */
1230: static void
1231: ctl_putadr(
1232: const char *tag,
1233: u_int32 addr32,
1234: sockaddr_u *addr
1235: )
1236: {
1237: register char *cp;
1238: register const char *cq;
1239: char buffer[200];
1240:
1241: cp = buffer;
1242: cq = tag;
1243: while (*cq != '\0')
1244: *cp++ = *cq++;
1245:
1246: *cp++ = '=';
1247: if (NULL == addr)
1248: cq = numtoa(addr32);
1249: else
1250: cq = stoa(addr);
1251: NTP_INSIST((cp - buffer) < sizeof(buffer));
1252: snprintf(cp, sizeof(buffer) - (cp - buffer), "%s", cq);
1253: cp += strlen(cp);
1254: ctl_putdata(buffer, (unsigned)(cp - buffer), 0);
1255: }
1256:
1257:
1258: /*
1259: * ctl_putrefid - send a u_int32 refid as printable text
1260: */
1261: static void
1262: ctl_putrefid(
1263: const char * tag,
1264: u_int32 refid
1265: )
1266: {
1267: char output[16];
1268: char * optr;
1269: char * oplim;
1270: char * iptr;
1271: char * iplim;
1272: char * past_eq;
1273:
1274: optr = output;
1275: oplim = output + sizeof(output);
1276: while (optr < oplim && '\0' != *tag)
1277: *optr++ = *tag++;
1278: if (optr < oplim) {
1279: *optr++ = '=';
1280: past_eq = optr;
1281: }
1282: if (!(optr < oplim))
1283: return;
1284: iptr = (char *)&refid;
1285: iplim = iptr + sizeof(refid);
1286: for ( ; optr < oplim && iptr < iplim && '\0' != *iptr;
1287: iptr++, optr++)
1288: if (isprint(*iptr))
1289: *optr = *iptr;
1290: else
1291: *optr = '.';
1292: if (!(optr <= oplim))
1293: optr = past_eq;
1294: ctl_putdata(output, (u_int)(optr - output), FALSE);
1295: }
1296:
1297:
1298: /*
1299: * ctl_putarray - write a tagged eight element double array into the response
1300: */
1301: static void
1302: ctl_putarray(
1303: const char *tag,
1304: double *arr,
1305: int start
1306: )
1307: {
1308: register char *cp;
1309: register const char *cq;
1310: char buffer[200];
1311: int i;
1312: cp = buffer;
1313: cq = tag;
1314: while (*cq != '\0')
1315: *cp++ = *cq++;
1316: i = start;
1317: do {
1318: if (i == 0)
1319: i = NTP_SHIFT;
1320: i--;
1321: NTP_INSIST((cp - buffer) < sizeof(buffer));
1322: snprintf(cp, sizeof(buffer) - (cp - buffer),
1323: " %.2f", arr[i] * 1e3);
1324: cp += strlen(cp);
1325: } while(i != start);
1326: ctl_putdata(buffer, (unsigned)(cp - buffer), 0);
1327: }
1328:
1329:
1330: /*
1331: * ctl_putsys - output a system variable
1332: */
1333: static void
1334: ctl_putsys(
1335: int varid
1336: )
1337: {
1338: l_fp tmp;
1339: char str[256];
1340: #ifdef OPENSSL
1341: struct cert_info *cp;
1342: char cbuf[256];
1343: #endif /* OPENSSL */
1344:
1345: switch (varid) {
1346:
1347: case CS_LEAP:
1348: ctl_putuint(sys_var[CS_LEAP].text, sys_leap);
1349: break;
1350:
1351: case CS_STRATUM:
1352: ctl_putuint(sys_var[CS_STRATUM].text, sys_stratum);
1353: break;
1354:
1355: case CS_PRECISION:
1356: ctl_putint(sys_var[CS_PRECISION].text, sys_precision);
1357: break;
1358:
1359: case CS_ROOTDELAY:
1360: ctl_putdbl(sys_var[CS_ROOTDELAY].text, sys_rootdelay *
1361: 1e3);
1362: break;
1363:
1364: case CS_ROOTDISPERSION:
1365: ctl_putdbl(sys_var[CS_ROOTDISPERSION].text,
1366: sys_rootdisp * 1e3);
1367: break;
1368:
1369: case CS_REFID:
1370: if (sys_stratum > 1 && sys_stratum < STRATUM_UNSPEC)
1371: ctl_putadr(sys_var[varid].text, sys_refid, NULL);
1372: else
1373: ctl_putrefid(sys_var[varid].text, sys_refid);
1374: break;
1375:
1376: case CS_REFTIME:
1377: ctl_putts(sys_var[CS_REFTIME].text, &sys_reftime);
1378: break;
1379:
1380: case CS_POLL:
1381: ctl_putuint(sys_var[CS_POLL].text, sys_poll);
1382: break;
1383:
1384: case CS_PEERID:
1385: if (sys_peer == NULL)
1386: ctl_putuint(sys_var[CS_PEERID].text, 0);
1387: else
1388: ctl_putuint(sys_var[CS_PEERID].text,
1389: sys_peer->associd);
1390: break;
1391:
1392: case CS_OFFSET:
1393: ctl_putdbl(sys_var[CS_OFFSET].text, last_offset * 1e3);
1394: break;
1395:
1396: case CS_DRIFT:
1397: ctl_putdbl(sys_var[CS_DRIFT].text, drift_comp * 1e6);
1398: break;
1399:
1400: case CS_JITTER:
1401: ctl_putdbl(sys_var[CS_JITTER].text, sys_jitter * 1e3);
1402: break;
1403:
1404: case CS_ERROR:
1405: ctl_putdbl(sys_var[CS_ERROR].text, clock_jitter * 1e3);
1406: break;
1407:
1408: case CS_CLOCK:
1409: get_systime(&tmp);
1410: ctl_putts(sys_var[CS_CLOCK].text, &tmp);
1411: break;
1412:
1413: case CS_PROCESSOR:
1414: #ifndef HAVE_UNAME
1415: ctl_putstr(sys_var[CS_PROCESSOR].text, str_processor,
1416: sizeof(str_processor) - 1);
1417: #else
1418: ctl_putstr(sys_var[CS_PROCESSOR].text,
1419: utsnamebuf.machine, strlen(utsnamebuf.machine));
1420: #endif /* HAVE_UNAME */
1421: break;
1422:
1423: case CS_SYSTEM:
1424: #ifndef HAVE_UNAME
1425: ctl_putstr(sys_var[CS_SYSTEM].text, str_system,
1426: sizeof(str_system) - 1);
1427: #else
1428: snprintf(str, sizeof(str), "%s/%s", utsnamebuf.sysname,
1429: utsnamebuf.release);
1430: ctl_putstr(sys_var[CS_SYSTEM].text, str, strlen(str));
1431: #endif /* HAVE_UNAME */
1432: break;
1433:
1434: case CS_VERSION:
1435: ctl_putstr(sys_var[CS_VERSION].text, Version,
1436: strlen(Version));
1437: break;
1438:
1439: case CS_STABIL:
1440: ctl_putdbl(sys_var[CS_STABIL].text, clock_stability *
1441: 1e6);
1442: break;
1443:
1444: case CS_VARLIST:
1445: {
1446: char buf[CTL_MAX_DATA_LEN];
1447: register char *s, *t, *be;
1448: register const char *ss;
1449: register int i;
1450: register struct ctl_var *k;
1451:
1452: s = buf;
1453: be = buf + sizeof(buf);
1454: if (s + strlen(sys_var[CS_VARLIST].text) + 4 > be)
1455: break; /* really long var name */
1456:
1457: snprintf(s, sizeof(buf), "%s=\"",
1458: sys_var[CS_VARLIST].text);
1459: s += strlen(s);
1460: t = s;
1461: for (k = sys_var; !(k->flags & EOV); k++) {
1462: if (k->flags & PADDING)
1463: continue;
1464: i = strlen(k->text);
1465: if (s+i+1 >= be)
1466: break;
1467:
1468: if (s != t)
1469: *s++ = ',';
1470: memcpy(s, k->text, i);
1471: s += i;
1472: }
1473:
1474: for (k = ext_sys_var; k && !(k->flags & EOV);
1475: k++) {
1476: if (k->flags & PADDING)
1477: continue;
1478:
1479: ss = k->text;
1480: if (!ss)
1481: continue;
1482:
1483: while (*ss && *ss != '=')
1484: ss++;
1485: i = ss - k->text;
1486: if (s + i + 1 >= be)
1487: break;
1488:
1489: if (s != t)
1490: *s++ = ',';
1491: memcpy(s, k->text,
1492: (unsigned)i);
1493: s += i;
1494: }
1495: if (s+2 >= be)
1496: break;
1497:
1498: *s++ = '"';
1499: *s = '\0';
1500:
1501: ctl_putdata(buf, (unsigned)( s - buf ),
1502: 0);
1503: }
1504: break;
1505:
1506: case CS_TAI:
1507: if (sys_tai > 0)
1508: ctl_putuint(sys_var[CS_TAI].text, sys_tai);
1509: break;
1510:
1511: case CS_LEAPTAB:
1512: if (leap_sec > 0)
1513: ctl_putfs(sys_var[CS_LEAPTAB].text,
1514: leap_sec);
1515: break;
1516:
1517: case CS_LEAPEND:
1518: if (leap_expire > 0)
1519: ctl_putfs(sys_var[CS_LEAPEND].text,
1520: leap_expire);
1521: break;
1522:
1523: case CS_RATE:
1524: ctl_putuint(sys_var[CS_RATE].text, ntp_minpoll);
1525: break;
1526:
1527: #ifdef OPENSSL
1528: case CS_FLAGS:
1529: if (crypto_flags)
1530: ctl_puthex(sys_var[CS_FLAGS].text,
1531: crypto_flags);
1532: break;
1533:
1534: case CS_DIGEST:
1535: if (crypto_flags) {
1536: strcpy(str, OBJ_nid2ln(crypto_nid));
1537: ctl_putstr(sys_var[CS_DIGEST].text, str,
1538: strlen(str));
1539: }
1540: break;
1541:
1542: case CS_SIGNATURE:
1543: if (crypto_flags) {
1544: const EVP_MD *dp;
1545:
1546: dp = EVP_get_digestbynid(crypto_flags >> 16);
1547: strcpy(str, OBJ_nid2ln(EVP_MD_pkey_type(dp)));
1548: ctl_putstr(sys_var[CS_SIGNATURE].text, str,
1549: strlen(str));
1550: }
1551: break;
1552:
1553: case CS_HOST:
1554: if (sys_hostname != NULL)
1555: ctl_putstr(sys_var[CS_HOST].text, sys_hostname,
1556: strlen(sys_hostname));
1557: break;
1558:
1559: case CS_GROUP:
1560: if (sys_groupname != NULL)
1561: ctl_putstr(sys_var[CS_GROUP].text, sys_groupname,
1562: strlen(sys_groupname));
1563: break;
1564:
1565: case CS_CERTIF:
1566: for (cp = cinfo; cp != NULL; cp = cp->link) {
1567: snprintf(cbuf, sizeof(cbuf), "%s %s 0x%x",
1568: cp->subject, cp->issuer, cp->flags);
1569: ctl_putstr(sys_var[CS_CERTIF].text, cbuf,
1570: strlen(cbuf));
1571: ctl_putfs(sys_var[CS_REVTIME].text, cp->last);
1572: }
1573: break;
1574:
1575: case CS_PUBLIC:
1576: if (hostval.tstamp != 0)
1577: ctl_putfs(sys_var[CS_PUBLIC].text,
1578: ntohl(hostval.tstamp));
1579: break;
1580: #endif /* OPENSSL */
1581: }
1582: }
1583:
1584:
1585: /*
1586: * ctl_putpeer - output a peer variable
1587: */
1588: static void
1589: ctl_putpeer(
1590: int varid,
1591: struct peer *peer
1592: )
1593: {
1594: int temp;
1595: #ifdef OPENSSL
1596: char str[256];
1597: struct autokey *ap;
1598: #endif /* OPENSSL */
1599:
1600: switch (varid) {
1601:
1602: case CP_CONFIG:
1603: ctl_putuint(peer_var[CP_CONFIG].text,
1604: (unsigned)((peer->flags & FLAG_PREEMPT) == 0));
1605: break;
1606:
1607: case CP_AUTHENABLE:
1608: ctl_putuint(peer_var[CP_AUTHENABLE].text,
1609: (unsigned)(peer->keyid != 0));
1610: break;
1611:
1612: case CP_AUTHENTIC:
1613: ctl_putuint(peer_var[CP_AUTHENTIC].text,
1614: (unsigned)((peer->flags & FLAG_AUTHENTIC) != 0));
1615: break;
1616:
1617: case CP_SRCADR:
1618: ctl_putadr(peer_var[CP_SRCADR].text, 0,
1619: &peer->srcadr);
1620: break;
1621:
1622: case CP_SRCPORT:
1623: ctl_putuint(peer_var[CP_SRCPORT].text,
1624: ntohs(((struct sockaddr_in*)&peer->srcadr)->sin_port));
1625: break;
1626:
1627: case CP_DSTADR:
1628: if (peer->dstadr) {
1629: ctl_putadr(peer_var[CP_DSTADR].text, 0,
1630: &(peer->dstadr->sin));
1631: } else {
1632: ctl_putadr(peer_var[CP_DSTADR].text, 0,
1633: NULL);
1634: }
1635: break;
1636:
1637: case CP_DSTPORT:
1638: ctl_putuint(peer_var[CP_DSTPORT].text,
1639: (u_long)(peer->dstadr ?
1640: ntohs(((struct sockaddr_in*)&peer->dstadr->sin)->sin_port) : 0));
1641: break;
1642:
1643: case CP_IN:
1644: if (peer->r21 > 0)
1645: ctl_putdbl(peer_var[CP_IN].text,
1646: peer->r21 / 1e3);
1647: break;
1648:
1649: case CP_OUT:
1650: if (peer->r34 >0)
1651: ctl_putdbl(peer_var[CP_OUT].text,
1652: peer->r34 / 1e3);
1653: break;
1654:
1655: case CP_RATE:
1656: ctl_putuint(peer_var[CP_RATE].text, peer->throttle);
1657: break;
1658:
1659: case CP_LEAP:
1660: ctl_putuint(peer_var[CP_LEAP].text, peer->leap);
1661: break;
1662:
1663: case CP_HMODE:
1664: ctl_putuint(peer_var[CP_HMODE].text, peer->hmode);
1665: break;
1666:
1667: case CP_STRATUM:
1668: ctl_putuint(peer_var[CP_STRATUM].text, peer->stratum);
1669: break;
1670:
1671: case CP_PPOLL:
1672: ctl_putuint(peer_var[CP_PPOLL].text, peer->ppoll);
1673: break;
1674:
1675: case CP_HPOLL:
1676: ctl_putuint(peer_var[CP_HPOLL].text, peer->hpoll);
1677: break;
1678:
1679: case CP_PRECISION:
1680: ctl_putint(peer_var[CP_PRECISION].text,
1681: peer->precision);
1682: break;
1683:
1684: case CP_ROOTDELAY:
1685: ctl_putdbl(peer_var[CP_ROOTDELAY].text,
1686: peer->rootdelay * 1e3);
1687: break;
1688:
1689: case CP_ROOTDISPERSION:
1690: ctl_putdbl(peer_var[CP_ROOTDISPERSION].text,
1691: peer->rootdisp * 1e3);
1692: break;
1693:
1694: case CP_REFID:
1695: #ifdef REFCLOCK
1696: if (peer->flags & FLAG_REFCLOCK) {
1697: ctl_putrefid(peer_var[varid].text, peer->refid);
1698: break;
1699: }
1700: #endif
1701: if (peer->stratum > 1 && peer->stratum < STRATUM_UNSPEC)
1702: ctl_putadr(peer_var[varid].text, peer->refid,
1703: NULL);
1704: else
1705: ctl_putrefid(peer_var[varid].text, peer->refid);
1706: break;
1707:
1708: case CP_REFTIME:
1709: ctl_putts(peer_var[CP_REFTIME].text, &peer->reftime);
1710: break;
1711:
1712: case CP_ORG:
1713: ctl_putts(peer_var[CP_ORG].text, &peer->aorg);
1714: break;
1715:
1716: case CP_REC:
1717: ctl_putts(peer_var[CP_REC].text, &peer->dst);
1718: break;
1719:
1720: case CP_XMT:
1721: if (peer->xleave != 0)
1722: ctl_putdbl(peer_var[CP_XMT].text, peer->xleave *
1723: 1e3);
1724: break;
1725:
1726: case CP_BIAS:
1727: if (peer->bias != 0)
1728: ctl_putdbl(peer_var[CP_BIAS].text, peer->bias *
1729: 1e3);
1730: break;
1731:
1732: case CP_REACH:
1733: ctl_puthex(peer_var[CP_REACH].text, peer->reach);
1734: break;
1735:
1736: case CP_FLASH:
1737: temp = peer->flash;
1738: ctl_puthex(peer_var[CP_FLASH].text, temp);
1739: break;
1740:
1741: case CP_TTL:
1742: if (peer->ttl > 0)
1743: ctl_putint(peer_var[CP_TTL].text,
1744: sys_ttl[peer->ttl]);
1745: break;
1746:
1747: case CP_UNREACH:
1748: ctl_putuint(peer_var[CP_UNREACH].text, peer->unreach);
1749: break;
1750:
1751: case CP_TIMER:
1752: ctl_putuint(peer_var[CP_TIMER].text,
1753: peer->nextdate - current_time);
1754: break;
1755:
1756: case CP_DELAY:
1757: ctl_putdbl(peer_var[CP_DELAY].text, peer->delay * 1e3);
1758: break;
1759:
1760: case CP_OFFSET:
1761: ctl_putdbl(peer_var[CP_OFFSET].text, peer->offset *
1762: 1e3);
1763: break;
1764:
1765: case CP_JITTER:
1766: ctl_putdbl(peer_var[CP_JITTER].text, peer->jitter *
1767: 1e3);
1768: break;
1769:
1770: case CP_DISPERSION:
1771: ctl_putdbl(peer_var[CP_DISPERSION].text, peer->disp *
1772: 1e3);
1773: break;
1774:
1775: case CP_KEYID:
1776: if (peer->keyid > NTP_MAXKEY)
1777: ctl_puthex(peer_var[CP_KEYID].text,
1778: peer->keyid);
1779: else
1780: ctl_putuint(peer_var[CP_KEYID].text,
1781: peer->keyid);
1782: break;
1783:
1784: case CP_FILTDELAY:
1785: ctl_putarray(peer_var[CP_FILTDELAY].text,
1786: peer->filter_delay, (int)peer->filter_nextpt);
1787: break;
1788:
1789: case CP_FILTOFFSET:
1790: ctl_putarray(peer_var[CP_FILTOFFSET].text,
1791: peer->filter_offset, (int)peer->filter_nextpt);
1792: break;
1793:
1794: case CP_FILTERROR:
1795: ctl_putarray(peer_var[CP_FILTERROR].text,
1796: peer->filter_disp, (int)peer->filter_nextpt);
1797: break;
1798:
1799: case CP_PMODE:
1800: ctl_putuint(peer_var[CP_PMODE].text, peer->pmode);
1801: break;
1802:
1803: case CP_RECEIVED:
1804: ctl_putuint(peer_var[CP_RECEIVED].text, peer->received);
1805: break;
1806:
1807: case CP_SENT:
1808: ctl_putuint(peer_var[CP_SENT].text, peer->sent);
1809: break;
1810:
1811: case CP_VARLIST:
1812: {
1813: char buf[CTL_MAX_DATA_LEN];
1814: register char *s, *t, *be;
1815: register int i;
1816: register struct ctl_var *k;
1817:
1818: s = buf;
1819: be = buf + sizeof(buf);
1820: if (s + strlen(peer_var[CP_VARLIST].text) + 4 > be)
1821: break; /* really long var name */
1822:
1823: snprintf(s, sizeof(buf), "%s=\"",
1824: peer_var[CP_VARLIST].text);
1825: s += strlen(s);
1826: t = s;
1827: for (k = peer_var; !(k->flags & EOV); k++) {
1828: if (k->flags & PADDING)
1829: continue;
1830:
1831: i = strlen(k->text);
1832: if (s + i + 1 >= be)
1833: break;
1834:
1835: if (s != t)
1836: *s++ = ',';
1837: memcpy(s, k->text, i);
1838: s += i;
1839: }
1840: if (s+2 >= be)
1841: break;
1842:
1843: *s++ = '"';
1844: *s = '\0';
1845: ctl_putdata(buf, (unsigned)(s - buf), 0);
1846: }
1847: break;
1848: #ifdef OPENSSL
1849: case CP_FLAGS:
1850: if (peer->crypto)
1851: ctl_puthex(peer_var[CP_FLAGS].text, peer->crypto);
1852: break;
1853:
1854: case CP_SIGNATURE:
1855: if (peer->crypto) {
1856: const EVP_MD *dp;
1857:
1858: dp = EVP_get_digestbynid(peer->crypto >> 16);
1859: strcpy(str, OBJ_nid2ln(EVP_MD_pkey_type(dp)));
1860: ctl_putstr(peer_var[CP_SIGNATURE].text, str,
1861: strlen(str));
1862: }
1863: break;
1864:
1865: case CP_HOST:
1866: if (peer->subject != NULL)
1867: ctl_putstr(peer_var[CP_HOST].text,
1868: peer->subject, strlen(peer->subject));
1869: break;
1870:
1871: case CP_VALID: /* not used */
1872: break;
1873:
1874: case CP_INITSEQ:
1875: if ((ap = (struct autokey *)peer->recval.ptr) == NULL)
1876: break;
1877:
1878: ctl_putint(peer_var[CP_INITSEQ].text, ap->seq);
1879: ctl_puthex(peer_var[CP_INITKEY].text, ap->key);
1880: ctl_putfs(peer_var[CP_INITTSP].text,
1881: ntohl(peer->recval.tstamp));
1882: break;
1883: #endif /* OPENSSL */
1884: }
1885: }
1886:
1887:
1888: #ifdef REFCLOCK
1889: /*
1890: * ctl_putclock - output clock variables
1891: */
1892: static void
1893: ctl_putclock(
1894: int varid,
1895: struct refclockstat *clock_stat,
1896: int mustput
1897: )
1898: {
1899: switch(varid) {
1900:
1901: case CC_TYPE:
1902: if (mustput || clock_stat->clockdesc == NULL
1903: || *(clock_stat->clockdesc) == '\0') {
1904: ctl_putuint(clock_var[CC_TYPE].text, clock_stat->type);
1905: }
1906: break;
1907: case CC_TIMECODE:
1908: ctl_putstr(clock_var[CC_TIMECODE].text,
1909: clock_stat->p_lastcode,
1910: (unsigned)clock_stat->lencode);
1911: break;
1912:
1913: case CC_POLL:
1914: ctl_putuint(clock_var[CC_POLL].text, clock_stat->polls);
1915: break;
1916:
1917: case CC_NOREPLY:
1918: ctl_putuint(clock_var[CC_NOREPLY].text,
1919: clock_stat->noresponse);
1920: break;
1921:
1922: case CC_BADFORMAT:
1923: ctl_putuint(clock_var[CC_BADFORMAT].text,
1924: clock_stat->badformat);
1925: break;
1926:
1927: case CC_BADDATA:
1928: ctl_putuint(clock_var[CC_BADDATA].text,
1929: clock_stat->baddata);
1930: break;
1931:
1932: case CC_FUDGETIME1:
1933: if (mustput || (clock_stat->haveflags & CLK_HAVETIME1))
1934: ctl_putdbl(clock_var[CC_FUDGETIME1].text,
1935: clock_stat->fudgetime1 * 1e3);
1936: break;
1937:
1938: case CC_FUDGETIME2:
1939: if (mustput || (clock_stat->haveflags & CLK_HAVETIME2))
1940: ctl_putdbl(clock_var[CC_FUDGETIME2].text,
1941: clock_stat->fudgetime2 * 1e3);
1942: break;
1943:
1944: case CC_FUDGEVAL1:
1945: if (mustput || (clock_stat->haveflags & CLK_HAVEVAL1))
1946: ctl_putint(clock_var[CC_FUDGEVAL1].text,
1947: clock_stat->fudgeval1);
1948: break;
1949:
1950: case CC_FUDGEVAL2:
1951: if (mustput || (clock_stat->haveflags & CLK_HAVEVAL2)) {
1952: if (clock_stat->fudgeval1 > 1)
1953: ctl_putadr(clock_var[CC_FUDGEVAL2].text,
1954: clock_stat->fudgeval2, NULL);
1955: else
1956: ctl_putrefid(clock_var[CC_FUDGEVAL2].text,
1957: clock_stat->fudgeval2);
1958: }
1959: break;
1960:
1961: case CC_FLAGS:
1962: if (mustput || (clock_stat->haveflags & (CLK_HAVEFLAG1 |
1963: CLK_HAVEFLAG2 | CLK_HAVEFLAG3 | CLK_HAVEFLAG4)))
1964: ctl_putuint(clock_var[CC_FLAGS].text,
1965: clock_stat->flags);
1966: break;
1967:
1968: case CC_DEVICE:
1969: if (clock_stat->clockdesc == NULL ||
1970: *(clock_stat->clockdesc) == '\0') {
1971: if (mustput)
1972: ctl_putstr(clock_var[CC_DEVICE].text,
1973: "", 0);
1974: } else {
1975: ctl_putstr(clock_var[CC_DEVICE].text,
1976: clock_stat->clockdesc,
1977: strlen(clock_stat->clockdesc));
1978: }
1979: break;
1980:
1981: case CC_VARLIST:
1982: {
1983: char buf[CTL_MAX_DATA_LEN];
1984: register char *s, *t, *be;
1985: register const char *ss;
1986: register int i;
1987: register struct ctl_var *k;
1988:
1989: s = buf;
1990: be = buf + sizeof(buf);
1991: if (s + strlen(clock_var[CC_VARLIST].text) + 4 >
1992: be)
1993: break; /* really long var name */
1994:
1995: snprintf(s, sizeof(buf), "%s=\"",
1996: clock_var[CC_VARLIST].text);
1997: s += strlen(s);
1998: t = s;
1999:
2000: for (k = clock_var; !(k->flags & EOV); k++) {
2001: if (k->flags & PADDING)
2002: continue;
2003:
2004: i = strlen(k->text);
2005: if (s + i + 1 >= be)
2006: break;
2007:
2008: if (s != t)
2009: *s++ = ',';
2010: memcpy(s, k->text, i);
2011: s += i;
2012: }
2013:
2014: for (k = clock_stat->kv_list; k && !(k->flags &
2015: EOV); k++) {
2016: if (k->flags & PADDING)
2017: continue;
2018:
2019: ss = k->text;
2020: if (!ss)
2021: continue;
2022:
2023: while (*ss && *ss != '=')
2024: ss++;
2025: i = ss - k->text;
2026: if (s+i+1 >= be)
2027: break;
2028:
2029: if (s != t)
2030: *s++ = ',';
2031: memcpy(s, k->text, (unsigned)i);
2032: s += i;
2033: *s = '\0';
2034: }
2035: if (s+2 >= be)
2036: break;
2037:
2038: *s++ = '"';
2039: *s = '\0';
2040: ctl_putdata(buf, (unsigned)( s - buf ), 0);
2041: }
2042: break;
2043: }
2044: }
2045: #endif
2046:
2047:
2048:
2049: /*
2050: * ctl_getitem - get the next data item from the incoming packet
2051: */
2052: static struct ctl_var *
2053: ctl_getitem(
2054: struct ctl_var *var_list,
2055: char **data
2056: )
2057: {
2058: register struct ctl_var *v;
2059: register char *cp;
2060: register char *tp;
2061: static struct ctl_var eol = { 0, EOV, };
2062: static char buf[128];
2063:
2064: /*
2065: * Delete leading commas and white space
2066: */
2067: while (reqpt < reqend && (*reqpt == ',' ||
2068: isspace((unsigned char)*reqpt)))
2069: reqpt++;
2070: if (reqpt >= reqend)
2071: return (0);
2072:
2073: if (var_list == (struct ctl_var *)0)
2074: return (&eol);
2075:
2076: /*
2077: * Look for a first character match on the tag. If we find
2078: * one, see if it is a full match.
2079: */
2080: v = var_list;
2081: cp = reqpt;
2082: while (!(v->flags & EOV)) {
2083: if (!(v->flags & PADDING) && *cp == *(v->text)) {
2084: tp = v->text;
2085: while (*tp != '\0' && *tp != '=' && cp <
2086: reqend && *cp == *tp) {
2087: cp++;
2088: tp++;
2089: }
2090: if ((*tp == '\0') || (*tp == '=')) {
2091: while (cp < reqend && isspace((unsigned char)*cp))
2092: cp++;
2093: if (cp == reqend || *cp == ',') {
2094: buf[0] = '\0';
2095: *data = buf;
2096: if (cp < reqend)
2097: cp++;
2098: reqpt = cp;
2099: return v;
2100: }
2101: if (*cp == '=') {
2102: cp++;
2103: tp = buf;
2104: while (cp < reqend && isspace((unsigned char)*cp))
2105: cp++;
2106: while (cp < reqend && *cp != ',') {
2107: *tp++ = *cp++;
2108: if (tp >= buf + sizeof(buf)) {
2109: ctl_error(CERR_BADFMT);
2110: numctlbadpkts++;
2111: #if 0 /* Avoid possible DOS attack */
2112: /* If we get a smarter msyslog we can re-enable this */
2113: msyslog(LOG_WARNING,
2114: "Possible 'ntpdx' exploit from %s:%d (possibly spoofed)\n",
2115: stoa(rmt_addr), SRCPORT(rmt_addr)
2116: );
2117: #endif
2118: return (0);
2119: }
2120: }
2121: if (cp < reqend)
2122: cp++;
2123: *tp-- = '\0';
2124: while (tp >= buf) {
2125: if (!isspace((unsigned int)(*tp)))
2126: break;
2127: *tp-- = '\0';
2128: }
2129: reqpt = cp;
2130: *data = buf;
2131: return (v);
2132: }
2133: }
2134: cp = reqpt;
2135: }
2136: v++;
2137: }
2138: return v;
2139: }
2140:
2141:
2142: /*
2143: * control_unspec - response to an unspecified op-code
2144: */
2145: /*ARGSUSED*/
2146: static void
2147: control_unspec(
2148: struct recvbuf *rbufp,
2149: int restrict_mask
2150: )
2151: {
2152: struct peer *peer;
2153:
2154: /*
2155: * What is an appropriate response to an unspecified op-code?
2156: * I return no errors and no data, unless a specified assocation
2157: * doesn't exist.
2158: */
2159: if (res_associd != 0) {
2160: if ((peer = findpeerbyassoc(res_associd)) == 0) {
2161: ctl_error(CERR_BADASSOC);
2162: return;
2163: }
2164: rpkt.status = htons(ctlpeerstatus(peer));
2165: } else {
2166: rpkt.status = htons(ctlsysstatus());
2167: }
2168: ctl_flushpkt(0);
2169: }
2170:
2171:
2172: /*
2173: * read_status - return either a list of associd's, or a particular
2174: * peer's status.
2175: */
2176: /*ARGSUSED*/
2177: static void
2178: read_status(
2179: struct recvbuf *rbufp,
2180: int restrict_mask
2181: )
2182: {
2183: register int i;
2184: register struct peer *peer;
2185: u_short ass_stat[CTL_MAX_DATA_LEN / sizeof(u_short)];
2186:
2187: #ifdef DEBUG
2188: if (debug > 2)
2189: printf("read_status: ID %d\n", res_associd);
2190: #endif
2191: /*
2192: * Two choices here. If the specified association ID is
2193: * zero we return all known assocation ID's. Otherwise
2194: * we return a bunch of stuff about the particular peer.
2195: */
2196: if (res_associd == 0) {
2197: register int n;
2198:
2199: n = 0;
2200: rpkt.status = htons(ctlsysstatus());
2201: for (i = 0; i < NTP_HASH_SIZE; i++) {
2202: for (peer = assoc_hash[i]; peer != 0;
2203: peer = peer->ass_next) {
2204: ass_stat[n++] = htons(peer->associd);
2205: ass_stat[n++] =
2206: htons(ctlpeerstatus(peer));
2207: if (n ==
2208: CTL_MAX_DATA_LEN/sizeof(u_short)) {
2209: ctl_putdata((char *)ass_stat,
2210: n * sizeof(u_short), 1);
2211: n = 0;
2212: }
2213: }
2214: }
2215:
2216: if (n != 0)
2217: ctl_putdata((char *)ass_stat, n *
2218: sizeof(u_short), 1);
2219: ctl_flushpkt(0);
2220: } else {
2221: peer = findpeerbyassoc(res_associd);
2222: if (peer == 0) {
2223: ctl_error(CERR_BADASSOC);
2224: } else {
2225: register u_char *cp;
2226:
2227: rpkt.status = htons(ctlpeerstatus(peer));
2228: if (res_authokay)
2229: peer->num_events = 0;
2230: /*
2231: * For now, output everything we know about the
2232: * peer. May be more selective later.
2233: */
2234: for (cp = def_peer_var; *cp != 0; cp++)
2235: ctl_putpeer((int)*cp, peer);
2236: ctl_flushpkt(0);
2237: }
2238: }
2239: }
2240:
2241:
2242: /*
2243: * read_variables - return the variables the caller asks for
2244: */
2245: /*ARGSUSED*/
2246: static void
2247: read_variables(
2248: struct recvbuf *rbufp,
2249: int restrict_mask
2250: )
2251: {
2252: register struct ctl_var *v;
2253: register int i;
2254: char *valuep;
2255: u_char *wants;
2256: unsigned int gotvar = (CS_MAXCODE > CP_MAXCODE) ? (CS_MAXCODE +
2257: 1) : (CP_MAXCODE + 1);
2258: if (res_associd == 0) {
2259: /*
2260: * Wants system variables. Figure out which he wants
2261: * and give them to him.
2262: */
2263: rpkt.status = htons(ctlsysstatus());
2264: if (res_authokay)
2265: ctl_sys_num_events = 0;
2266: gotvar += count_var(ext_sys_var);
2267: wants = (u_char *)emalloc(gotvar);
2268: memset((char *)wants, 0, gotvar);
2269: gotvar = 0;
2270: while ((v = ctl_getitem(sys_var, &valuep)) != 0) {
2271: if (v->flags & EOV) {
2272: if ((v = ctl_getitem(ext_sys_var,
2273: &valuep)) != 0) {
2274: if (v->flags & EOV) {
2275: ctl_error(CERR_UNKNOWNVAR);
2276: free((char *)wants);
2277: return;
2278: }
2279: wants[CS_MAXCODE + 1 +
2280: v->code] = 1;
2281: gotvar = 1;
2282: continue;
2283: } else {
2284: break; /* shouldn't happen ! */
2285: }
2286: }
2287: wants[v->code] = 1;
2288: gotvar = 1;
2289: }
2290: if (gotvar) {
2291: for (i = 1; i <= CS_MAXCODE; i++)
2292: if (wants[i])
2293: ctl_putsys(i);
2294: for (i = 0; ext_sys_var &&
2295: !(ext_sys_var[i].flags & EOV); i++)
2296: if (wants[i + CS_MAXCODE + 1])
2297: ctl_putdata(ext_sys_var[i].text,
2298: strlen(ext_sys_var[i].text),
2299: 0);
2300: } else {
2301: register u_char *cs;
2302: register struct ctl_var *kv;
2303:
2304: for (cs = def_sys_var; *cs != 0; cs++)
2305: ctl_putsys((int)*cs);
2306: for (kv = ext_sys_var; kv && !(kv->flags & EOV);
2307: kv++)
2308: if (kv->flags & DEF)
2309: ctl_putdata(kv->text,
2310: strlen(kv->text), 0);
2311: }
2312: free((char *)wants);
2313: } else {
2314: register struct peer *peer;
2315:
2316: /*
2317: * Wants info for a particular peer. See if we know
2318: * the guy.
2319: */
2320: peer = findpeerbyassoc(res_associd);
2321: if (peer == 0) {
2322: ctl_error(CERR_BADASSOC);
2323: return;
2324: }
2325: rpkt.status = htons(ctlpeerstatus(peer));
2326: if (res_authokay)
2327: peer->num_events = 0;
2328: wants = (u_char *)emalloc(gotvar);
2329: memset((char*)wants, 0, gotvar);
2330: gotvar = 0;
2331: while ((v = ctl_getitem(peer_var, &valuep)) != 0) {
2332: if (v->flags & EOV) {
2333: ctl_error(CERR_UNKNOWNVAR);
2334: free((char *)wants);
2335: return;
2336: }
2337: wants[v->code] = 1;
2338: gotvar = 1;
2339: }
2340: if (gotvar) {
2341: for (i = 1; i <= CP_MAXCODE; i++)
2342: if (wants[i])
2343: ctl_putpeer(i, peer);
2344: } else {
2345: register u_char *cp;
2346:
2347: for (cp = def_peer_var; *cp != 0; cp++)
2348: ctl_putpeer((int)*cp, peer);
2349: }
2350: free((char *)wants);
2351: }
2352: ctl_flushpkt(0);
2353: }
2354:
2355:
2356: /*
2357: * write_variables - write into variables. We only allow leap bit
2358: * writing this way.
2359: */
2360: /*ARGSUSED*/
2361: static void
2362: write_variables(
2363: struct recvbuf *rbufp,
2364: int restrict_mask
2365: )
2366: {
2367: register struct ctl_var *v;
2368: register int ext_var;
2369: char *valuep;
2370: long val = 0;
2371:
2372: /*
2373: * If he's trying to write into a peer tell him no way
2374: */
2375: if (res_associd != 0) {
2376: ctl_error(CERR_PERMISSION);
2377: return;
2378: }
2379:
2380: /*
2381: * Set status
2382: */
2383: rpkt.status = htons(ctlsysstatus());
2384:
2385: /*
2386: * Look through the variables. Dump out at the first sign of
2387: * trouble.
2388: */
2389: while ((v = ctl_getitem(sys_var, &valuep)) != 0) {
2390: ext_var = 0;
2391: if (v->flags & EOV) {
2392: if ((v = ctl_getitem(ext_sys_var, &valuep)) !=
2393: 0) {
2394: if (v->flags & EOV) {
2395: ctl_error(CERR_UNKNOWNVAR);
2396: return;
2397: }
2398: ext_var = 1;
2399: } else {
2400: break;
2401: }
2402: }
2403: if (!(v->flags & CAN_WRITE)) {
2404: ctl_error(CERR_PERMISSION);
2405: return;
2406: }
2407: if (!ext_var && (*valuep == '\0' || !atoint(valuep,
2408: &val))) {
2409: ctl_error(CERR_BADFMT);
2410: return;
2411: }
2412: if (!ext_var && (val & ~LEAP_NOTINSYNC) != 0) {
2413: ctl_error(CERR_BADVALUE);
2414: return;
2415: }
2416:
2417: if (ext_var) {
2418: char *s = (char *)emalloc(strlen(v->text) +
2419: strlen(valuep) + 2);
2420: const char *t;
2421: char *tt = s;
2422:
2423: t = v->text;
2424: while (*t && *t != '=')
2425: *tt++ = *t++;
2426:
2427: *tt++ = '=';
2428: strcat(tt, valuep);
2429: set_sys_var(s, strlen(s)+1, v->flags);
2430: free(s);
2431: } else {
2432: /*
2433: * This one seems sane. Save it.
2434: */
2435: switch(v->code) {
2436:
2437: case CS_LEAP:
2438: default:
2439: ctl_error(CERR_UNSPEC); /* really */
2440: return;
2441: }
2442: }
2443: }
2444:
2445: /*
2446: * If we got anything, do it. xxx nothing to do ***
2447: */
2448: /*
2449: if (leapind != ~0 || leapwarn != ~0) {
2450: if (!leap_setleap((int)leapind, (int)leapwarn)) {
2451: ctl_error(CERR_PERMISSION);
2452: return;
2453: }
2454: }
2455: */
2456: ctl_flushpkt(0);
2457: }
2458:
2459: /*
2460: * configure() processes ntpq :config/config-from-file, allowing
2461: * generic runtime reconfiguration.
2462: */
2463: static void configure(
2464: struct recvbuf *rbufp,
2465: int restrict_mask
2466: )
2467: {
2468: size_t data_count;
2469: int retval;
2470: int replace_nl;
2471:
2472: /* I haven't yet implemented changes to an existing association.
2473: * Hence check if the association id is 0
2474: */
2475: if (res_associd != 0) {
2476: ctl_error(CERR_BADVALUE);
2477: return;
2478: }
2479:
2480: if (restrict_mask & RES_NOMODIFY) {
2481: snprintf(remote_config.err_msg,
2482: sizeof(remote_config.err_msg),
2483: "runtime configuration prohibited by restrict ... nomodify");
2484: ctl_putdata(remote_config.err_msg,
2485: strlen(remote_config.err_msg), 0);
2486: ctl_flushpkt(0);
2487: msyslog(LOG_NOTICE,
2488: "runtime config from %s rejected due to nomodify restriction",
2489: stoa(&rbufp->recv_srcadr));
2490: return;
2491: }
2492:
2493: /* Initialize the remote config buffer */
2494: data_count = reqend - reqpt;
2495: memcpy(remote_config.buffer, reqpt, data_count);
2496: if (data_count > 0
2497: && '\n' != remote_config.buffer[data_count - 1])
2498: remote_config.buffer[data_count++] = '\n';
2499: remote_config.buffer[data_count] = '\0';
2500: remote_config.pos = 0;
2501: remote_config.err_pos = 0;
2502: remote_config.no_errors = 0;
2503:
2504: /* do not include terminating newline in log */
2505: if (data_count > 0
2506: && '\n' == remote_config.buffer[data_count - 1]) {
2507: remote_config.buffer[data_count - 1] = '\0';
2508: replace_nl = 1;
2509: } else
2510: replace_nl = 0;
2511:
2512: DPRINTF(1, ("Got Remote Configuration Command: %s\n",
2513: remote_config.buffer));
2514: msyslog(LOG_NOTICE, "%s config: %s",
2515: stoa(&rbufp->recv_srcadr),
2516: remote_config.buffer);
2517:
2518: if (replace_nl)
2519: remote_config.buffer[data_count - 1] = '\n';
2520:
2521: config_remotely(&rbufp->recv_srcadr);
2522:
2523: /*
2524: * Check if errors were reported. If not, output 'Config
2525: * Succeeded'. Else output the error count. It would be nice
2526: * to output any parser error messages.
2527: */
2528: if (0 == remote_config.no_errors) {
2529: retval = snprintf(remote_config.err_msg,
2530: sizeof(remote_config.err_msg),
2531: "Config Succeeded");
2532: if (retval > 0)
2533: remote_config.err_pos += retval;
2534: }
2535:
2536: ctl_putdata(remote_config.err_msg, remote_config.err_pos, 0);
2537: ctl_flushpkt(0);
2538:
2539: DPRINTF(1, ("Reply: %s\n", remote_config.err_msg));
2540:
2541: if (remote_config.no_errors > 0)
2542: msyslog(LOG_NOTICE, "%d error in %s config",
2543: remote_config.no_errors,
2544: stoa(&rbufp->recv_srcadr));
2545: }
2546:
2547:
2548: /*
2549: * read_clock_status - return clock radio status
2550: */
2551: /*ARGSUSED*/
2552: static void
2553: read_clock_status(
2554: struct recvbuf *rbufp,
2555: int restrict_mask
2556: )
2557: {
2558: #ifndef REFCLOCK
2559: /*
2560: * If no refclock support, no data to return
2561: */
2562: ctl_error(CERR_BADASSOC);
2563: #else
2564: register struct ctl_var *v;
2565: register int i;
2566: register struct peer *peer;
2567: char *valuep;
2568: u_char *wants;
2569: unsigned int gotvar;
2570: struct refclockstat clock_stat;
2571:
2572: if (res_associd == 0) {
2573:
2574: /*
2575: * Find a clock for this jerk. If the system peer
2576: * is a clock use it, else search the hash tables
2577: * for one.
2578: */
2579: if (sys_peer != 0 && (sys_peer->flags & FLAG_REFCLOCK))
2580: {
2581: peer = sys_peer;
2582: } else {
2583: peer = 0;
2584: for (i = 0; peer == 0 && i < NTP_HASH_SIZE; i++) {
2585: for (peer = assoc_hash[i]; peer != 0;
2586: peer = peer->ass_next) {
2587: if (peer->flags & FLAG_REFCLOCK)
2588: break;
2589: }
2590: }
2591: if (peer == 0) {
2592: ctl_error(CERR_BADASSOC);
2593: return;
2594: }
2595: }
2596: } else {
2597: peer = findpeerbyassoc(res_associd);
2598: if (peer == 0 || !(peer->flags & FLAG_REFCLOCK)) {
2599: ctl_error(CERR_BADASSOC);
2600: return;
2601: }
2602: }
2603:
2604: /*
2605: * If we got here we have a peer which is a clock. Get his
2606: * status.
2607: */
2608: clock_stat.kv_list = (struct ctl_var *)0;
2609: refclock_control(&peer->srcadr, (struct refclockstat *)0,
2610: &clock_stat);
2611:
2612: /*
2613: * Look for variables in the packet.
2614: */
2615: rpkt.status = htons(ctlclkstatus(&clock_stat));
2616: gotvar = CC_MAXCODE + 1 + count_var(clock_stat.kv_list);
2617: wants = (u_char *)emalloc(gotvar);
2618: memset((char*)wants, 0, gotvar);
2619: gotvar = 0;
2620: while ((v = ctl_getitem(clock_var, &valuep)) != 0) {
2621: if (v->flags & EOV) {
2622: if ((v = ctl_getitem(clock_stat.kv_list,
2623: &valuep)) != 0) {
2624: if (v->flags & EOV) {
2625: ctl_error(CERR_UNKNOWNVAR);
2626: free((char*)wants);
2627: free_varlist(clock_stat.kv_list);
2628: return;
2629: }
2630: wants[CC_MAXCODE + 1 + v->code] = 1;
2631: gotvar = 1;
2632: continue;
2633: } else {
2634: break; /* shouldn't happen ! */
2635: }
2636: }
2637: wants[v->code] = 1;
2638: gotvar = 1;
2639: }
2640:
2641: if (gotvar) {
2642: for (i = 1; i <= CC_MAXCODE; i++)
2643: if (wants[i])
2644: ctl_putclock(i, &clock_stat, 1);
2645: for (i = 0; clock_stat.kv_list &&
2646: !(clock_stat.kv_list[i].flags & EOV); i++)
2647: if (wants[i + CC_MAXCODE + 1])
2648: ctl_putdata(clock_stat.kv_list[i].text,
2649: strlen(clock_stat.kv_list[i].text),
2650: 0);
2651: } else {
2652: register u_char *cc;
2653: register struct ctl_var *kv;
2654:
2655: for (cc = def_clock_var; *cc != 0; cc++)
2656: ctl_putclock((int)*cc, &clock_stat, 0);
2657: for (kv = clock_stat.kv_list; kv && !(kv->flags & EOV);
2658: kv++)
2659: if (kv->flags & DEF)
2660: ctl_putdata(kv->text, strlen(kv->text),
2661: 0);
2662: }
2663:
2664: free((char*)wants);
2665: free_varlist(clock_stat.kv_list);
2666:
2667: ctl_flushpkt(0);
2668: #endif
2669: }
2670:
2671:
2672: /*
2673: * write_clock_status - we don't do this
2674: */
2675: /*ARGSUSED*/
2676: static void
2677: write_clock_status(
2678: struct recvbuf *rbufp,
2679: int restrict_mask
2680: )
2681: {
2682: ctl_error(CERR_PERMISSION);
2683: }
2684:
2685: /*
2686: * Trap support from here on down. We send async trap messages when the
2687: * upper levels report trouble. Traps can by set either by control
2688: * messages or by configuration.
2689: */
2690: /*
2691: * set_trap - set a trap in response to a control message
2692: */
2693: static void
2694: set_trap(
2695: struct recvbuf *rbufp,
2696: int restrict_mask
2697: )
2698: {
2699: int traptype;
2700:
2701: /*
2702: * See if this guy is allowed
2703: */
2704: if (restrict_mask & RES_NOTRAP) {
2705: ctl_error(CERR_PERMISSION);
2706: return;
2707: }
2708:
2709: /*
2710: * Determine his allowed trap type.
2711: */
2712: traptype = TRAP_TYPE_PRIO;
2713: if (restrict_mask & RES_LPTRAP)
2714: traptype = TRAP_TYPE_NONPRIO;
2715:
2716: /*
2717: * Call ctlsettrap() to do the work. Return
2718: * an error if it can't assign the trap.
2719: */
2720: if (!ctlsettrap(&rbufp->recv_srcadr, rbufp->dstadr, traptype,
2721: (int)res_version))
2722: ctl_error(CERR_NORESOURCE);
2723: ctl_flushpkt(0);
2724: }
2725:
2726:
2727: /*
2728: * unset_trap - unset a trap in response to a control message
2729: */
2730: static void
2731: unset_trap(
2732: struct recvbuf *rbufp,
2733: int restrict_mask
2734: )
2735: {
2736: int traptype;
2737:
2738: /*
2739: * We don't prevent anyone from removing his own trap unless the
2740: * trap is configured. Note we also must be aware of the
2741: * possibility that restriction flags were changed since this
2742: * guy last set his trap. Set the trap type based on this.
2743: */
2744: traptype = TRAP_TYPE_PRIO;
2745: if (restrict_mask & RES_LPTRAP)
2746: traptype = TRAP_TYPE_NONPRIO;
2747:
2748: /*
2749: * Call ctlclrtrap() to clear this out.
2750: */
2751: if (!ctlclrtrap(&rbufp->recv_srcadr, rbufp->dstadr, traptype))
2752: ctl_error(CERR_BADASSOC);
2753: ctl_flushpkt(0);
2754: }
2755:
2756:
2757: /*
2758: * ctlsettrap - called to set a trap
2759: */
2760: int
2761: ctlsettrap(
2762: sockaddr_u *raddr,
2763: struct interface *linter,
2764: int traptype,
2765: int version
2766: )
2767: {
2768: register struct ctl_trap *tp;
2769: register struct ctl_trap *tptouse;
2770:
2771: /*
2772: * See if we can find this trap. If so, we only need update
2773: * the flags and the time.
2774: */
2775: if ((tp = ctlfindtrap(raddr, linter)) != NULL) {
2776: switch (traptype) {
2777:
2778: case TRAP_TYPE_CONFIG:
2779: tp->tr_flags = TRAP_INUSE|TRAP_CONFIGURED;
2780: break;
2781:
2782: case TRAP_TYPE_PRIO:
2783: if (tp->tr_flags & TRAP_CONFIGURED)
2784: return (1); /* don't change anything */
2785: tp->tr_flags = TRAP_INUSE;
2786: break;
2787:
2788: case TRAP_TYPE_NONPRIO:
2789: if (tp->tr_flags & TRAP_CONFIGURED)
2790: return (1); /* don't change anything */
2791: tp->tr_flags = TRAP_INUSE|TRAP_NONPRIO;
2792: break;
2793: }
2794: tp->tr_settime = current_time;
2795: tp->tr_resets++;
2796: return (1);
2797: }
2798:
2799: /*
2800: * First we heard of this guy. Try to find a trap structure
2801: * for him to use, clearing out lesser priority guys if we
2802: * have to. Clear out anyone who's expired while we're at it.
2803: */
2804: tptouse = NULL;
2805: for (tp = ctl_trap; tp < &ctl_trap[CTL_MAXTRAPS]; tp++) {
2806: if ((tp->tr_flags & TRAP_INUSE) &&
2807: !(tp->tr_flags & TRAP_CONFIGURED) &&
2808: ((tp->tr_settime + CTL_TRAPTIME) > current_time)) {
2809: tp->tr_flags = 0;
2810: num_ctl_traps--;
2811: }
2812: if (!(tp->tr_flags & TRAP_INUSE)) {
2813: tptouse = tp;
2814: } else if (!(tp->tr_flags & TRAP_CONFIGURED)) {
2815: switch (traptype) {
2816:
2817: case TRAP_TYPE_CONFIG:
2818: if (tptouse == NULL) {
2819: tptouse = tp;
2820: break;
2821: }
2822: if (tptouse->tr_flags & TRAP_NONPRIO &&
2823: !(tp->tr_flags & TRAP_NONPRIO))
2824: break;
2825:
2826: if (!(tptouse->tr_flags & TRAP_NONPRIO)
2827: && tp->tr_flags & TRAP_NONPRIO) {
2828: tptouse = tp;
2829: break;
2830: }
2831: if (tptouse->tr_origtime <
2832: tp->tr_origtime)
2833: tptouse = tp;
2834: break;
2835:
2836: case TRAP_TYPE_PRIO:
2837: if (tp->tr_flags & TRAP_NONPRIO) {
2838: if (tptouse == NULL ||
2839: (tptouse->tr_flags &
2840: TRAP_INUSE &&
2841: tptouse->tr_origtime <
2842: tp->tr_origtime))
2843: tptouse = tp;
2844: }
2845: break;
2846:
2847: case TRAP_TYPE_NONPRIO:
2848: break;
2849: }
2850: }
2851: }
2852:
2853: /*
2854: * If we don't have room for him return an error.
2855: */
2856: if (tptouse == NULL)
2857: return (0);
2858:
2859: /*
2860: * Set up this structure for him.
2861: */
2862: tptouse->tr_settime = tptouse->tr_origtime = current_time;
2863: tptouse->tr_count = tptouse->tr_resets = 0;
2864: tptouse->tr_sequence = 1;
2865: tptouse->tr_addr = *raddr;
2866: tptouse->tr_localaddr = linter;
2867: tptouse->tr_version = (u_char) version;
2868: tptouse->tr_flags = TRAP_INUSE;
2869: if (traptype == TRAP_TYPE_CONFIG)
2870: tptouse->tr_flags |= TRAP_CONFIGURED;
2871: else if (traptype == TRAP_TYPE_NONPRIO)
2872: tptouse->tr_flags |= TRAP_NONPRIO;
2873: num_ctl_traps++;
2874: return (1);
2875: }
2876:
2877:
2878: /*
2879: * ctlclrtrap - called to clear a trap
2880: */
2881: int
2882: ctlclrtrap(
2883: sockaddr_u *raddr,
2884: struct interface *linter,
2885: int traptype
2886: )
2887: {
2888: register struct ctl_trap *tp;
2889:
2890: if ((tp = ctlfindtrap(raddr, linter)) == NULL)
2891: return (0);
2892:
2893: if (tp->tr_flags & TRAP_CONFIGURED
2894: && traptype != TRAP_TYPE_CONFIG)
2895: return (0);
2896:
2897: tp->tr_flags = 0;
2898: num_ctl_traps--;
2899: return (1);
2900: }
2901:
2902:
2903: /*
2904: * ctlfindtrap - find a trap given the remote and local addresses
2905: */
2906: static struct ctl_trap *
2907: ctlfindtrap(
2908: sockaddr_u *raddr,
2909: struct interface *linter
2910: )
2911: {
2912: register struct ctl_trap *tp;
2913:
2914: for (tp = ctl_trap; tp < &ctl_trap[CTL_MAXTRAPS]; tp++) {
2915: if ((tp->tr_flags & TRAP_INUSE)
2916: && (NSRCPORT(raddr) == NSRCPORT(&tp->tr_addr))
2917: && SOCK_EQ(raddr, &tp->tr_addr)
2918: && (linter == tp->tr_localaddr) )
2919: return (tp);
2920: }
2921: return (struct ctl_trap *)NULL;
2922: }
2923:
2924:
2925: /*
2926: * report_event - report an event to the trappers
2927: */
2928: void
2929: report_event(
2930: int err, /* error code */
2931: struct peer *peer, /* peer structure pointer */
2932: const char *str /* protostats string */
2933: )
2934: {
2935: char statstr[NTP_MAXSTRLEN];
2936: int i;
2937: size_t len;
2938:
2939: /*
2940: * Report the error to the protostats file, system log and
2941: * trappers.
2942: */
2943: if (peer == NULL) {
2944:
2945: /*
2946: * Discard a system report if the number of reports of
2947: * the same type exceeds the maximum.
2948: */
2949: if (ctl_sys_last_event != (u_char)err)
2950: ctl_sys_num_events= 0;
2951: if (ctl_sys_num_events >= CTL_SYS_MAXEVENTS)
2952: return;
2953:
2954: ctl_sys_last_event = (u_char)err;
2955: ctl_sys_num_events++;
2956: snprintf(statstr, NTP_MAXSTRLEN,
2957: "0.0.0.0 %04x %02x %s",
2958: ctlsysstatus(), err, eventstr(err));
2959: if (str != NULL) {
2960: len = strlen(statstr);
2961: snprintf(statstr + len, sizeof(statstr) - len,
2962: " %s", str);
2963: }
2964: NLOG(NLOG_SYSEVENT)
2965: msyslog(LOG_INFO, statstr);
2966: } else {
2967:
2968: /*
2969: * Discard a peer report if the number of reports of
2970: * the same type exceeds the maximum for that peer.
2971: */
2972: char *src;
2973: u_char errlast;
2974:
2975: errlast = (u_char)err & ~PEER_EVENT;
2976: if (peer->last_event == errlast)
2977: peer->num_events = 0;
2978: if (peer->num_events >= CTL_PEER_MAXEVENTS)
2979: return;
2980:
2981: peer->last_event = errlast;
2982: peer->num_events++;
2983: if (ISREFCLOCKADR(&peer->srcadr))
2984: src = refnumtoa(&peer->srcadr);
2985: else
2986: src = stoa(&peer->srcadr);
2987:
2988: snprintf(statstr, NTP_MAXSTRLEN,
2989: "%s %04x %02x %s", src,
2990: ctlpeerstatus(peer), err, eventstr(err));
2991: if (str != NULL) {
2992: len = strlen(statstr);
2993: snprintf(statstr + len, sizeof(statstr) - len,
2994: " %s", str);
2995: }
2996: NLOG(NLOG_PEEREVENT)
2997: msyslog(LOG_INFO, statstr);
2998: }
2999: record_proto_stats(statstr);
3000: #if DEBUG
3001: if (debug)
3002: printf("event at %lu %s\n", current_time, statstr);
3003: #endif
3004:
3005: /*
3006: * If no trappers, return.
3007: */
3008: if (num_ctl_traps <= 0)
3009: return;
3010:
3011: /*
3012: * Set up the outgoing packet variables
3013: */
3014: res_opcode = CTL_OP_ASYNCMSG;
3015: res_offset = 0;
3016: res_async = 1;
3017: res_authenticate = 0;
3018: datapt = rpkt.data;
3019: dataend = &(rpkt.data[CTL_MAX_DATA_LEN]);
3020: if (!(err & PEER_EVENT)) {
3021: rpkt.associd = 0;
3022: rpkt.status = htons(ctlsysstatus());
3023:
3024: /*
3025: * For now, put everything we know about system
3026: * variables. Don't send crypto strings.
3027: */
3028: for (i = 1; i <= CS_MAXCODE; i++) {
3029: #ifdef OPENSSL
3030: if (i > CS_VARLIST)
3031: continue;
3032: #endif /* OPENSSL */
3033: ctl_putsys(i);
3034: }
3035: } else {
3036: NTP_INSIST(peer != NULL);
3037: rpkt.associd = htons(peer->associd);
3038: rpkt.status = htons(ctlpeerstatus(peer));
3039:
3040: /*
3041: * Dump it all. Later, maybe less.
3042: */
3043: for (i = 1; i <= CP_MAXCODE; i++) {
3044: #ifdef OPENSSL
3045: if (i > CP_VARLIST)
3046: continue;
3047: #endif /* OPENSSL */
3048: ctl_putpeer(i, peer);
3049: }
3050: #ifdef REFCLOCK
3051: /*
3052: * for clock exception events: add clock variables to
3053: * reflect info on exception
3054: */
3055: if (err == PEVNT_CLOCK) {
3056: struct refclockstat clock_stat;
3057: struct ctl_var *kv;
3058:
3059: clock_stat.kv_list = (struct ctl_var *)0;
3060: refclock_control(&peer->srcadr,
3061: (struct refclockstat *)0, &clock_stat);
3062:
3063: ctl_puthex("refclockstatus",
3064: ctlclkstatus(&clock_stat));
3065:
3066: for (i = 1; i <= CC_MAXCODE; i++)
3067: ctl_putclock(i, &clock_stat, 0);
3068: for (kv = clock_stat.kv_list; kv &&
3069: !(kv->flags & EOV); kv++)
3070: if (kv->flags & DEF)
3071: ctl_putdata(kv->text,
3072: strlen(kv->text), 0);
3073: free_varlist(clock_stat.kv_list);
3074: }
3075: #endif /* REFCLOCK */
3076: }
3077:
3078: /*
3079: * We're done, return.
3080: */
3081: ctl_flushpkt(0);
3082: }
3083:
3084:
3085: /*
3086: * ctl_clr_stats - clear stat counters
3087: */
3088: void
3089: ctl_clr_stats(void)
3090: {
3091: ctltimereset = current_time;
3092: numctlreq = 0;
3093: numctlbadpkts = 0;
3094: numctlresponses = 0;
3095: numctlfrags = 0;
3096: numctlerrors = 0;
3097: numctlfrags = 0;
3098: numctltooshort = 0;
3099: numctlinputresp = 0;
3100: numctlinputfrag = 0;
3101: numctlinputerr = 0;
3102: numctlbadoffset = 0;
3103: numctlbadversion = 0;
3104: numctldatatooshort = 0;
3105: numctlbadop = 0;
3106: numasyncmsgs = 0;
3107: }
3108:
3109: static u_long
3110: count_var(
3111: struct ctl_var *k
3112: )
3113: {
3114: register u_long c;
3115:
3116: if (!k)
3117: return (0);
3118:
3119: c = 0;
3120: while (!(k++->flags & EOV))
3121: c++;
3122: return (c);
3123: }
3124:
3125: char *
3126: add_var(
3127: struct ctl_var **kv,
3128: u_long size,
3129: u_short def
3130: )
3131: {
3132: register u_long c;
3133: register struct ctl_var *k;
3134:
3135: c = count_var(*kv);
3136:
3137: k = *kv;
3138: *kv = (struct ctl_var *)emalloc((c+2)*sizeof(struct ctl_var));
3139: if (k) {
3140: memmove((char *)*kv, (char *)k,
3141: sizeof(struct ctl_var)*c);
3142: free((char *)k);
3143: }
3144: (*kv)[c].code = (u_short) c;
3145: (*kv)[c].text = (char *)emalloc(size);
3146: (*kv)[c].flags = def;
3147: (*kv)[c+1].code = 0;
3148: (*kv)[c+1].text = (char *)0;
3149: (*kv)[c+1].flags = EOV;
3150: return (char *)(*kv)[c].text;
3151: }
3152:
3153: void
3154: set_var(
3155: struct ctl_var **kv,
3156: const char *data,
3157: u_long size,
3158: u_short def
3159: )
3160: {
3161: register struct ctl_var *k;
3162: register const char *s;
3163: register const char *t;
3164: char *td;
3165:
3166: if (!data || !size)
3167: return;
3168:
3169: k = *kv;
3170: if (k != NULL) {
3171: while (!(k->flags & EOV)) {
3172: s = data;
3173: t = k->text;
3174: if (t) {
3175: while (*t != '=' && *s - *t == 0) {
3176: s++;
3177: t++;
3178: }
3179: if (*s == *t && ((*t == '=') || !*t)) {
3180: free((void *)k->text);
3181: td = (char *)emalloc(size);
3182: memmove(td, data, size);
3183: k->text =td;
3184: k->flags = def;
3185: return;
3186: }
3187: } else {
3188: td = (char *)emalloc(size);
3189: memmove(td, data, size);
3190: k->text = td;
3191: k->flags = def;
3192: return;
3193: }
3194: k++;
3195: }
3196: }
3197: td = add_var(kv, size, def);
3198: memmove(td, data, size);
3199: }
3200:
3201: void
3202: set_sys_var(
3203: const char *data,
3204: u_long size,
3205: u_short def
3206: )
3207: {
3208: set_var(&ext_sys_var, data, size, def);
3209: }
3210:
3211: void
3212: free_varlist(
3213: struct ctl_var *kv
3214: )
3215: {
3216: struct ctl_var *k;
3217: if (kv) {
3218: for (k = kv; !(k->flags & EOV); k++)
3219: free((void *)k->text);
3220: free((void *)kv);
3221: }
3222: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ntp_control.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd