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