]> The Tcpdump Group git mirrors - tcpdump/blob - print-ip.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
atabify
[tcpdump] / print-ip.c
1 /*
2 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 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[] =
24 "@(#) $Header: /tcpdump/master/tcpdump/print-ip.c,v 1.93 2001-01-28 08:18:27 itojun Exp $ (LBL)";
25 #endif
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #include <sys/param.h>
32 #include <sys/time.h>
33 #include <sys/socket.h>
34
35 #include <netinet/in.h>
36
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <unistd.h>
41
42 #include "addrtoname.h"
43 #include "interface.h"
44 #include "extract.h" /* must come after interface.h */
45
46 #include "ip.h"
47
48 /* Compatibility */
49 #ifndef IPPROTO_ND
50 #define IPPROTO_ND 77
51 #endif
52
53 /*
54 * print the recorded route in an IP RR, LSRR or SSRR option.
55 */
56 static void
57 ip_printroute(const char *type, register const u_char *cp, u_int length)
58 {
59 register u_int ptr = cp[2] - 1;
60 register u_int len;
61
62 printf(" %s{", type);
63 if ((length + 1) & 3)
64 printf(" [bad length %d]", length);
65 if (ptr < 3 || ((ptr + 1) & 3) || ptr > length + 1)
66 printf(" [bad ptr %d]", cp[2]);
67
68 type = "";
69 for (len = 3; len < length; len += 4) {
70 if (ptr == len)
71 type = "#";
72 printf("%s%s", type, ipaddr_string(&cp[len]));
73 type = " ";
74 }
75 printf("%s}", ptr == len? "#" : "");
76 }
77
78 static void
79 ip_printts(register const u_char *cp, u_int length)
80 {
81 register u_int ptr = cp[2] - 1;
82 register u_int len = 0;
83 int hoplen;
84 char *type;
85
86 printf(" TS{");
87 hoplen = ((cp[3]&0xF) != IPOPT_TS_TSONLY) ? 8 : 4;
88 if ((length - 4) & (hoplen-1))
89 printf("[bad length %d]", length);
90 if (ptr < 4 || ((ptr - 4) & (hoplen-1)) || ptr > length + 1)
91 printf("[bad ptr %d]", cp[2]);
92 switch (cp[3]&0xF) {
93 case IPOPT_TS_TSONLY:
94 printf("TSONLY");
95 break;
96 case IPOPT_TS_TSANDADDR:
97 printf("TS+ADDR");
98 break;
99 /*
100 * prespecified should really be 3, but some ones might send 2
101 * instead, and the IPOPT_TS_PRESPEC constant can apparently
102 * have both values, so we have to hard-code it here.
103 */
104
105 case 2:
106 printf("PRESPEC2.0");
107 break;
108 case 3: /* IPOPT_TS_PRESPEC */
109 printf("PRESPEC");
110 break;
111 default:
112 printf("[bad ts type %d]", cp[3]&0xF);
113 goto done;
114 }
115
116 type = " ";
117 for (len = 4; len < length; len += hoplen) {
118 if (ptr == len)
119 type = " ^ ";
120 printf("%s%d@%s", type, EXTRACT_32BITS(&cp[len+hoplen-4]),
121 hoplen!=8 ? "" : ipaddr_string(&cp[len]));
122 type = " ";
123 }
124
125 done:
126 printf("%s", ptr == len ? " ^ " : "");
127
128 if (cp[3]>>4)
129 printf(" [%d hops not recorded]} ", cp[3]>>4);
130 else
131 printf("}");
132 }
133
134 /*
135 * print IP options.
136 */
137 static void
138 ip_optprint(register const u_char *cp, u_int length)
139 {
140 register u_int len;
141
142 for (; length > 0; cp += len, length -= len) {
143 int tt = *cp;
144
145 if (tt == IPOPT_NOP || tt == IPOPT_EOL)
146 len = 1;
147 else {
148 if (&cp[1] >= snapend) {
149 printf("[|ip]");
150 return;
151 }
152 len = cp[1];
153 }
154 if (len <= 0) {
155 printf("[|ip op len %d]", len);
156 return;
157 }
158 if (&cp[1] >= snapend || cp + len > snapend) {
159 printf("[|ip]");
160 return;
161 }
162 switch (tt) {
163
164 case IPOPT_EOL:
165 printf(" EOL");
166 if (length > 1)
167 printf("-%d", length - 1);
168 return;
169
170 case IPOPT_NOP:
171 printf(" NOP");
172 break;
173
174 case IPOPT_TS:
175 ip_printts(cp, len);
176 break;
177
178 #ifndef IPOPT_SECURITY
179 #define IPOPT_SECURITY 130
180 #endif /* IPOPT_SECURITY */
181 case IPOPT_SECURITY:
182 printf(" SECURITY{%d}", len);
183 break;
184
185 case IPOPT_RR:
186 ip_printroute("RR", cp, len);
187 break;
188
189 case IPOPT_SSRR:
190 ip_printroute("SSRR", cp, len);
191 break;
192
193 case IPOPT_LSRR:
194 ip_printroute("LSRR", cp, len);
195 break;
196
197 #ifndef IPOPT_RA
198 #define IPOPT_RA 148 /* router alert */
199 #endif
200 case IPOPT_RA:
201 printf(" RA");
202 if (len != 4)
203 printf("{%d}", len);
204 else if (cp[2] || cp[3])
205 printf("%d.%d", cp[2], cp[3]);
206 break;
207
208 default:
209 printf(" IPOPT-%d{%d}", cp[0], len);
210 break;
211 }
212 }
213 }
214
215 /*
216 * compute an IP header checksum.
217 * don't modifiy the packet.
218 */
219 u_short
220 in_cksum(const u_short *addr, register int len, u_short csum)
221 {
222 int nleft = len;
223 const u_short *w = addr;
224 u_short answer;
225 int sum = csum;
226
227 /*
228 * Our algorithm is simple, using a 32 bit accumulator (sum),
229 * we add sequential 16 bit words to it, and at the end, fold
230 * back all the carry bits from the top 16 bits into the lower
231 * 16 bits.
232 */
233 while (nleft > 1) {
234 sum += *w++;
235 nleft -= 2;
236 }
237 if (nleft == 1)
238 sum += htons(*(u_char *)w<<8);
239
240 /*
241 * add back carry outs from top 16 bits to low 16 bits
242 */
243 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
244 sum += (sum >> 16); /* add carry */
245 answer = ~sum; /* truncate to 16 bits */
246 return (answer);
247 }
248
249 /*
250 * print an IP datagram.
251 */
252 void
253 ip_print(register const u_char *bp, register u_int length)
254 {
255 register const struct ip *ip;
256 register u_int hlen, len, len0, off;
257 register const u_char *cp;
258 u_char nh;
259 int advance;
260
261 ip = (const struct ip *)bp;
262 #ifdef LBL_ALIGN
263 /*
264 * If the IP header is not aligned, copy into abuf.
265 * This will never happen with BPF. It does happen raw packet
266 * dumps from -r.
267 */
268 if ((long)ip & 3) {
269 static u_char *abuf = NULL;
270 static int didwarn = 0;
271
272 if (abuf == NULL) {
273 abuf = (u_char *)malloc(snaplen);
274 if (abuf == NULL)
275 error("ip_print: malloc");
276 }
277 memcpy((char *)abuf, (char *)ip, min(length, snaplen));
278 snapend += abuf - (u_char *)ip;
279 packetp = abuf;
280 ip = (struct ip *)abuf;
281 /* We really want libpcap to give us aligned packets */
282 if (!didwarn) {
283 warning("compensating for unaligned libpcap packets");
284 ++didwarn;
285 }
286 }
287 #endif
288 if ((u_char *)(ip + 1) > snapend) {
289 printf("[|ip]");
290 return;
291 }
292 if (length < sizeof (struct ip)) {
293 (void)printf("truncated-ip %d", length);
294 return;
295 }
296 hlen = IP_HL(ip) * 4;
297 if (hlen < sizeof (struct ip)) {
298 (void)printf("bad-hlen %d", hlen);
299 return;
300 }
301
302 len = ntohs(ip->ip_len);
303 if (length < len)
304 (void)printf("truncated-ip - %d bytes missing!",
305 len - length);
306 len -= hlen;
307 len0 = len;
308
309 /*
310 * If this is fragment zero, hand it to the next higher
311 * level protocol.
312 */
313 off = ntohs(ip->ip_off);
314 if ((off & 0x1fff) == 0) {
315 cp = (const u_char *)ip + hlen;
316 nh = ip->ip_p;
317
318 if (nh != IPPROTO_TCP && nh != IPPROTO_UDP) {
319 (void)printf("%s > %s: ", ipaddr_string(&ip->ip_src),
320 ipaddr_string(&ip->ip_dst));
321 }
322 again:
323 switch (nh) {
324
325 #ifndef IPPROTO_AH
326 #define IPPROTO_AH 51
327 #endif
328 case IPPROTO_AH:
329 nh = *cp;
330 advance = ah_print(cp, (const u_char *)ip);
331 cp += advance;
332 len -= advance;
333 goto again;
334
335 #ifndef IPPROTO_ESP
336 #define IPPROTO_ESP 50
337 #endif
338 case IPPROTO_ESP:
339 {
340 int enh;
341 advance = esp_print(cp, (const u_char *)ip, &enh);
342 cp += advance;
343 len -= advance;
344 if (enh < 0)
345 break;
346 nh = enh & 0xff;
347 goto again;
348 }
349
350 #ifndef IPPROTO_IPCOMP
351 #define IPPROTO_IPCOMP 108
352 #endif
353 case IPPROTO_IPCOMP:
354 {
355 int enh;
356 advance = ipcomp_print(cp, (const u_char *)ip, &enh);
357 cp += advance;
358 len -= advance;
359 if (enh < 0)
360 break;
361 nh = enh & 0xff;
362 goto again;
363 }
364
365 case IPPROTO_TCP:
366 tcp_print(cp, len, (const u_char *)ip, (off &~ 0x6000));
367 break;
368
369 case IPPROTO_UDP:
370 udp_print(cp, len, (const u_char *)ip, (off &~ 0x6000));
371 break;
372
373 case IPPROTO_ICMP:
374 icmp_print(cp, len, (const u_char *)ip);
375 break;
376
377 #ifndef IPPROTO_IGRP
378 #define IPPROTO_IGRP 9
379 #endif
380 case IPPROTO_IGRP:
381 igrp_print(cp, len, (const u_char *)ip);
382 break;
383
384 case IPPROTO_ND:
385 #if 0
386 (void)printf("%s > %s:", ipaddr_string(&ip->ip_src),
387 ipaddr_string(&ip->ip_dst));
388 #endif
389 (void)printf(" nd %d", len);
390 break;
391
392 case IPPROTO_EGP:
393 egp_print(cp, len, (const u_char *)ip);
394 break;
395
396 #ifndef IPPROTO_OSPF
397 #define IPPROTO_OSPF 89
398 #endif
399 case IPPROTO_OSPF:
400 ospf_print(cp, len, (const u_char *)ip);
401 break;
402
403 #ifndef IPPROTO_IGMP
404 #define IPPROTO_IGMP 2
405 #endif
406 case IPPROTO_IGMP:
407 igmp_print(cp, len, (const u_char *)ip);
408 break;
409
410 case 4:
411 /* DVMRP multicast tunnel (ip-in-ip encapsulation) */
412 #if 0
413 if (vflag)
414 (void)printf("%s > %s: ",
415 ipaddr_string(&ip->ip_src),
416 ipaddr_string(&ip->ip_dst));
417 #endif
418 ip_print(cp, len);
419 if (! vflag) {
420 printf(" (ipip)");
421 return;
422 }
423 break;
424
425 #ifdef INET6
426 #ifndef IP6PROTO_ENCAP
427 #define IP6PROTO_ENCAP 41
428 #endif
429 case IP6PROTO_ENCAP:
430 /* ip6-in-ip encapsulation */
431 #if 0
432 if (vflag)
433 (void)printf("%s > %s: ",
434 ipaddr_string(&ip->ip_src),
435 ipaddr_string(&ip->ip_dst));
436 #endif
437 ip6_print(cp, len);
438 if (! vflag) {
439 printf(" (encap)");
440 return;
441 }
442 break;
443 #endif /*INET6*/
444
445
446 #ifndef IPPROTO_GRE
447 #define IPPROTO_GRE 47
448 #endif
449 case IPPROTO_GRE:
450 if (vflag)
451 (void)printf("gre %s > %s: ",
452 ipaddr_string(&ip->ip_src),
453 ipaddr_string(&ip->ip_dst));
454 /* do it */
455 gre_print(cp, len);
456 if (! vflag) {
457 printf(" (gre encap)");
458 return;
459 }
460 break;
461
462 #ifndef IPPROTO_MOBILE
463 #define IPPROTO_MOBILE 55
464 #endif
465 case IPPROTO_MOBILE:
466 if (vflag)
467 (void)printf("mobile %s > %s: ",
468 ipaddr_string(&ip->ip_src),
469 ipaddr_string(&ip->ip_dst));
470 mobile_print(cp, len);
471 if (! vflag) {
472 printf(" (mobile encap)");
473 return;
474 }
475 break;
476
477 #ifndef IPPROTO_PIM
478 #define IPPROTO_PIM 103
479 #endif
480 case IPPROTO_PIM:
481 pim_print(cp, len);
482 break;
483
484 #ifndef IPPROTO_VRRP
485 #define IPPROTO_VRRP 112
486 #endif
487 case IPPROTO_VRRP:
488 if (vflag)
489 (void)printf("vrrp %s > %s: ",
490 ipaddr_string(&ip->ip_src),
491 ipaddr_string(&ip->ip_dst));
492 vrrp_print(cp, len, ip->ip_ttl);
493 break;
494
495 default:
496 #if 0
497 (void)printf("%s > %s:", ipaddr_string(&ip->ip_src),
498 ipaddr_string(&ip->ip_dst));
499 #endif
500 (void)printf(" ip-proto-%d %d", nh, len);
501 break;
502 }
503 }
504
505 /* Ultra quiet now means that all this stuff should be suppressed */
506 /* res 3-Nov-98 */
507 if (qflag > 1) return;
508
509
510 /*
511 * for fragmented datagrams, print id:size@offset. On all
512 * but the last stick a "+". For unfragmented datagrams, note
513 * the don't fragment flag.
514 */
515 len = len0; /* get the original length */
516 if (off & 0x3fff) {
517 /*
518 * if this isn't the first frag, we're missing the
519 * next level protocol header. print the ip addr.
520 */
521 if (off & 0x1fff)
522 (void)printf("%s > %s:", ipaddr_string(&ip->ip_src),
523 ipaddr_string(&ip->ip_dst));
524 #ifndef IP_MF
525 #define IP_MF 0x2000
526 #endif /* IP_MF */
527 #ifndef IP_DF
528 #define IP_DF 0x4000
529 #endif /* IP_DF */
530 (void)printf(" (frag %d:%u@%d%s)", ntohs(ip->ip_id), len,
531 (off & 0x1fff) * 8,
532 (off & IP_MF)? "+" : "");
533
534 } else if (off & IP_DF)
535 (void)printf(" (DF)");
536
537 if (ip->ip_tos) {
538 (void)printf(" [tos 0x%x", (int)ip->ip_tos);
539 /* ECN bits */
540 if (ip->ip_tos&0x02) {
541 (void)printf(",ECT");
542 if (ip->ip_tos&0x01)
543 (void)printf(",CE");
544 }
545 (void)printf("] ");
546 }
547
548 if (ip->ip_ttl <= 1)
549 (void)printf(" [ttl %d]", (int)ip->ip_ttl);
550
551 if (vflag) {
552 int sum;
553 char *sep = "";
554
555 printf(" (");
556 if (ip->ip_ttl > 1) {
557 (void)printf("%sttl %d", sep, (int)ip->ip_ttl);
558 sep = ", ";
559 }
560 if ((off & 0x3fff) == 0) {
561 (void)printf("%sid %d", sep, (int)ntohs(ip->ip_id));
562 sep = ", ";
563 }
564 (void)printf("%slen %d", sep, (int)ntohs(ip->ip_len));
565 sep = ", ";
566 if ((u_char *)ip + hlen <= snapend) {
567 sum = in_cksum((const u_short *)ip, hlen, 0);
568 if (sum != 0) {
569 (void)printf("%sbad cksum %x!", sep,
570 ntohs(ip->ip_sum));
571 sep = ", ";
572 }
573 }
574 if ((hlen -= sizeof(struct ip)) > 0) {
575 (void)printf("%soptlen=%d", sep, hlen);
576 ip_optprint((u_char *)(ip + 1), hlen);
577 }
578 printf(")");
579 }
580 }
581
582 void
583 ipN_print(register const u_char *bp, register u_int length)
584 {
585 struct ip *ip, hdr;
586
587 ip = (struct ip *)bp;
588 if (length < 4) {
589 (void)printf("truncated-ip %d", length);
590 return;
591 }
592 memcpy (&hdr, (char *)ip, 4);
593 switch (IP_V(&hdr)) {
594 case 4:
595 ip_print (bp, length);
596 return;
597 #ifdef INET6
598 case 6:
599 ip6_print (bp, length);
600 return;
601 #endif
602 default:
603 (void)printf("unknown ip %d", IP_V(&hdr));
604 return;
605 }
606 }
[mirror] the TCPdump network dissector