statestr.c revision 358659 
1/*
2 * pretty printing of status information
3 */
4#ifdef HAVE_CONFIG_H
5#include <config.h>
6#endif
7#include <stdio.h>
8#include "ntp_stdlib.h"
9#include "ntp_fp.h"
10#include "ntp.h"
11#include "lib_strbuf.h"
12#include "ntp_refclock.h"
13#include "ntp_control.h"
14#include "ntp_string.h"
15#ifdef KERNEL_PLL
16# include "ntp_syscall.h"
17#endif
18
19
20/*
21 * Structure for turning various constants into a readable string.
22 */
23struct codestring {
24	int code;
25	const char * const string1;
26	const char * const string0;
27};
28
29/*
30 * Leap status (leap)
31 */
32static const struct codestring leap_codes[] = {
33	{ LEAP_NOWARNING,	"leap_none",	0 },
34	{ LEAP_ADDSECOND,	"leap_add_sec",	0 },
35	{ LEAP_DELSECOND,	"leap_del_sec",	0 },
36	{ LEAP_NOTINSYNC,	"leap_alarm",	0 },
37	{ -1,			"leap",		0 }
38};
39
40/*
41 * Clock source status (sync)
42 */
43static const struct codestring sync_codes[] = {
44	{ CTL_SST_TS_UNSPEC,	"sync_unspec",		0 },
45	{ CTL_SST_TS_ATOM,	"sync_pps",		0 },
46	{ CTL_SST_TS_LF,	"sync_lf_radio",	0 },
47	{ CTL_SST_TS_HF,	"sync_hf_radio",	0 },
48	{ CTL_SST_TS_UHF,	"sync_uhf_radio",	0 },
49	{ CTL_SST_TS_LOCAL,	"sync_local",		0 },
50	{ CTL_SST_TS_NTP,	"sync_ntp",		0 },
51	{ CTL_SST_TS_UDPTIME,	"sync_other",		0 },
52	{ CTL_SST_TS_WRSTWTCH,	"sync_wristwatch",	0 },
53	{ CTL_SST_TS_TELEPHONE,	"sync_telephone",	0 },
54	{ -1,			"sync",			0 }
55};
56
57/*
58 * Peer selection status (sel)
59 */
60static const struct codestring select_codes[] = {
61	{ CTL_PST_SEL_REJECT,	"sel_reject",		0 },
62	{ CTL_PST_SEL_SANE,	"sel_falsetick",	0 },
63	{ CTL_PST_SEL_CORRECT,	"sel_excess",		0 },
64	{ CTL_PST_SEL_SELCAND,	"sel_outlier",		0 },
65	{ CTL_PST_SEL_SYNCCAND,	"sel_candidate",	0 },
66	{ CTL_PST_SEL_EXCESS,	"sel_backup",		0 },
67	{ CTL_PST_SEL_SYSPEER,	"sel_sys.peer",		0 },
68	{ CTL_PST_SEL_PPS,	"sel_pps.peer",		0 },
69	{ -1,			"sel",			0 }
70};
71
72/*
73 * Clock status (clk)
74 */
75static const struct codestring clock_codes[] = {
76	{ CTL_CLK_OKAY,		"clk_unspec",		0 },
77	{ CTL_CLK_NOREPLY,	"clk_no_reply",		0 },
78	{ CTL_CLK_BADFORMAT,	"clk_bad_format",	0 },
79	{ CTL_CLK_FAULT,	"clk_fault",		0 },
80	{ CTL_CLK_PROPAGATION,	"clk_bad_signal",	0 },
81	{ CTL_CLK_BADDATE,	"clk_bad_date",		0 },
82	{ CTL_CLK_BADTIME,	"clk_bad_time",		0 },
83	{ -1,			"clk",			0 }
84};
85
86
87#ifdef FLASH_CODES_UNUSED
88/*
89 * Flash bits -- see ntpq.c tstflags & tstflagnames
90 */
91static const struct codestring flash_codes[] = {
92	{ TEST1,		"pkt_dup",	0 },
93	{ TEST2,		"pkt_bogus",	0 },
94	{ TEST3,		"pkt_unsync",	0 },
95	{ TEST4,		"pkt_denied",	0 },
96	{ TEST5,		"pkt_auth",	0 },
97	{ TEST6,		"pkt_stratum",	0 },
98	{ TEST7,		"pkt_header",	0 },
99	{ TEST8,		"pkt_autokey",	0 },
100	{ TEST9,		"pkt_crypto",	0 },
101	{ TEST10,		"peer_stratum",	0 },
102	{ TEST11,		"peer_dist",	0 },
103	{ TEST12,		"peer_loop",	0 },
104	{ TEST13,		"peer_unreach",	0 },
105	{ -1,			"flash",	0 }
106};
107#endif
108
109
110/*
111 * System events (sys)
112 */
113static const struct codestring sys_codes[] = {
114	{ EVNT_UNSPEC,		"unspecified",			0 },
115	{ EVNT_NSET,		"freq_not_set",			0 },
116	{ EVNT_FSET,		"freq_set",			0 },
117	{ EVNT_SPIK,		"spike_detect",			0 },
118	{ EVNT_FREQ,		"freq_mode",			0 },
119	{ EVNT_SYNC,		"clock_sync",			0 },
120	{ EVNT_SYSRESTART,	"restart",			0 },
121	{ EVNT_SYSFAULT,	"panic_stop",			0 },
122	{ EVNT_NOPEER,		"no_sys_peer",			0 },
123	{ EVNT_ARMED,		"leap_armed",			0 },
124	{ EVNT_DISARMED,	"leap_disarmed",		0 },
125	{ EVNT_LEAP,		"leap_event",			0 },
126	{ EVNT_CLOCKRESET,	"clock_step",			0 },
127	{ EVNT_KERN,		"kern",				0 },
128	{ EVNT_TAI,		"TAI",				0 },
129	{ EVNT_LEAPVAL,		"stale_leapsecond_values",	0 },
130	{ -1,			"",				0 }
131};
132
133/*
134 * Peer events (peer)
135 */
136static const struct codestring peer_codes[] = {
137	{ PEVNT_MOBIL & ~PEER_EVENT,	"mobilize",		0 },
138	{ PEVNT_DEMOBIL & ~PEER_EVENT,	"demobilize",		0 },
139	{ PEVNT_UNREACH & ~PEER_EVENT,	"unreachable",		0 },
140	{ PEVNT_REACH & ~PEER_EVENT,	"reachable",		0 },
141	{ PEVNT_RESTART & ~PEER_EVENT,	"restart",		0 },
142	{ PEVNT_REPLY & ~PEER_EVENT,	"no_reply",		0 },
143	{ PEVNT_RATE & ~PEER_EVENT,	"rate_exceeded",	0 },
144	{ PEVNT_DENY & ~PEER_EVENT,	"access_denied",	0 },
145	{ PEVNT_ARMED & ~PEER_EVENT,	"leap_armed",		0 },
146	{ PEVNT_NEWPEER & ~PEER_EVENT,	"sys_peer",		0 },
147	{ PEVNT_CLOCK & ~PEER_EVENT,	"clock_event",		0 },
148	{ PEVNT_AUTH & ~PEER_EVENT,	"bad_auth",		0 },
149	{ PEVNT_POPCORN & ~PEER_EVENT,	"popcorn",		0 },
150	{ PEVNT_XLEAVE & ~PEER_EVENT,	"interleave_mode",	0 },
151	{ PEVNT_XERR & ~PEER_EVENT,	"interleave_error",	0 },
152	{ -1,				"",			0 }
153};
154
155/*
156 * Peer status bits
157 */
158static const struct codestring peer_st_bits[] = {
159	{ CTL_PST_CONFIG,		"conf",		0 },
160	{ CTL_PST_AUTHENABLE,		"authenb",	0 },
161	{ CTL_PST_AUTHENTIC,		"auth",		0 },
162	{ CTL_PST_REACH,		"reach",	0 },
163	{ CTL_PST_BCAST,		"bcast",	0 },
164	/* not used with getcode(), no terminating entry needed */
165};
166
167/*
168 * Restriction match bits
169 */
170static const struct codestring res_match_bits[] = {
171	{ RESM_NTPONLY,			"ntpport",	0 },
172	{ RESM_INTERFACE,		"interface",	0 },
173	{ RESM_SOURCE,			"source",	0 },
174	/* not used with getcode(), no terminating entry needed */
175};
176
177/*
178 * Restriction access bits
179 */
180static const struct codestring res_access_bits[] = {
181	{ RES_IGNORE,			"ignore",	0 },
182	{ RES_DONTSERVE,		"noserve",	"serve" },
183	{ RES_DONTTRUST,		"notrust",	"trust" },
184	{ RES_VERSION,			"version",	0 },
185	{ RES_NOPEER,			"nopeer",	"peer" },
186	{ RES_NOEPEER,			"noepeer",	"epeer" },
187	{ RES_LIMITED,			"limited",	0 },
188
189	{ RES_NOQUERY,			"noquery",	"query" },
190	{ RES_NOMODIFY,			"nomodify",	0 },
191	{ RES_NOTRAP,			"notrap",	"trap" },
192	{ RES_LPTRAP,			"lptrap",	0 },
193
194	{ RES_KOD,			"kod",		0 },
195	{ RES_MSSNTP,			"mssntp",	0 },
196	{ RES_FLAKE,			"flake",	0 },
197	{ RES_NOMRULIST,		"nomrulist",	0 },
198
199	{ RES_SRVRSPFUZ,		"serverresponse fuzz",	0 },
200
201	/* not used with getcode(), no terminating entry needed */
202};
203
204#ifdef AUTOKEY
205/*
206 * Crypto events (cryp)
207 */
208static const struct codestring crypto_codes[] = {
209	{ XEVNT_OK & ~CRPT_EVENT,	"success",			0 },
210	{ XEVNT_LEN & ~CRPT_EVENT,	"bad_field_format_or_length",	0 },
211	{ XEVNT_TSP & ~CRPT_EVENT,	"bad_timestamp",		0 },
212	{ XEVNT_FSP & ~CRPT_EVENT,	"bad_filestamp",		0 },
213	{ XEVNT_PUB & ~CRPT_EVENT,	"bad_or_missing_public_key",	0 },
214	{ XEVNT_MD & ~CRPT_EVENT,	"unsupported_digest_type",	0 },
215	{ XEVNT_KEY & ~CRPT_EVENT,	"unsupported_identity_type",	0 },
216	{ XEVNT_SGL & ~CRPT_EVENT,	"bad_signature_length",		0 },
217	{ XEVNT_SIG & ~CRPT_EVENT,	"signature_not_verified",	0 },
218	{ XEVNT_VFY & ~CRPT_EVENT,	"certificate_not_verified",	0 },
219	{ XEVNT_PER & ~CRPT_EVENT,	"host_certificate_expired",	0 },
220	{ XEVNT_CKY & ~CRPT_EVENT,	"bad_or_missing_cookie",	0 },
221	{ XEVNT_DAT & ~CRPT_EVENT,	"bad_or_missing_leapseconds",	0 },
222	{ XEVNT_CRT & ~CRPT_EVENT,	"bad_or_missing_certificate",	0 },
223	{ XEVNT_ID & ~CRPT_EVENT,	"bad_or_missing_group key",	0 },
224	{ XEVNT_ERR & ~CRPT_EVENT,	"protocol_error",		0 },
225	{ -1,				"",				0 }
226};
227#endif	/* AUTOKEY */
228
229#ifdef KERNEL_PLL
230/*
231 * kernel discipline status bits
232 */
233static const struct codestring k_st_bits[] = {
234# ifdef STA_PLL
235	{ STA_PLL,			"pll",		0 },
236# endif
237# ifdef STA_PPSFREQ
238	{ STA_PPSFREQ,			"ppsfreq",	0 },
239# endif
240# ifdef STA_PPSTIME
241	{ STA_PPSTIME,			"ppstime",	0 },
242# endif
243# ifdef STA_FLL
244	{ STA_FLL,			"fll",		0 },
245# endif
246# ifdef STA_INS
247	{ STA_INS,			"ins",		0 },
248# endif
249# ifdef STA_DEL
250	{ STA_DEL,			"del",		0 },
251# endif
252# ifdef STA_UNSYNC
253	{ STA_UNSYNC,			"unsync",	0 },
254# endif
255# ifdef STA_FREQHOLD
256	{ STA_FREQHOLD,			"freqhold",	0 },
257# endif
258# ifdef STA_PPSSIGNAL
259	{ STA_PPSSIGNAL,		"ppssignal",	0 },
260# endif
261# ifdef STA_PPSJITTER
262	{ STA_PPSJITTER,		"ppsjitter",	0 },
263# endif
264# ifdef STA_PPSWANDER
265	{ STA_PPSWANDER,		"ppswander",	0 },
266# endif
267# ifdef STA_PPSERROR
268	{ STA_PPSERROR,			"ppserror",	0 },
269# endif
270# ifdef STA_CLOCKERR
271	{ STA_CLOCKERR,			"clockerr",	0 },
272# endif
273# ifdef STA_NANO
274	{ STA_NANO,			"nano",		0 },
275# endif
276# ifdef STA_MODE
277	{ STA_MODE,			"mode=fll",	0 },
278# endif
279# ifdef STA_CLK
280	{ STA_CLK,			"src=B",	0 },
281# endif
282	/* not used with getcode(), no terminating entry needed */
283};
284#endif	/* KERNEL_PLL */
285
286/* Forwards */
287static const char *	getcode(int, const struct codestring *);
288static const char *	getevents(int);
289static const char *	peer_st_flags(u_char pst);
290
291/*
292 * getcode - return string corresponding to code
293 */
294static const char *
295getcode(
296	int				code,
297	const struct codestring *	codetab
298	)
299{
300	char *	buf;
301
302	while (codetab->code != -1) {
303		if (codetab->code == code)
304			return codetab->string1;
305		codetab++;
306	}
307
308	LIB_GETBUF(buf);
309	snprintf(buf, LIB_BUFLENGTH, "%s_%d", codetab->string1, code);
310
311	return buf;
312}
313
314/*
315 * getevents - return a descriptive string for the event count
316 */
317static const char *
318getevents(
319	int cnt
320	)
321{
322	char *	buf;
323
324	if (cnt == 0)
325		return "no events";
326
327	LIB_GETBUF(buf);
328	snprintf(buf, LIB_BUFLENGTH, "%d event%s", cnt,
329		 (1 == cnt)
330		     ? ""
331		     : "s");
332
333	return buf;
334}
335
336
337/*
338 * decode_bitflags()
339 *
340 * returns a human-readable string with a keyword from tab for each bit
341 * set in bits, separating multiple entries with text of sep2.
342 */
343static const char *
344decode_bitflags(
345	int				bits,
346	const char *			sep2,
347	const struct codestring *	tab,
348	size_t				tab_ct
349	)
350{
351	const char *	sep;
352	char *		buf;
353	char *		pch;
354	char *		lim;
355	size_t		b;
356	int		rc;
357	int		saved_errno;	/* for use in DPRINTF with %m */
358
359	saved_errno = errno;
360	LIB_GETBUF(buf);
361	pch = buf;
362	lim = buf + LIB_BUFLENGTH;
363	sep = "";
364
365	for (b = 0; b < tab_ct; b++) {
366		const char * flagstr;
367
368		if (tab[b].code & bits) {
369			flagstr = tab[b].string1;
370		} else {
371			flagstr = tab[b].string0;
372		}
373
374		if (flagstr) {
375			size_t avail = lim - pch;
376			rc = snprintf(pch, avail, "%s%s", sep,
377				      flagstr);
378			if ((size_t)rc >= avail)
379				goto toosmall;
380			pch += rc;
381			sep = sep2;
382		}
383	}
384
385	return buf;
386
387    toosmall:
388	snprintf(buf, LIB_BUFLENGTH,
389		 "decode_bitflags(%s) can't decode 0x%x in %d bytes",
390		 (tab == peer_st_bits)
391		     ? "peer_st"
392		     :
393#ifdef KERNEL_PLL
394		       (tab == k_st_bits)
395			   ? "kern_st"
396			   :
397#endif
398			     "",
399		 bits, (int)LIB_BUFLENGTH);
400	errno = saved_errno;
401
402	return buf;
403}
404
405
406static const char *
407peer_st_flags(
408	u_char pst
409	)
410{
411	return decode_bitflags(pst, ", ", peer_st_bits,
412			       COUNTOF(peer_st_bits));
413}
414
415
416const char *
417res_match_flags(
418	u_short mf
419	)
420{
421	return decode_bitflags(mf, " ", res_match_bits,
422			       COUNTOF(res_match_bits));
423}
424
425
426const char *
427res_access_flags(
428	u_int32 af
429	)
430{
431	return decode_bitflags(af, " ", res_access_bits,
432			       COUNTOF(res_access_bits));
433}
434
435
436#ifdef KERNEL_PLL
437const char *
438k_st_flags(
439	u_int32 st
440	)
441{
442	return decode_bitflags(st, " ", k_st_bits, COUNTOF(k_st_bits));
443}
444#endif	/* KERNEL_PLL */
445
446
447/*
448 * statustoa - return a descriptive string for a peer status
449 */
450char *
451statustoa(
452	int type,
453	int st
454	)
455{
456	char *	cb;
457	char *	cc;
458	u_char	pst;
459
460	LIB_GETBUF(cb);
461
462	switch (type) {
463
464	case TYPE_SYS:
465		snprintf(cb, LIB_BUFLENGTH, "%s, %s, %s, %s",
466			 getcode(CTL_SYS_LI(st), leap_codes),
467			 getcode(CTL_SYS_SOURCE(st), sync_codes),
468			 getevents(CTL_SYS_NEVNT(st)),
469			 getcode(CTL_SYS_EVENT(st), sys_codes));
470		break;
471
472	case TYPE_PEER:
473		pst = (u_char)CTL_PEER_STATVAL(st);
474		snprintf(cb, LIB_BUFLENGTH, "%s, %s, %s",
475			 peer_st_flags(pst),
476			 getcode(pst & 0x7, select_codes),
477			 getevents(CTL_PEER_NEVNT(st)));
478		if (CTL_PEER_EVENT(st) != EVNT_UNSPEC) {
479			cc = cb + strlen(cb);
480			snprintf(cc, LIB_BUFLENGTH - (cc - cb), ", %s",
481				 getcode(CTL_PEER_EVENT(st),
482					 peer_codes));
483		}
484		break;
485
486	case TYPE_CLOCK:
487		snprintf(cb, LIB_BUFLENGTH, "%s, %s",
488			 getevents(CTL_SYS_NEVNT(st)),
489			 getcode((st) & 0xf, clock_codes));
490		break;
491	}
492
493	return cb;
494}
495
496const char *
497eventstr(
498	int num
499	)
500{
501	if (num & PEER_EVENT)
502		return (getcode(num & ~PEER_EVENT, peer_codes));
503#ifdef AUTOKEY
504	else if (num & CRPT_EVENT)
505		return (getcode(num & ~CRPT_EVENT, crypto_codes));
506#endif	/* AUTOKEY */
507	else
508		return (getcode(num, sys_codes));
509}
510
511const char *
512ceventstr(
513	int num
514	)
515{
516	return getcode(num, clock_codes);
517}
518