nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 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 /*
23 * txtproto_print() derived from original code by Hannes Gredler
24 * (hannes@juniper.net):
25 *
26 * Redistribution and use in source and binary forms, with or without
27 * modification, are permitted provided that: (1) source code
28 * distributions retain the above copyright notice and this paragraph
29 * in its entirety, and (2) distributions including binary code include
30 * the above copyright notice and this paragraph in its entirety in
31 * the documentation or other materials provided with the distribution.
32 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
33 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
34 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
35 * FOR A PARTICULAR PURPOSE.
36 */
37  
38 #define NETDISSECT_REWORKED
39 #ifdef HAVE_CONFIG_H
40 #include "config.h"
41 #endif
42  
43 #include <tcpdump-stdinc.h>
44  
45 #include <sys/stat.h>
46  
47 #ifdef HAVE_FCNTL_H
48 #include <fcntl.h>
49 #endif
50 #include <stdio.h>
51 #include <stdarg.h>
52 #include <stdlib.h>
53 #include <string.h>
54  
55 #include "interface.h"
56  
57 /*
58 * Print out a null-terminated filename (or other ascii string).
59 * If ep is NULL, assume no truncation check is needed.
60 * Return true if truncated.
61 */
62 int
63 fn_print(netdissect_options *ndo,
64 register const u_char *s, register const u_char *ep)
65 {
66 register int ret;
67 register u_char c;
68  
69 ret = 1; /* assume truncated */
70 while (ep == NULL || s < ep) {
71 c = *s++;
72 if (c == '\0') {
73 ret = 0;
74 break;
75 }
76 if (!ND_ISASCII(c)) {
77 c = ND_TOASCII(c);
78 ND_PRINT((ndo, "M-"));
79 }
80 if (!ND_ISPRINT(c)) {
81 c ^= 0x40; /* DEL to ?, others to alpha */
82 ND_PRINT((ndo, "^"));
83 }
84 ND_PRINT((ndo, "%c", c));
85 }
86 return(ret);
87 }
88  
89 /*
90 * Print out a counted filename (or other ascii string).
91 * If ep is NULL, assume no truncation check is needed.
92 * Return true if truncated.
93 */
94 int
95 fn_printn(netdissect_options *ndo,
96 register const u_char *s, register u_int n, register const u_char *ep)
97 {
98 register u_char c;
99  
100 while (n > 0 && (ep == NULL || s < ep)) {
101 n--;
102 c = *s++;
103 if (!ND_ISASCII(c)) {
104 c = ND_TOASCII(c);
105 ND_PRINT((ndo, "M-"));
106 }
107 if (!ND_ISPRINT(c)) {
108 c ^= 0x40; /* DEL to ?, others to alpha */
109 ND_PRINT((ndo, "^"));
110 }
111 ND_PRINT((ndo, "%c", c));
112 }
113 return (n == 0) ? 0 : 1;
114 }
115  
116 /*
117 * Print out a null-padded filename (or other ascii string).
118 * If ep is NULL, assume no truncation check is needed.
119 * Return true if truncated.
120 */
121 int
122 fn_printzp(netdissect_options *ndo,
123 register const u_char *s, register u_int n,
124 register const u_char *ep)
125 {
126 register int ret;
127 register u_char c;
128  
129 ret = 1; /* assume truncated */
130 while (n > 0 && (ep == NULL || s < ep)) {
131 n--;
132 c = *s++;
133 if (c == '\0') {
134 ret = 0;
135 break;
136 }
137 if (!ND_ISASCII(c)) {
138 c = ND_TOASCII(c);
139 ND_PRINT((ndo, "M-"));
140 }
141 if (!ND_ISPRINT(c)) {
142 c ^= 0x40; /* DEL to ?, others to alpha */
143 ND_PRINT((ndo, "^"));
144 }
145 ND_PRINT((ndo, "%c", c));
146 }
147 return (n == 0) ? 0 : ret;
148 }
149  
150 /*
151 * Format the timestamp
152 */
153 static char *
154 ts_format(netdissect_options *ndo
155 #ifndef HAVE_PCAP_SET_TSTAMP_PRECISION
156 _U_
157 #endif
158 , int sec, int usec)
159 {
160 static char buf[sizeof("00:00:00.000000000")];
161 const char *format;
162  
163 #ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
164 switch (ndo->ndo_tstamp_precision) {
165  
166 case PCAP_TSTAMP_PRECISION_MICRO:
167 format = "%02d:%02d:%02d.%06u";
168 break;
169  
170 case PCAP_TSTAMP_PRECISION_NANO:
171 format = "%02d:%02d:%02d.%09u";
172 break;
173  
174 default:
175 format = "%02d:%02d:%02d.{unknown precision}";
176 break;
177 }
178 #else
179 format = "%02d:%02d:%02d.%06u";
180 #endif
181  
182 snprintf(buf, sizeof(buf), format,
183 sec / 3600, (sec % 3600) / 60, sec % 60, usec);
184  
185 return buf;
186 }
187  
188 /*
189 * Print the timestamp
190 */
191 void
192 ts_print(netdissect_options *ndo,
193 register const struct timeval *tvp)
194 {
195 register int s;
196 struct tm *tm;
197 time_t Time;
198 static unsigned b_sec;
199 static unsigned b_usec;
200 int d_usec;
201 int d_sec;
202  
203 switch (ndo->ndo_tflag) {
204  
205 case 0: /* Default */
206 s = (tvp->tv_sec + thiszone) % 86400;
207 ND_PRINT((ndo, "%s ", ts_format(ndo, s, tvp->tv_usec)));
208 break;
209  
210 case 1: /* No time stamp */
211 break;
212  
213 case 2: /* Unix timeval style */
214 ND_PRINT((ndo, "%u.%06u ",
215 (unsigned)tvp->tv_sec,
216 (unsigned)tvp->tv_usec));
217 break;
218  
219 case 3: /* Microseconds since previous packet */
220 case 5: /* Microseconds since first packet */
221 if (b_sec == 0) {
222 /* init timestamp for first packet */
223 b_usec = tvp->tv_usec;
224 b_sec = tvp->tv_sec;
225 }
226  
227 d_usec = tvp->tv_usec - b_usec;
228 d_sec = tvp->tv_sec - b_sec;
229  
230 while (d_usec < 0) {
231 d_usec += 1000000;
232 d_sec--;
233 }
234  
235 ND_PRINT((ndo, "%s ", ts_format(ndo, d_sec, d_usec)));
236  
237 if (ndo->ndo_tflag == 3) { /* set timestamp for last packet */
238 b_sec = tvp->tv_sec;
239 b_usec = tvp->tv_usec;
240 }
241 break;
242  
243 case 4: /* Default + Date*/
244 s = (tvp->tv_sec + thiszone) % 86400;
245 Time = (tvp->tv_sec + thiszone) - s;
246 tm = gmtime (&Time);
247 if (!tm)
248 ND_PRINT((ndo, "Date fail "));
249 else
250 ND_PRINT((ndo, "%04d-%02d-%02d %s ",
251 tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
252 ts_format(ndo, s, tvp->tv_usec)));
253 break;
254 }
255 }
256  
257 /*
258 * Print a relative number of seconds (e.g. hold time, prune timer)
259 * in the form 5m1s. This does no truncation, so 32230861 seconds
260 * is represented as 1y1w1d1h1m1s.
261 */
262 void
263 relts_print(netdissect_options *ndo,
264 int secs)
265 {
266 static const char *lengths[] = {"y", "w", "d", "h", "m", "s"};
267 static const int seconds[] = {31536000, 604800, 86400, 3600, 60, 1};
268 const char **l = lengths;
269 const int *s = seconds;
270  
271 if (secs == 0) {
272 ND_PRINT((ndo, "0s"));
273 return;
274 }
275 if (secs < 0) {
276 ND_PRINT((ndo, "-"));
277 secs = -secs;
278 }
279 while (secs > 0) {
280 if (secs >= *s) {
281 ND_PRINT((ndo, "%d%s", secs / *s, *l));
282 secs -= (secs / *s) * *s;
283 }
284 s++;
285 l++;
286 }
287 }
288  
289 /*
290 * this is a generic routine for printing unknown data;
291 * we pass on the linefeed plus indentation string to
292 * get a proper output - returns 0 on error
293 */
294  
295 int
296 print_unknown_data(netdissect_options *ndo, const u_char *cp,const char *ident,int len)
297 {
298 if (len < 0) {
299 ND_PRINT((ndo,"%sDissector error: print_unknown_data called with negative length",
300 ident));
301 return(0);
302 }
303 if (ndo->ndo_snapend - cp < len)
304 len = ndo->ndo_snapend - cp;
305 if (len < 0) {
306 ND_PRINT((ndo,"%sDissector error: print_unknown_data called with pointer past end of packet",
307 ident));
308 return(0);
309 }
310 hex_print(ndo, ident,cp,len);
311 return(1); /* everything is ok */
312 }
313  
314 /*
315 * Convert a token value to a string; use "fmt" if not found.
316 */
317 const char *
318 tok2strbuf(register const struct tok *lp, register const char *fmt,
319 register u_int v, char *buf, size_t bufsize)
320 {
321 if (lp != NULL) {
322 while (lp->s != NULL) {
323 if (lp->v == v)
324 return (lp->s);
325 ++lp;
326 }
327 }
328 if (fmt == NULL)
329 fmt = "#%d";
330  
331 (void)snprintf(buf, bufsize, fmt, v);
332 return (const char *)buf;
333 }
334  
335 /*
336 * Convert a token value to a string; use "fmt" if not found.
337 */
338 const char *
339 tok2str(register const struct tok *lp, register const char *fmt,
340 register u_int v)
341 {
342 static char buf[4][128];
343 static int idx = 0;
344 char *ret;
345  
346 ret = buf[idx];
347 idx = (idx+1) & 3;
348 return tok2strbuf(lp, fmt, v, ret, sizeof(buf[0]));
349 }
350  
351 /*
352 * Convert a bit token value to a string; use "fmt" if not found.
353 * this is useful for parsing bitfields, the output strings are seperated
354 * if the s field is positive.
355 */
356 static char *
357 bittok2str_internal(register const struct tok *lp, register const char *fmt,
358 register u_int v, const char *sep)
359 {
360 static char buf[256]; /* our stringbuffer */
361 int buflen=0;
362 register u_int rotbit; /* this is the bit we rotate through all bitpositions */
363 register u_int tokval;
364 const char * sepstr = "";
365  
366 while (lp != NULL && lp->s != NULL) {
367 tokval=lp->v; /* load our first value */
368 rotbit=1;
369 while (rotbit != 0) {
370 /*
371 * lets AND the rotating bit with our token value
372 * and see if we have got a match
373 */
374 if (tokval == (v&rotbit)) {
375 /* ok we have found something */
376 buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s%s",
377 sepstr, lp->s);
378 sepstr = sep;
379 break;
380 }
381 rotbit=rotbit<<1; /* no match - lets shift and try again */
382 }
383 lp++;
384 }
385  
386 if (buflen == 0)
387 /* bummer - lets print the "unknown" message as advised in the fmt string if we got one */
388 (void)snprintf(buf, sizeof(buf), fmt == NULL ? "#%08x" : fmt, v);
389 return (buf);
390 }
391  
392 /*
393 * Convert a bit token value to a string; use "fmt" if not found.
394 * this is useful for parsing bitfields, the output strings are not seperated.
395 */
396 char *
397 bittok2str_nosep(register const struct tok *lp, register const char *fmt,
398 register u_int v)
399 {
400 return (bittok2str_internal(lp, fmt, v, ""));
401 }
402  
403 /*
404 * Convert a bit token value to a string; use "fmt" if not found.
405 * this is useful for parsing bitfields, the output strings are comma seperated.
406 */
407 char *
408 bittok2str(register const struct tok *lp, register const char *fmt,
409 register u_int v)
410 {
411 return (bittok2str_internal(lp, fmt, v, ", "));
412 }
413  
414 /*
415 * Convert a value to a string using an array; the macro
416 * tok2strary() in <interface.h> is the public interface to
417 * this function and ensures that the second argument is
418 * correct for bounds-checking.
419 */
420 const char *
421 tok2strary_internal(register const char **lp, int n, register const char *fmt,
422 register int v)
423 {
424 static char buf[128];
425  
426 if (v >= 0 && v < n && lp[v] != NULL)
427 return lp[v];
428 if (fmt == NULL)
429 fmt = "#%d";
430 (void)snprintf(buf, sizeof(buf), fmt, v);
431 return (buf);
432 }
433  
434 /*
435 * Convert a 32-bit netmask to prefixlen if possible
436 * the function returns the prefix-len; if plen == -1
437 * then conversion was not possible;
438 */
439  
440 int
441 mask2plen(uint32_t mask)
442 {
443 uint32_t bitmasks[33] = {
444 0x00000000,
445 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
446 0xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
447 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
448 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
449 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
450 0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
451 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
452 0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff
453 };
454 int prefix_len = 32;
455  
456 /* let's see if we can transform the mask into a prefixlen */
457 while (prefix_len >= 0) {
458 if (bitmasks[prefix_len] == mask)
459 break;
460 prefix_len--;
461 }
462 return (prefix_len);
463 }
464  
465 #ifdef INET6
466 int
467 mask62plen(const u_char *mask)
468 {
469 u_char bitmasks[9] = {
470 0x00,
471 0x80, 0xc0, 0xe0, 0xf0,
472 0xf8, 0xfc, 0xfe, 0xff
473 };
474 int byte;
475 int cidr_len = 0;
476  
477 for (byte = 0; byte < 16; byte++) {
478 u_int bits;
479  
480 for (bits = 0; bits < (sizeof (bitmasks) / sizeof (bitmasks[0])); bits++) {
481 if (mask[byte] == bitmasks[bits]) {
482 cidr_len += bits;
483 break;
484 }
485 }
486  
487 if (mask[byte] != 0xff)
488 break;
489 }
490 return (cidr_len);
491 }
492 #endif /* INET6 */
493  
494 /*
495 * Routine to print out information for text-based protocols such as FTP,
496 * HTTP, SMTP, RTSP, SIP, ....
497 */
498 #define MAX_TOKEN 128
499  
500 /*
501 * Fetch a token from a packet, starting at the specified index,
502 * and return the length of the token.
503 *
504 * Returns 0 on error; yes, this is indistinguishable from an empty
505 * token, but an "empty token" isn't a valid token - it just means
506 * either a space character at the beginning of the line (this
507 * includes a blank line) or no more tokens remaining on the line.
508 */
509 static int
510 fetch_token(netdissect_options *ndo, const u_char *pptr, u_int idx, u_int len,
511 u_char *tbuf, size_t tbuflen)
512 {
513 size_t toklen = 0;
514  
515 for (; idx < len; idx++) {
516 if (!ND_TTEST(*(pptr + idx))) {
517 /* ran past end of captured data */
518 return (0);
519 }
520 if (!isascii(*(pptr + idx))) {
521 /* not an ASCII character */
522 return (0);
523 }
524 if (isspace(*(pptr + idx))) {
525 /* end of token */
526 break;
527 }
528 if (!isprint(*(pptr + idx))) {
529 /* not part of a command token or response code */
530 return (0);
531 }
532 if (toklen + 2 > tbuflen) {
533 /* no room for this character and terminating '\0' */
534 return (0);
535 }
536 tbuf[toklen] = *(pptr + idx);
537 toklen++;
538 }
539 if (toklen == 0) {
540 /* no token */
541 return (0);
542 }
543 tbuf[toklen] = '\0';
544  
545 /*
546 * Skip past any white space after the token, until we see
547 * an end-of-line (CR or LF).
548 */
549 for (; idx < len; idx++) {
550 if (!ND_TTEST(*(pptr + idx))) {
551 /* ran past end of captured data */
552 break;
553 }
554 if (*(pptr + idx) == '\r' || *(pptr + idx) == '\n') {
555 /* end of line */
556 break;
557 }
558 if (!isascii(*(pptr + idx)) || !isprint(*(pptr + idx))) {
559 /* not a printable ASCII character */
560 break;
561 }
562 if (!isspace(*(pptr + idx))) {
563 /* beginning of next token */
564 break;
565 }
566 }
567 return (idx);
568 }
569  
570 /*
571 * Scan a buffer looking for a line ending - LF or CR-LF.
572 * Return the index of the character after the line ending or 0 if
573 * we encounter a non-ASCII or non-printable character or don't find
574 * the line ending.
575 */
576 static u_int
577 print_txt_line(netdissect_options *ndo, const char *protoname,
578 const char *prefix, const u_char *pptr, u_int idx, u_int len)
579 {
580 u_int startidx;
581 u_int linelen;
582  
583 startidx = idx;
584 while (idx < len) {
585 ND_TCHECK(*(pptr+idx));
586 if (*(pptr+idx) == '\n') {
587 /*
588 * LF without CR; end of line.
589 * Skip the LF and print the line, with the
590 * exception of the LF.
591 */
592 linelen = idx - startidx;
593 idx++;
594 goto print;
595 } else if (*(pptr+idx) == '\r') {
596 /* CR - any LF? */
597 if ((idx+1) >= len) {
598 /* not in this packet */
599 return (0);
600 }
601 ND_TCHECK(*(pptr+idx+1));
602 if (*(pptr+idx+1) == '\n') {
603 /*
604 * CR-LF; end of line.
605 * Skip the CR-LF and print the line, with
606 * the exception of the CR-LF.
607 */
608 linelen = idx - startidx;
609 idx += 2;
610 goto print;
611 }
612  
613 /*
614 * CR followed by something else; treat this
615 * as if it were binary data, and don't print
616 * it.
617 */
618 return (0);
619 } else if (!isascii(*(pptr+idx)) ||
620 (!isprint(*(pptr+idx)) && *(pptr+idx) != '\t')) {
621 /*
622 * Not a printable ASCII character and not a tab;
623 * treat this as if it were binary data, and
624 * don't print it.
625 */
626 return (0);
627 }
628 idx++;
629 }
630  
631 /*
632 * All printable ASCII, but no line ending after that point
633 * in the buffer; treat this as if it were truncated.
634 */
635 trunc:
636 linelen = idx - startidx;
637 ND_PRINT((ndo, "%s%.*s[!%s]", prefix, (int)linelen, pptr + startidx,
638 protoname));
639 return (0);
640  
641 print:
642 ND_PRINT((ndo, "%s%.*s", prefix, (int)linelen, pptr + startidx));
643 return (idx);
644 }
645  
646 void
647 txtproto_print(netdissect_options *ndo, const u_char *pptr, u_int len,
648 const char *protoname, const char **cmds, u_int flags)
649 {
650 u_int idx, eol;
651 u_char token[MAX_TOKEN+1];
652 const char *cmd;
653 int is_reqresp = 0;
654 const char *pnp;
655  
656 if (cmds != NULL) {
657 /*
658 * This protocol has more than just request and
659 * response lines; see whether this looks like a
660 * request or response.
661 */
662 idx = fetch_token(ndo, pptr, 0, len, token, sizeof(token));
663 if (idx != 0) {
664 /* Is this a valid request name? */
665 while ((cmd = *cmds++) != NULL) {
666 if (strcasecmp((const char *)token, cmd) == 0) {
667 /* Yes. */
668 is_reqresp = 1;
669 break;
670 }
671 }
672  
673 /*
674 * No - is this a valid response code (3 digits)?
675 *
676 * Is this token the response code, or is the next
677 * token the response code?
678 */
679 if (flags & RESP_CODE_SECOND_TOKEN) {
680 /*
681 * Next token - get it.
682 */
683 idx = fetch_token(ndo, pptr, idx, len, token,
684 sizeof(token));
685 }
686 if (idx != 0) {
687 if (isdigit(token[0]) && isdigit(token[1]) &&
688 isdigit(token[2]) && token[3] == '\0') {
689 /* Yes. */
690 is_reqresp = 1;
691 }
692 }
693 }
694 } else {
695 /*
696 * This protocol has only request and response lines
697 * (e.g., FTP, where all the data goes over a
698 * different connection); assume the payload is
699 * a request or response.
700 */
701 is_reqresp = 1;
702 }
703  
704 /* Capitalize the protocol name */
705 for (pnp = protoname; *pnp != '\0'; pnp++)
706 ND_PRINT((ndo, "%c", toupper(*pnp)));
707  
708 if (is_reqresp) {
709 /*
710 * In non-verbose mode, just print the protocol, followed
711 * by the first line as the request or response info.
712 *
713 * In verbose mode, print lines as text until we run out
714 * of characters or see something that's not a
715 * printable-ASCII line.
716 */
717 if (ndo->ndo_vflag) {
718 /*
719 * We're going to print all the text lines in the
720 * request or response; just print the length
721 * on the first line of the output.
722 */
723 ND_PRINT((ndo, ", length: %u", len));
724 for (idx = 0;
725 idx < len && (eol = print_txt_line(ndo, protoname, "\n\t", pptr, idx, len)) != 0;
726 idx = eol)
727 ;
728 } else {
729 /*
730 * Just print the first text line.
731 */
732 print_txt_line(ndo, protoname, ": ", pptr, 0, len);
733 }
734 }
735 }
736  
737 /* VARARGS */
738 void
739 error(const char *fmt, ...)
740 {
741 va_list ap;
742  
743 (void)fprintf(stderr, "%s: ", program_name);
744 va_start(ap, fmt);
745 (void)vfprintf(stderr, fmt, ap);
746 va_end(ap);
747 if (*fmt) {
748 fmt += strlen(fmt);
749 if (fmt[-1] != '\n')
750 (void)fputc('\n', stderr);
751 }
752 exit(1);
753 /* NOTREACHED */
754 }
755  
756 /* VARARGS */
757 void
758 warning(const char *fmt, ...)
759 {
760 va_list ap;
761  
762 (void)fprintf(stderr, "%s: WARNING: ", program_name);
763 va_start(ap, fmt);
764 (void)vfprintf(stderr, fmt, ap);
765 va_end(ap);
766 if (*fmt) {
767 fmt += strlen(fmt);
768 if (fmt[-1] != '\n')
769 (void)fputc('\n', stderr);
770 }
771 }
772  
773 /*
774 * Copy arg vector into a new buffer, concatenating arguments with spaces.
775 */
776 char *
777 copy_argv(register char **argv)
778 {
779 register char **p;
780 register u_int len = 0;
781 char *buf;
782 char *src, *dst;
783  
784 p = argv;
785 if (*p == 0)
786 return 0;
787  
788 while (*p)
789 len += strlen(*p++) + 1;
790  
791 buf = (char *)malloc(len);
792 if (buf == NULL)
793 error("copy_argv: malloc");
794  
795 p = argv;
796 dst = buf;
797 while ((src = *p++) != NULL) {
798 while ((*dst++ = *src++) != '\0')
799 ;
800 dst[-1] = ' ';
801 }
802 dst[-1] = '\0';
803  
804 return buf;
805 }
806  
807 /*
808 * On Windows, we need to open the file in binary mode, so that
809 * we get all the bytes specified by the size we get from "fstat()".
810 * On UNIX, that's not necessary. O_BINARY is defined on Windows;
811 * we define it as 0 if it's not defined, so it does nothing.
812 */
813 #ifndef O_BINARY
814 #define O_BINARY 0
815 #endif
816  
817 char *
818 read_infile(char *fname)
819 {
820 register int i, fd, cc;
821 register char *cp;
822 struct stat buf;
823  
824 fd = open(fname, O_RDONLY|O_BINARY);
825 if (fd < 0)
826 error("can't open %s: %s", fname, pcap_strerror(errno));
827  
828 if (fstat(fd, &buf) < 0)
829 error("can't stat %s: %s", fname, pcap_strerror(errno));
830  
831 cp = malloc((u_int)buf.st_size + 1);
832 if (cp == NULL)
833 error("malloc(%d) for %s: %s", (u_int)buf.st_size + 1,
834 fname, pcap_strerror(errno));
835 cc = read(fd, cp, (u_int)buf.st_size);
836 if (cc < 0)
837 error("read %s: %s", fname, pcap_strerror(errno));
838 if (cc != buf.st_size)
839 error("short read %s (%d != %d)", fname, cc, (int)buf.st_size);
840  
841 close(fd);
842 /* replace "# comment" with spaces */
843 for (i = 0; i < cc; i++) {
844 if (cp[i] == '#')
845 while (i < cc && cp[i] != '\n')
846 cp[i++] = ' ';
847 }
848 cp[cc] = '\0';
849 return (cp);
850 }
851  
852 void
853 safeputs(netdissect_options *ndo,
854 const u_char *s, const u_int maxlen)
855 {
856 u_int idx = 0;
857  
858 while (*s && idx < maxlen) {
859 safeputchar(ndo, *s);
860 idx++;
861 s++;
862 }
863 }
864  
865 void
866 safeputchar(netdissect_options *ndo,
867 const u_char c)
868 {
869 ND_PRINT((ndo, (c < 0x80 && ND_ISPRINT(c)) ? "%c" : "\\0x%02x", c));
870 }
871  
872 #ifdef LBL_ALIGN
873 /*
874 * Some compilers try to optimize memcpy(), using the alignment constraint
875 * on the argument pointer type. by using this function, we try to avoid the
876 * optimization.
877 */
878 void
879 unaligned_memcpy(void *p, const void *q, size_t l)
880 {
881 memcpy(p, q, l);
882 }
883  
884 /* As with memcpy(), so with memcmp(). */
885 int
886 unaligned_memcmp(const void *p, const void *q, size_t l)
887 {
888 return (memcmp(p, q, l));
889 }
890 #endif