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
23 static 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
47 char * 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 */
54 int
fn_print(register const u_char * s,register const u_char * ep)55 fn_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 */
86 int
fn_printn(register const u_char * s,register u_int n,register const u_char * ep)87 fn_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 */
114 int
fn_printzp(register const u_char * s,register u_int n,register const u_char * ep)115 fn_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 */
146 char *
ts_format(register int sec,register int usec)147 ts_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 */
159 void
ts_print(register const struct timeval * tvp)160 ts_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 */
229 void
relts_print(int secs)230 relts_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
261 int
print_unknown_data(const u_char * cp,const char * ident,int len)262 print_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 */
283 const char *
tok2strbuf(register const struct tok * lp,register const char * fmt,register int v,char * buf,size_t bufsize)284 tok2strbuf(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 */
304 const char *
tok2str(register const struct tok * lp,register const char * fmt,register int v)305 tok2str(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 */
322 static char *
bittok2str_internal(register const struct tok * lp,register const char * fmt,register int v,register int sep)323 bittok2str_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 */
373 char *
bittok2str_nosep(register const struct tok * lp,register const char * fmt,register int v)374 bittok2str_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 */
384 char *
bittok2str(register const struct tok * lp,register const char * fmt,register int v)385 bittok2str(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 */
397 const char *
tok2strary_internal(register const char ** lp,int n,register const char * fmt,register int v)398 tok2strary_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
417 int
mask2plen(u_int32_t mask)418 mask2plen(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
443 int
mask62plen(const u_char * mask)444 mask62plen(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 */
472 void
error(const char * fmt,...)473 error(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 */
491 void
warning(const char * fmt,...)492 warning(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 */
510 char *
copy_argv(register char ** argv)511 copy_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
551 char *
read_infile(char * fname)552 read_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
586 void
safeputs(const char * s,int maxlen)587 safeputs(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
598 void
safeputchar(int c)599 safeputchar(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 */
616 void
unaligned_memcpy(void * p,const void * q,size_t l)617 unaligned_memcpy(void *p, const void *q, size_t l)
618 {
619 memcpy(p, q, l);
620 }
621
622 /* As with memcpy(), so with memcmp(). */
623 int
unaligned_memcmp(const void * p,const void * q,size_t l)624 unaligned_memcmp(const void *p, const void *q, size_t l)
625 {
626 return (memcmp(p, q, l));
627 }
628 #endif
629