xref: /titanic_41/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ntp.c (revision ebd1706e95186ddae1d4c0d63c47544cf33832ee)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <fcntl.h>
30 #include <sys/socket.h>
31 #include <sys/sysmacros.h>
32 #include <netinet/in.h>
33 #include <netdb.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <tzfile.h>
37 #include "snoop.h"
38 #include "ntp.h"
39 
40 /*
41  * In verbose mode, how many octets of the control-mode data payload
42  * are displayed per line of output.  The value 64 fits well on an
43  * 80-column screen and, as a power of 2, is easily correlated to
44  * hexadecimal output.
45  */
46 #define	OCTETS_PER_LINE	64
47 
48 extern char *dlc_header;
49 
50 static	char	*show_leap(int);
51 static	char	*show_mode(int);
52 static	char	*show_ref(int, ulong_t);
53 static	char	*show_time(struct l_fixedpt);
54 static	double	s_fixed_to_double(struct s_fixedpt *);
55 static	char	*iso_date_time(time_t);
56 static	char	*show_operation(int);
57 
58 int
59 interpret_ntp(int flags, struct ntpdata *ntp_pkt, int fraglen)
60 {
61 	unsigned int	i, j, macbytes;
62 	unsigned int	proto_version;
63 	unsigned int	datalen;
64 	unsigned int	linelen = OCTETS_PER_LINE;
65 	unsigned int	sofar = 0;
66 
67 	char	*datap;
68 	char	hbuf[2 * MAC_OCTETS_MAX + 1];
69 	static	char *hexstr = "0123456789ABCDEF";
70 
71 	union	ntp_pkt_buf {
72 		struct	ntpdata ntp_msg;
73 		union ntpc_buf {
74 			struct	ntp_control chdr;
75 			uchar_t	data2[NTPC_DATA_MAXLEN - 1];
76 		} ntpc_msg;
77 		union ntpp_buf {
78 			struct	ntp_private phdr;
79 			uchar_t	data2[1];
80 		} ntpp_msg;
81 	} fragbuf;
82 
83 	struct	ntpdata		*ntp = &fragbuf.ntp_msg;
84 	struct	ntp_control	*ntpc = (struct ntp_control *)&fragbuf.ntpc_msg;
85 	struct	ntp_private	*ntpp = (struct ntp_private *)&fragbuf.ntpp_msg;
86 
87 	/*
88 	 * Copying packet contents into a local buffer avoids
89 	 * problems of interpretation if the packet is truncated.
90 	 */
91 	(void) memcpy(&fragbuf, ntp_pkt, MIN(sizeof (fragbuf), fraglen));
92 
93 	if (flags & F_SUM) {
94 		switch (ntp->li_vn_mode & NTPMODEMASK) {
95 		case MODE_SYM_ACT:
96 		case MODE_SYM_PAS:
97 		case MODE_CLIENT:
98 		case MODE_SERVER:
99 		case MODE_BROADCAST:
100 		    (void) sprintf(get_sum_line(),
101 			"NTP  %s [st=%hd] (%s)",
102 			show_mode(ntp->li_vn_mode & NTPMODEMASK),
103 			ntp->stratum,
104 			show_time(ntp->xmt));
105 		    break;
106 		case MODE_CONTROL:
107 		    (void) sprintf(get_sum_line(),
108 			"NTP  %s "
109 			"(Flags/op=0x%02x Seq=%hu Status=0x%04hx Assoc=%hu)",
110 			show_mode(ntpc->li_vn_mode & NTPMODEMASK),
111 			ntpc->r_m_e_op,
112 			ntohs(ntpc->sequence),
113 			ntohs(ntpc->status),
114 			ntohs(ntpc->associd));
115 		    break;
116 		default:
117 		    (void) sprintf(get_sum_line(),
118 			"NTP  %s",
119 			show_mode(ntpp->rm_vn_mode & NTPMODEMASK));
120 		    break;
121 		}
122 	}
123 
124 	proto_version = (ntp->li_vn_mode & VERSIONMASK) >> 3;
125 
126 	if (flags & F_DTAIL) {
127 		show_header("NTP:  ", "Network Time Protocol", fraglen);
128 		show_space();
129 		switch (ntp->li_vn_mode & NTPMODEMASK) {
130 		case MODE_SYM_ACT:
131 		case MODE_SYM_PAS:
132 		case MODE_CLIENT:
133 		case MODE_SERVER:
134 		case MODE_BROADCAST:
135 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode -
136 			dlc_header, 1),
137 			"Leap    = 0x%x (%s)",
138 			(int)(ntp->li_vn_mode & LEAPMASK) >> 6,
139 			show_leap(ntp->li_vn_mode & LEAPMASK));
140 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode -
141 			dlc_header, 1),
142 			"Version = %lu", proto_version);
143 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode -
144 			dlc_header, 1),
145 			"Mode    = %hu (%s)",
146 			ntp->li_vn_mode & NTPMODEMASK,
147 			show_mode(ntp->li_vn_mode & NTPMODEMASK));
148 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->stratum -
149 			dlc_header, 1),
150 			"Stratum = %d (%s)",
151 			ntp->stratum,
152 			ntp->stratum == 0 ? "unspecified" :
153 			ntp->stratum == 1 ? "primary reference" :
154 			"secondary reference");
155 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->ppoll -
156 			dlc_header, 1),	"Poll    = %hu", ntp->ppoll);
157 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->precision -
158 			dlc_header, 1),
159 			"Precision = %d seconds",
160 			ntp->precision);
161 		    (void) sprintf(get_line(
162 			(char *)(uintptr_t)ntp->distance.int_part -
163 			dlc_header, 1),
164 			"Synchronizing distance   = 0x%04x.%04x  (%f)",
165 			ntohs(ntp->distance.int_part),
166 			ntohs(ntp->distance.fraction),
167 			s_fixed_to_double(&ntp->distance));
168 		    (void) sprintf(get_line(
169 			(char *)(uintptr_t)ntp->dispersion.int_part -
170 			dlc_header, 1),
171 			"Synchronizing dispersion = 0x%04x.%04x  (%f)",
172 			ntohs(ntp->dispersion.int_part),
173 			ntohs(ntp->dispersion.fraction),
174 			s_fixed_to_double(&ntp->dispersion));
175 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->refid -
176 			dlc_header, 1), "Reference clock = %s",
177 			show_ref(ntp->stratum, ntp->refid));
178 
179 		    (void) sprintf(get_line(
180 			(char *)(uintptr_t)ntp->reftime.int_part - dlc_header,
181 			1), "Reference time = 0x%08lx.%08lx (%s)",
182 			ntohl(ntp->reftime.int_part),
183 			ntohl(ntp->reftime.fraction),
184 			show_time(ntp->reftime));
185 
186 		    (void) sprintf(get_line(
187 			(char *)(uintptr_t)ntp->org.int_part - dlc_header, 1),
188 			"Originate time = 0x%08lx.%08lx (%s)",
189 			ntohl(ntp->org.int_part),
190 			ntohl(ntp->org.fraction),
191 			show_time(ntp->org));
192 
193 		    (void) sprintf(get_line(
194 			(char *)(uintptr_t)ntp->rec.int_part - dlc_header, 1),
195 			"Receive   time = 0x%08lx.%08lx (%s)",
196 			ntohl(ntp->rec.int_part),
197 			ntohl(ntp->rec.fraction),
198 			show_time(ntp->rec));
199 
200 		    (void) sprintf(get_line(
201 			(char *)(uintptr_t)ntp->xmt.int_part - dlc_header, 1),
202 			"Transmit  time = 0x%08lx.%08lx (%s)",
203 			ntohl(ntp->xmt.int_part),
204 			ntohl(ntp->xmt.fraction),
205 			show_time(ntp->xmt));
206 
207 		    if (proto_version > 3 ||
208 			fraglen < (LEN_PKT_NOMAC + MAC_OCTETS_MIN)) {
209 				/*
210 				 * A newer protocol version we can't parse,
211 				 * or v3 packet with no valid authentication.
212 				 */
213 				break;
214 		    }
215 		    (void) sprintf(get_line((char *)ntp->keyid -
216 			dlc_header, 1),
217 			"Key ID  = %8lu", ntohl(ntp->keyid));
218 
219 		    macbytes = fraglen - (LEN_PKT_NOMAC + sizeof (uint32_t));
220 
221 		    for (i = 0, j = 0; i < macbytes; i++) {
222 			    hbuf[j++] = hexstr[ntp->mac[i] >> 4 & 0x0f];
223 			    hbuf[j++] = hexstr[ntp->mac[i] & 0x0f];
224 		    }
225 		    hbuf[j] = '\0';
226 		    (void) sprintf(get_line((char *)ntp->mac -
227 			dlc_header, 1),
228 			"Authentication code = %s", hbuf);
229 		    break;
230 
231 		case MODE_CONTROL:
232 		    /* NTP Control Message, mode 6 */
233 
234 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode -
235 			dlc_header, 1),
236 			"Leap    = 0x%x (%s)",
237 			(int)(ntp->li_vn_mode & LEAPMASK) >> 6,
238 			show_leap(ntp->li_vn_mode & LEAPMASK));
239 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode -
240 			dlc_header, 1),
241 			"Version = %lu", proto_version);
242 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode -
243 			dlc_header, 1),
244 			"Mode    = %hu (%s)",
245 			ntp->li_vn_mode & NTPMODEMASK,
246 			show_mode(ntp->li_vn_mode & NTPMODEMASK));
247 		    (void) sprintf(get_line((char *)(uintptr_t)ntpc->r_m_e_op -
248 			dlc_header, 1),
249 			"Flags and operation code = 0x%02x",
250 			ntpc->r_m_e_op);
251 		    (void) sprintf(get_line((char *)(uintptr_t)ntpc->r_m_e_op -
252 			dlc_header, 1),
253 			"      %s",
254 			getflag(ntpc->r_m_e_op, CTL_RESPONSE, "response",
255 			"request"));
256 		    (void) sprintf(get_line((char *)(uintptr_t)ntpc->r_m_e_op -
257 			dlc_header, 1),
258 			"      %s",
259 			getflag(ntpc->r_m_e_op, CTL_ERROR, "error",
260 			"success"));
261 		    (void) sprintf(get_line((char *)(uintptr_t)ntpc->r_m_e_op -
262 			dlc_header, 1),
263 			"      %s",
264 			getflag(ntpc->r_m_e_op, CTL_MORE, "more",
265 			"no more"));
266 		    (void) sprintf(get_line((char *)(uintptr_t)ntpc->r_m_e_op -
267 			dlc_header, 1),
268 			"      ...x xxxx = %hd (%s)",
269 			ntpc->r_m_e_op & CTL_OP_MASK,
270 			show_operation(ntpc->r_m_e_op & CTL_OP_MASK));
271 		    (void) sprintf(get_line((char *)(uintptr_t)ntpc->sequence -
272 			dlc_header, 1),
273 			"Sequence = %hu",
274 			ntohs(ntpc->sequence));
275 		    (void) sprintf(get_line((char *)(uintptr_t)ntpc->status -
276 			dlc_header, 1),
277 			"Status = 0x%04hx",
278 			ntohs(ntpc->status));
279 		    (void) sprintf(get_line((char *)(uintptr_t)ntpc->associd -
280 			dlc_header, 1),
281 			"Assoc ID = %hu",
282 			ntohs(ntpc->associd));
283 		    (void) sprintf(get_line((char *)(uintptr_t)ntpc->offset -
284 			dlc_header, 1),
285 			"Data offset = %hu",
286 			ntohs(ntpc->offset));
287 		    (void) sprintf(get_line((char *)(uintptr_t)ntpc->count -
288 			dlc_header, 1),
289 			"Data bytes = %hu",
290 			ntohs(ntpc->count));
291 		    datalen = ntohs(ntpc->count);
292 		    if (datalen == 0) {
293 			    break;
294 		    } else if (datalen > NTPC_DATA_MAXLEN) {
295 			    datalen = NTPC_DATA_MAXLEN;
296 		    }
297 		    show_space();
298 		    datap = (char *)ntpc->data;
299 		    do {
300 			    (void) sprintf(get_line(datap -
301 				dlc_header, 1),
302 				"\"%s\"",
303 				show_string(datap, linelen, datalen));
304 			    sofar += linelen;
305 			    datap += linelen;
306 			    if ((sofar + linelen) > datalen) {
307 				    linelen = datalen - sofar;
308 			    }
309 		    } while (sofar < datalen);
310 		    show_trailer();
311 		    break;
312 
313 		case MODE_PRIVATE:
314 		    /* NTP Private Message, mode 7 */
315 
316 		    (void) sprintf(get_line(
317 			(char *)(uintptr_t)ntpp->rm_vn_mode - dlc_header, 1),
318 			"Version = %hu", INFO_VERSION(ntpp->rm_vn_mode));
319 		    (void) sprintf(get_line(
320 			(char *)(uintptr_t)ntpp->rm_vn_mode - dlc_header, 1),
321 			"Mode    = %hu (%s)", INFO_MODE(ntpp->rm_vn_mode),
322 			show_mode(INFO_MODE(ntpp->rm_vn_mode)));
323 		    (void) sprintf(get_line(
324 			(char *)(uintptr_t)ntpp->rm_vn_mode - dlc_header, 1),
325 			"Flags = 0x%02hx", ntpp->rm_vn_mode);
326 		    (void) sprintf(get_line(
327 			(char *)(uintptr_t)ntpp->rm_vn_mode - dlc_header, 1),
328 			"      %s",
329 			getflag(ntpp->rm_vn_mode, RESP_BIT, "response",
330 			"request"));
331 		    (void) sprintf(get_line(
332 			(char *)(uintptr_t)ntpp->rm_vn_mode - dlc_header, 1),
333 			"      %s",
334 			getflag(ntpp->rm_vn_mode, MORE_BIT, "more", "no more"));
335 		    (void) sprintf(get_line((char *)(uintptr_t)ntpp->auth_seq -
336 			dlc_header, 1),
337 			"Authentication and sequence = 0x%02x", ntpp->auth_seq);
338 		    (void) sprintf(get_line((char *)(uintptr_t)ntpp->auth_seq -
339 			dlc_header, 1),
340 			"      %s",
341 			getflag(ntpp->auth_seq, AUTH_BIT, "authenticated",
342 			"unauthenticated"));
343 		    (void) sprintf(get_line((char *)(uintptr_t)ntpp->auth_seq -
344 			dlc_header, 1),
345 			"      .xxx xxxx = %hu (sequence number)",
346 			INFO_SEQ(ntpp->auth_seq));
347 		    (void) sprintf(get_line(
348 			(char *)(uintptr_t)ntpp->implementation - dlc_header,
349 			1), "Implementation = %hu", ntpp->implementation);
350 		    (void) sprintf(get_line((char *)(uintptr_t)ntpp->request -
351 			dlc_header, 1), "Request = %hu", ntpp->request);
352 		    (void) sprintf(get_line(
353 			(char *)(uintptr_t)ntpp->err_nitems - dlc_header, 1),
354 			"Error = %hu", INFO_ERR(ntpp->err_nitems));
355 		    (void) sprintf(get_line(
356 			(char *)(uintptr_t)ntpp->err_nitems - dlc_header, 1),
357 			"Items = %hu", INFO_NITEMS(ntpp->err_nitems));
358 		    (void) sprintf(get_line(
359 			(char *)(uintptr_t)ntpp->mbz_itemsize - dlc_header, 1),
360 			"Item size = %hu", INFO_ITEMSIZE(ntpp->mbz_itemsize));
361 		    break;
362 
363 		default:
364 		    /* Unknown mode */
365 		    (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode -
366 			dlc_header, 1),	"Mode    = %hu (%s)",
367 			ntp->li_vn_mode & NTPMODEMASK,
368 			show_mode(ntp->li_vn_mode & NTPMODEMASK));
369 		    break;
370 		}
371 	}
372 
373 	return (fraglen);
374 }
375 
376 char *
377 show_leap(int leap)
378 {
379 	switch (leap) {
380 	case NO_WARNING: return ("OK");
381 	case PLUS_SEC:	return ("add a second (61 seconds)");
382 	case MINUS_SEC: return ("minus a second (59 seconds)");
383 	case ALARM:	return ("alarm condition (clock unsynchronized)");
384 	default:	return ("unknown");
385 	}
386 }
387 
388 char *
389 show_mode(int mode)
390 {
391 	switch (mode) {
392 	case MODE_UNSPEC:	return ("unspecified");
393 	case MODE_SYM_ACT:	return ("symmetric active");
394 	case MODE_SYM_PAS:	return ("symmetric passive");
395 	case MODE_CLIENT:	return ("client");
396 	case MODE_SERVER:	return ("server");
397 	case MODE_BROADCAST:	return ("broadcast");
398 	case MODE_CONTROL:	return ("control");
399 	case MODE_PRIVATE:	return ("private");
400 	default:		return ("unknown");
401 	}
402 }
403 
404 char *
405 show_ref(int mode, ulong_t refid)
406 {
407 	static char buff[MAXHOSTNAMELEN + 32];
408 	struct in_addr host;
409 	extern char *inet_ntoa();
410 
411 	switch (mode) {
412 	case 0:
413 	case 1:
414 		(void) strncpy(buff, (char *)&refid, 4);
415 		buff[4] = '\0';
416 		break;
417 
418 	default:
419 		host.s_addr = refid;
420 		(void) sprintf(buff, "%s (%s)",
421 		    inet_ntoa(host),
422 		    addrtoname(AF_INET, &host));
423 		break;
424 	}
425 
426 	return (buff);
427 }
428 
429 /*
430  *  Here we have to worry about the high order bit being signed
431  */
432 double
433 s_fixed_to_double(struct s_fixedpt *t)
434 {
435 	double a;
436 
437 	if (ntohs(t->int_part) & 0x8000) {
438 		a = ntohs((int)(~t->fraction) & 0xFFFF);
439 		a = a / 65536.0;	/* shift dec point over by 16 bits */
440 		a +=  ntohs((int)(~t->int_part) & 0xFFFF);
441 		a = -a;
442 	} else {
443 		a = ntohs(t->fraction);
444 		a = a / 65536.0;	/* shift dec point over by 16 bits */
445 		a += ntohs(t->int_part);
446 	}
447 	return (a);
448 }
449 
450 /*
451  * Consistent with RFC-3339, ISO 8601.
452  */
453 char *
454 iso_date_time(time_t input_time)
455 {
456 	struct tm	*time_parts;
457 	static char	tbuf[sizeof ("yyyy-mm-dd hh:mm:ss")];
458 
459 	time_parts = localtime(&input_time);
460 	(void) strftime(tbuf, sizeof (tbuf), "%Y-%m-%d %H:%M:%S", time_parts);
461 	return (tbuf);
462 }
463 
464 /*
465  * The base of NTP timestamps is 1900-01-01 00:00:00.00000
466  */
467 char *
468 show_time(struct l_fixedpt pkt_time)
469 {
470 	struct l_fixedpt net_time;
471 	unsigned long	fracsec;
472 	static char	buff[32];
473 
474 	if (pkt_time.int_part == 0) {
475 		buff[0] = '\0';
476 		return (buff);
477 	}
478 
479 	net_time.int_part = ntohl(pkt_time.int_part) - JAN_1970;
480 	net_time.fraction = ntohl(pkt_time.fraction);
481 
482 	fracsec = net_time.fraction / 42949;	/* fract / (2**32/10**6) */
483 
484 	(void) strlcpy(buff, iso_date_time(net_time.int_part), sizeof (buff));
485 	(void) snprintf(buff, sizeof (buff), "%s.%05lu", buff, fracsec);
486 
487 	return (buff);
488 }
489 
490 char *
491 show_operation(int op)
492 {
493 	switch (op) {
494 	case CTL_OP_UNSPEC:	return ("unspecified");
495 	case CTL_OP_READSTAT:	return ("read stats");
496 	case CTL_OP_READVAR:	return ("read var");
497 	case CTL_OP_WRITEVAR:	return ("write var");
498 	case CTL_OP_READCLOCK:	return ("read clock");
499 	case CTL_OP_WRITECLOCK: return ("write clock");
500 	case CTL_OP_SETTRAP:	return ("set trap");
501 	case CTL_OP_ASYNCMSG:	return ("async msg");
502 	case CTL_OP_UNSETTRAP:	return ("unset trap");
503 	default:		return ("unknown");
504 	}
505 }
506