1/*
2 * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that: (1) source code distributions
7 * retain the above copyright notice and this paragraph in its entirety, (2)
8 * distributions including binary code include the above copyright notice and
9 * this paragraph in its entirety in the documentation or other materials
10 * provided with the distribution, and (3) all advertising materials mentioning
11 * features or use of this software display the following acknowledgement:
12 * ``This product includes software developed by the University of California,
13 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
14 * the University nor the names of its contributors may be used to endorse
15 * or promote products derived from this software without specific prior
16 * written permission.
17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20 */
21
22#ifndef lint
23static const char rcsid[] _U_ =
24    "@(#) $Header: /tcpdump/master/tcpdump/util.c,v 1.109 2007-01-29 09:59:42 hannes Exp $ (LBL)";
25#endif
26
27#ifdef HAVE_CONFIG_H
28#include "config.h"
29#endif
30
31#include <tcpdump-stdinc.h>
32
33#include <sys/stat.h>
34
35#include <errno.h>
36#ifdef HAVE_FCNTL_H
37#include <fcntl.h>
38#endif
39#include <pcap.h>
40#include <stdio.h>
41#include <stdarg.h>
42#include <stdlib.h>
43#include <string.h>
44
45#include "interface.h"
46
47char * ts_format(register int, register int);
48
49/*
50 * Print out a null-terminated filename (or other ascii string).
51 * If ep is NULL, assume no truncation check is needed.
52 * Return true if truncated.
53 */
54int
55fn_print(register const u_char *s, register const u_char *ep)
56{
57	register int ret;
58	register u_char c;
59
60	ret = 1;			/* assume truncated */
61	while (ep == NULL || s < ep) {
62		c = *s++;
63		if (c == '\0') {
64			ret = 0;
65			break;
66		}
67		if (!ND_ISASCII(c)) {
68			c = ND_TOASCII(c);
69			putchar('M');
70			putchar('-');
71		}
72		if (!ND_ISPRINT(c)) {
73			c ^= 0x40;	/* DEL to ?, others to alpha */
74			putchar('^');
75		}
76		putchar(c);
77	}
78	return(ret);
79}
80
81/*
82 * Print out a counted filename (or other ascii string).
83 * If ep is NULL, assume no truncation check is needed.
84 * Return true if truncated.
85 */
86int
87fn_printn(register const u_char *s, register u_int n,
88	  register const u_char *ep)
89{
90	register u_char c;
91
92	while (n > 0 && (ep == NULL || s < ep)) {
93		n--;
94		c = *s++;
95		if (!ND_ISASCII(c)) {
96			c = ND_TOASCII(c);
97			putchar('M');
98			putchar('-');
99		}
100		if (!ND_ISPRINT(c)) {
101			c ^= 0x40;	/* DEL to ?, others to alpha */
102			putchar('^');
103		}
104		putchar(c);
105	}
106	return (n == 0) ? 0 : 1;
107}
108
109/*
110 * Print out a null-padded filename (or other ascii string).
111 * If ep is NULL, assume no truncation check is needed.
112 * Return true if truncated.
113 */
114int
115fn_printzp(register const u_char *s, register u_int n,
116	  register const u_char *ep)
117{
118	register int ret;
119	register u_char c;
120
121	ret = 1;			/* assume truncated */
122	while (n > 0 && (ep == NULL || s < ep)) {
123		n--;
124		c = *s++;
125		if (c == '\0') {
126			ret = 0;
127			break;
128		}
129		if (!ND_ISASCII(c)) {
130			c = ND_TOASCII(c);
131			putchar('M');
132			putchar('-');
133		}
134		if (!ND_ISPRINT(c)) {
135			c ^= 0x40;	/* DEL to ?, others to alpha */
136			putchar('^');
137		}
138		putchar(c);
139	}
140	return (n == 0) ? 0 : ret;
141}
142
143/*
144 * Format the timestamp
145 */
146char *
147ts_format(register int sec, register int usec)
148{
149        static char buf[sizeof("00:00:00.000000")];
150        (void)snprintf(buf, sizeof(buf), "%02d:%02d:%02d.%06u",
151               sec / 3600, (sec % 3600) / 60, sec % 60, usec);
152
153        return buf;
154}
155
156/*
157 * Print the timestamp
158 */
159void
160ts_print(register const struct timeval *tvp)
161{
162	register int s;
163	struct tm *tm;
164	time_t Time;
165	static unsigned b_sec;
166	static unsigned b_usec;
167	int d_usec;
168	int d_sec;
169
170	switch (tflag) {
171
172	case 0: /* Default */
173		s = (tvp->tv_sec + thiszone) % 86400;
174                (void)printf("%s ", ts_format(s, tvp->tv_usec));
175		break;
176
177	case 1: /* No time stamp */
178		break;
179
180	case 2: /* Unix timeval style */
181		(void)printf("%u.%06u ",
182			     (unsigned)tvp->tv_sec,
183			     (unsigned)tvp->tv_usec);
184		break;
185
186	case 3: /* Microseconds since previous packet */
187        case 5: /* Microseconds since first packet */
188		if (b_sec == 0) {
189                        /* init timestamp for first packet */
190                        b_usec = tvp->tv_usec;
191                        b_sec = tvp->tv_sec;
192                }
193
194                d_usec = tvp->tv_usec - b_usec;
195                d_sec = tvp->tv_sec - b_sec;
196
197                while (d_usec < 0) {
198                    d_usec += 1000000;
199                    d_sec--;
200                }
201
202                (void)printf("%s ", ts_format(d_sec, d_usec));
203
204                if (tflag == 3) { /* set timestamp for last packet */
205                    b_sec = tvp->tv_sec;
206                    b_usec = tvp->tv_usec;
207                }
208		break;
209
210	case 4: /* Default + Date*/
211		s = (tvp->tv_sec + thiszone) % 86400;
212		Time = (tvp->tv_sec + thiszone) - s;
213		tm = gmtime (&Time);
214		if (!tm)
215			printf("Date fail  ");
216		else
217			printf("%04d-%02d-%02d %s ",
218                               tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
219                               ts_format(s, tvp->tv_usec));
220		break;
221	}
222}
223
224/*
225 * Print a relative number of seconds (e.g. hold time, prune timer)
226 * in the form 5m1s.  This does no truncation, so 32230861 seconds
227 * is represented as 1y1w1d1h1m1s.
228 */
229void
230relts_print(int secs)
231{
232	static const char *lengths[] = {"y", "w", "d", "h", "m", "s"};
233	static const int seconds[] = {31536000, 604800, 86400, 3600, 60, 1};
234	const char **l = lengths;
235	const int *s = seconds;
236
237	if (secs == 0) {
238		(void)printf("0s");
239		return;
240	}
241	if (secs < 0) {
242		(void)printf("-");
243		secs = -secs;
244	}
245	while (secs > 0) {
246		if (secs >= *s) {
247			(void)printf("%d%s", secs / *s, *l);
248			secs -= (secs / *s) * *s;
249		}
250		s++;
251		l++;
252	}
253}
254
255/*
256 *  this is a generic routine for printing unknown data;
257 *  we pass on the linefeed plus indentation string to
258 *  get a proper output - returns 0 on error
259 */
260
261int
262print_unknown_data(const u_char *cp,const char *ident,int len)
263{
264	if (len < 0) {
265		printf("%sDissector error: print_unknown_data called with negative length",
266		    ident);
267		return(0);
268	}
269	if (snapend - cp < len)
270		len = snapend - cp;
271	if (len < 0) {
272		printf("%sDissector error: print_unknown_data called with pointer past end of packet",
273		    ident);
274		return(0);
275	}
276        hex_print(ident,cp,len);
277	return(1); /* everything is ok */
278}
279
280/*
281 * Convert a token value to a string; use "fmt" if not found.
282 */
283const char *
284tok2strbuf(register const struct tok *lp, register const char *fmt,
285	   register int v, char *buf, size_t bufsize)
286{
287	if (lp != NULL) {
288		while (lp->s != NULL) {
289			if (lp->v == v)
290				return (lp->s);
291			++lp;
292		}
293	}
294	if (fmt == NULL)
295		fmt = "#%d";
296
297	(void)snprintf(buf, bufsize, fmt, v);
298	return (const char *)buf;
299}
300
301/*
302 * Convert a token value to a string; use "fmt" if not found.
303 */
304const char *
305tok2str(register const struct tok *lp, register const char *fmt,
306	register int v)
307{
308	static char buf[4][128];
309	static int idx = 0;
310	char *ret;
311
312	ret = buf[idx];
313	idx = (idx+1) & 3;
314	return tok2strbuf(lp, fmt, v, ret, sizeof(buf[0]));
315}
316
317/*
318 * Convert a bit token value to a string; use "fmt" if not found.
319 * this is useful for parsing bitfields, the output strings are seperated
320 * if the s field is positive.
321 */
322static char *
323bittok2str_internal(register const struct tok *lp, register const char *fmt,
324	   register int v, register int sep)
325{
326        static char buf[256]; /* our stringbuffer */
327        int buflen=0;
328        register int rotbit; /* this is the bit we rotate through all bitpositions */
329        register int tokval;
330
331	while (lp != NULL && lp->s != NULL) {
332            tokval=lp->v;   /* load our first value */
333            rotbit=1;
334            while (rotbit != 0) {
335                /*
336                 * lets AND the rotating bit with our token value
337                 * and see if we have got a match
338                 */
339		if (tokval == (v&rotbit)) {
340                    /* ok we have found something */
341                    buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s%s",
342                                     lp->s, sep ? ", " : "");
343                    break;
344                }
345                rotbit=rotbit<<1; /* no match - lets shift and try again */
346            }
347            lp++;
348	}
349
350        /* user didn't want string seperation - no need to cut off trailing seperators */
351        if (!sep) {
352            return (buf);
353        }
354
355        if (buflen != 0) { /* did we find anything */
356            /* yep, set the the trailing zero 2 bytes before to eliminate the last comma & whitespace */
357            buf[buflen-2] = '\0';
358            return (buf);
359        }
360        else {
361            /* bummer - lets print the "unknown" message as advised in the fmt string if we got one */
362            if (fmt == NULL)
363		fmt = "#%d";
364            (void)snprintf(buf, sizeof(buf), fmt, v);
365            return (buf);
366        }
367}
368
369/*
370 * Convert a bit token value to a string; use "fmt" if not found.
371 * this is useful for parsing bitfields, the output strings are not seperated.
372 */
373char *
374bittok2str_nosep(register const struct tok *lp, register const char *fmt,
375	   register int v)
376{
377    return (bittok2str_internal(lp, fmt, v, 0));
378}
379
380/*
381 * Convert a bit token value to a string; use "fmt" if not found.
382 * this is useful for parsing bitfields, the output strings are comma seperated.
383 */
384char *
385bittok2str(register const struct tok *lp, register const char *fmt,
386	   register int v)
387{
388    return (bittok2str_internal(lp, fmt, v, 1));
389}
390
391/*
392 * Convert a value to a string using an array; the macro
393 * tok2strary() in <interface.h> is the public interface to
394 * this function and ensures that the second argument is
395 * correct for bounds-checking.
396 */
397const char *
398tok2strary_internal(register const char **lp, int n, register const char *fmt,
399	register int v)
400{
401	static char buf[128];
402
403	if (v >= 0 && v < n && lp[v] != NULL)
404		return lp[v];
405	if (fmt == NULL)
406		fmt = "#%d";
407	(void)snprintf(buf, sizeof(buf), fmt, v);
408	return (buf);
409}
410
411/*
412 * Convert a 32-bit netmask to prefixlen if possible
413 * the function returns the prefix-len; if plen == -1
414 * then conversion was not possible;
415 */
416
417int
418mask2plen(u_int32_t mask)
419{
420	u_int32_t bitmasks[33] = {
421		0x00000000,
422		0x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
423		0xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
424		0xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
425		0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
426		0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
427		0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
428		0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
429		0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff
430	};
431	int prefix_len = 32;
432
433	/* let's see if we can transform the mask into a prefixlen */
434	while (prefix_len >= 0) {
435		if (bitmasks[prefix_len] == mask)
436			break;
437		prefix_len--;
438	}
439	return (prefix_len);
440}
441
442#ifdef INET6
443int
444mask62plen(const u_char *mask)
445{
446	u_char bitmasks[9] = {
447		0x00,
448		0x80, 0xc0, 0xe0, 0xf0,
449		0xf8, 0xfc, 0xfe, 0xff
450	};
451	int byte;
452	int cidr_len = 0;
453
454	for (byte = 0; byte < 16; byte++) {
455		u_int bits;
456
457		for (bits = 0; bits < (sizeof (bitmasks) / sizeof (bitmasks[0])); bits++) {
458			if (mask[byte] == bitmasks[bits]) {
459				cidr_len += bits;
460				break;
461			}
462		}
463
464		if (mask[byte] != 0xff)
465			break;
466	}
467	return (cidr_len);
468}
469#endif /* INET6 */
470
471/* VARARGS */
472void
473error(const char *fmt, ...)
474{
475	va_list ap;
476
477	(void)fprintf(stderr, "%s: ", program_name);
478	va_start(ap, fmt);
479	(void)vfprintf(stderr, fmt, ap);
480	va_end(ap);
481	if (*fmt) {
482		fmt += strlen(fmt);
483		if (fmt[-1] != '\n')
484			(void)fputc('\n', stderr);
485	}
486	exit(1);
487	/* NOTREACHED */
488}
489
490/* VARARGS */
491void
492warning(const char *fmt, ...)
493{
494	va_list ap;
495
496	(void)fprintf(stderr, "%s: WARNING: ", program_name);
497	va_start(ap, fmt);
498	(void)vfprintf(stderr, fmt, ap);
499	va_end(ap);
500	if (*fmt) {
501		fmt += strlen(fmt);
502		if (fmt[-1] != '\n')
503			(void)fputc('\n', stderr);
504	}
505}
506
507/*
508 * Copy arg vector into a new buffer, concatenating arguments with spaces.
509 */
510char *
511copy_argv(register char **argv)
512{
513	register char **p;
514	register u_int len = 0;
515	char *buf;
516	char *src, *dst;
517
518	p = argv;
519	if (*p == 0)
520		return 0;
521
522	while (*p)
523		len += strlen(*p++) + 1;
524
525	buf = (char *)malloc(len);
526	if (buf == NULL)
527		error("copy_argv: malloc");
528
529	p = argv;
530	dst = buf;
531	while ((src = *p++) != NULL) {
532		while ((*dst++ = *src++) != '\0')
533			;
534		dst[-1] = ' ';
535	}
536	dst[-1] = '\0';
537
538	return buf;
539}
540
541/*
542 * On Windows, we need to open the file in binary mode, so that
543 * we get all the bytes specified by the size we get from "fstat()".
544 * On UNIX, that's not necessary.  O_BINARY is defined on Windows;
545 * we define it as 0 if it's not defined, so it does nothing.
546 */
547#ifndef O_BINARY
548#define O_BINARY	0
549#endif
550
551char *
552read_infile(char *fname)
553{
554	register int i, fd, cc;
555	register char *cp;
556	struct stat buf;
557
558	fd = open(fname, O_RDONLY|O_BINARY);
559	if (fd < 0)
560		error("can't open %s: %s", fname, pcap_strerror(errno));
561
562	if (fstat(fd, &buf) < 0)
563		error("can't stat %s: %s", fname, pcap_strerror(errno));
564
565	cp = malloc((u_int)buf.st_size + 1);
566	if (cp == NULL)
567		error("malloc(%d) for %s: %s", (u_int)buf.st_size + 1,
568			fname, pcap_strerror(errno));
569	cc = read(fd, cp, (u_int)buf.st_size);
570	if (cc < 0)
571		error("read %s: %s", fname, pcap_strerror(errno));
572	if (cc != buf.st_size)
573		error("short read %s (%d != %d)", fname, cc, (int)buf.st_size);
574
575	close(fd);
576	/* replace "# comment" with spaces */
577	for (i = 0; i < cc; i++) {
578		if (cp[i] == '#')
579			while (i < cc && cp[i] != '\n')
580				cp[i++] = ' ';
581	}
582	cp[cc] = '\0';
583	return (cp);
584}
585
586void
587safeputs(const char *s, int maxlen)
588{
589	int idx = 0;
590
591	while (*s && idx < maxlen) {
592		safeputchar(*s);
593                idx++;
594		s++;
595	}
596}
597
598void
599safeputchar(int c)
600{
601	unsigned char ch;
602
603	ch = (unsigned char)(c & 0xff);
604	if (ch < 0x80 && ND_ISPRINT(ch))
605		printf("%c", ch);
606	else
607		printf("\\0x%02x", ch);
608}
609
610#ifdef LBL_ALIGN
611/*
612 * Some compilers try to optimize memcpy(), using the alignment constraint
613 * on the argument pointer type.  by using this function, we try to avoid the
614 * optimization.
615 */
616void
617unaligned_memcpy(void *p, const void *q, size_t l)
618{
619	memcpy(p, q, l);
620}
621
622/* As with memcpy(), so with memcmp(). */
623int
624unaligned_memcmp(const void *p, const void *q, size_t l)
625{
626	return (memcmp(p, q, l));
627}
628#endif
629