]> The Tcpdump Group git mirrors - tcpdump/blob - print-ppp.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
- add support for return code values
[tcpdump] / print-ppp.c
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 * Extensively modified by Motonori Shindo (mshindo@mshindo.net) for more
22 * complete PPP support.
23 */
24
25 /*
26 * TODO:
27 * o resolve XXX as much as possible
28 * o MP support
29 * o BAP support
30 */
31
32 #ifndef lint
33 static const char rcsid[] _U_ =
34 "@(#) $Header: /tcpdump/master/tcpdump/print-ppp.c,v 1.94 2004-03-24 03:30:06 guy Exp $ (LBL)";
35 #endif
36
37 #ifdef HAVE_CONFIG_H
38 #include "config.h"
39 #endif
40
41 #include <tcpdump-stdinc.h>
42
43 #ifdef __bsdi__
44 #include <net/slcompress.h>
45 #include <net/if_ppp.h>
46 #endif
47
48 #include <pcap.h>
49 #include <stdio.h>
50
51 #include "interface.h"
52 #include "extract.h"
53 #include "addrtoname.h"
54 #include "ppp.h"
55 #include "chdlc.h"
56 #include "ethertype.h"
57 #include "oui.h"
58
59 /*
60 * The following constatns are defined by IANA. Please refer to
61 * http://www.isi.edu/in-notes/iana/assignments/ppp-numbers
62 * for the up-to-date information.
63 */
64
65 /* Protocol Codes defined in ppp.h */
66
67 struct tok ppptype2str[] = {
68 { PPP_IP, "IP" },
69 { PPP_OSI, "OSI" },
70 { PPP_NS, "NS" },
71 { PPP_DECNET, "DECNET" },
72 { PPP_APPLE, "APPLE" },
73 { PPP_IPX, "IPX" },
74 { PPP_VJC, "VJC" },
75 { PPP_VJNC, "VJNC" },
76 { PPP_BRPDU, "BRPDU" },
77 { PPP_STII, "STII" },
78 { PPP_VINES, "VINES" },
79 { PPP_MPLS_UCAST, "MPLS" },
80 { PPP_MPLS_MCAST, "MPLS" },
81
82 { PPP_HELLO, "HELLO" },
83 { PPP_LUXCOM, "LUXCOM" },
84 { PPP_SNS, "SNS" },
85 { PPP_IPCP, "IPCP" },
86 { PPP_OSICP, "OSICP" },
87 { PPP_NSCP, "NSCP" },
88 { PPP_DECNETCP, "DECNETCP" },
89 { PPP_APPLECP, "APPLECP" },
90 { PPP_IPXCP, "IPXCP" },
91 { PPP_STIICP, "STIICP" },
92 { PPP_VINESCP, "VINESCP" },
93 { PPP_MPLSCP, "MPLSCP" },
94
95 { PPP_LCP, "LCP" },
96 { PPP_PAP, "PAP" },
97 { PPP_LQM, "LQM" },
98 { PPP_CHAP, "CHAP" },
99 { PPP_BACP, "BACP" },
100 { PPP_BAP, "BAP" },
101 { PPP_MP, "ML" },
102 { 0, NULL }
103 };
104
105 /* Control Protocols (LCP/IPCP/CCP etc.) Codes defined in RFC 1661 */
106
107 #define CPCODES_VEXT 0 /* Vendor-Specific (RFC2153) */
108 #define CPCODES_CONF_REQ 1 /* Configure-Request */
109 #define CPCODES_CONF_ACK 2 /* Configure-Ack */
110 #define CPCODES_CONF_NAK 3 /* Configure-Nak */
111 #define CPCODES_CONF_REJ 4 /* Configure-Reject */
112 #define CPCODES_TERM_REQ 5 /* Terminate-Request */
113 #define CPCODES_TERM_ACK 6 /* Terminate-Ack */
114 #define CPCODES_CODE_REJ 7 /* Code-Reject */
115 #define CPCODES_PROT_REJ 8 /* Protocol-Reject (LCP only) */
116 #define CPCODES_ECHO_REQ 9 /* Echo-Request (LCP only) */
117 #define CPCODES_ECHO_RPL 10 /* Echo-Reply (LCP only) */
118 #define CPCODES_DISC_REQ 11 /* Discard-Request (LCP only) */
119 #define CPCODES_ID 12 /* Identification (LCP only) RFC1570 */
120 #define CPCODES_TIME_REM 13 /* Time-Remaining (LCP only) RFC1570 */
121 #define CPCODES_RESET_REQ 14 /* Reset-Request (CCP only) RFC1962 */
122 #define CPCODES_RESET_REP 15 /* Reset-Reply (CCP only) */
123
124 struct tok cpcodes[] = {
125 {CPCODES_VEXT, "Vendor-Extension"}, /* RFC2153 */
126 {CPCODES_CONF_REQ, "Conf-Request"},
127 {CPCODES_CONF_ACK, "Conf-Ack"},
128 {CPCODES_CONF_NAK, "Conf-Nack"},
129 {CPCODES_CONF_REJ, "Conf-Reject"},
130 {CPCODES_TERM_REQ, "Term-Request"},
131 {CPCODES_TERM_ACK, "Term-Ack"},
132 {CPCODES_CODE_REJ, "Code-Reject"},
133 {CPCODES_PROT_REJ, "Prot-Reject"},
134 {CPCODES_ECHO_REQ, "Echo-Request"},
135 {CPCODES_ECHO_RPL, "Echo-Reply"},
136 {CPCODES_DISC_REQ, "Disc-Req"},
137 {CPCODES_ID, "Ident"}, /* RFC1570 */
138 {CPCODES_TIME_REM, "Time-Rem"}, /* RFC1570 */
139 {CPCODES_RESET_REQ, "Reset-Req"}, /* RFC1962 */
140 {CPCODES_RESET_REP, "Reset-Ack"}, /* RFC1962 */
141 {0, NULL}
142 };
143
144 /* LCP Config Options */
145
146 #define LCPOPT_VEXT 0
147 #define LCPOPT_MRU 1
148 #define LCPOPT_ACCM 2
149 #define LCPOPT_AP 3
150 #define LCPOPT_QP 4
151 #define LCPOPT_MN 5
152 #define LCPOPT_DEP6 6
153 #define LCPOPT_PFC 7
154 #define LCPOPT_ACFC 8
155 #define LCPOPT_FCSALT 9
156 #define LCPOPT_SDP 10
157 #define LCPOPT_NUMMODE 11
158 #define LCPOPT_DEP12 12
159 #define LCPOPT_CBACK 13
160 #define LCPOPT_DEP14 14
161 #define LCPOPT_DEP15 15
162 #define LCPOPT_DEP16 16
163 #define LCPOPT_MLMRRU 17
164 #define LCPOPT_MLSSNHF 18
165 #define LCPOPT_MLED 19
166 #define LCPOPT_PROP 20
167 #define LCPOPT_DCEID 21
168 #define LCPOPT_MPP 22
169 #define LCPOPT_LD 23
170 #define LCPOPT_LCPAOPT 24
171 #define LCPOPT_COBS 25
172 #define LCPOPT_PE 26
173 #define LCPOPT_MLHF 27
174 #define LCPOPT_I18N 28
175 #define LCPOPT_SDLOS 29
176 #define LCPOPT_PPPMUX 30
177
178 #define LCPOPT_MIN LCPOPT_VEXT
179 #define LCPOPT_MAX LCPOPT_PPPMUX
180
181 static const char *lcpconfopts[] = {
182 "Vend-Ext", /* (0) */
183 "MRU", /* (1) */
184 "ACCM", /* (2) */
185 "Auth-Prot", /* (3) */
186 "Qual-Prot", /* (4) */
187 "Magic-Num", /* (5) */
188 "deprecated(6)", /* used to be a Quality Protocol */
189 "PFC", /* (7) */
190 "ACFC", /* (8) */
191 "FCS-Alt", /* (9) */
192 "SDP", /* (10) */
193 "Num-Mode", /* (11) */
194 "deprecated(12)", /* used to be a Multi-Link-Procedure*/
195 "Call-Back", /* (13) */
196 "deprecated(14)", /* used to be a Connect-Time */
197 "deprecated(15)", /* used to be a Compund-Frames */
198 "deprecated(16)", /* used to be a Nominal-Data-Encap */
199 "MRRU", /* (17) */
200 "SSNHF", /* (18) */
201 "End-Disc", /* (19) */
202 "Proprietary", /* (20) */
203 "DCE-Id", /* (21) */
204 "MP+", /* (22) */
205 "Link-Disc", /* (23) */
206 "LCP-Auth-Opt", /* (24) */
207 "COBS", /* (25) */
208 "Prefix-elision", /* (26) */
209 "Multilink-header-Form",/* (27) */
210 "I18N", /* (28) */
211 "SDL-over-SONET/SDH", /* (29) */
212 "PPP-Muxing", /* (30) */
213 };
214
215 /* IPV6CP - to be supported */
216 /* ECP - to be supported */
217
218 /* CCP Config Options */
219
220 #define CCPOPT_OUI 0 /* RFC1962 */
221 #define CCPOPT_PRED1 1 /* RFC1962 */
222 #define CCPOPT_PRED2 2 /* RFC1962 */
223 #define CCPOPT_PJUMP 3 /* RFC1962 */
224 /* 4-15 unassigned */
225 #define CCPOPT_HPPPC 16 /* RFC1962 */
226 #define CCPOPT_STACLZS 17 /* RFC1974 */
227 #define CCPOPT_MPPC 18 /* RFC2118 */
228 #define CCPOPT_GFZA 19 /* RFC1962 */
229 #define CCPOPT_V42BIS 20 /* RFC1962 */
230 #define CCPOPT_BSDCOMP 21 /* RFC1977 */
231 /* 22 unassigned */
232 #define CCPOPT_LZSDCP 23 /* RFC1967 */
233 #define CCPOPT_MVRCA 24 /* RFC1975 */
234 #define CCPOPT_DEC 25 /* RFC1976 */
235 #define CCPOPT_DEFLATE 26 /* RFC1979 */
236 /* 27-254 unassigned */
237 #define CCPOPT_RESV 255 /* RFC1962 */
238
239 #define CCPOPT_MIN CCPOPT_OUI
240 #define CCPOPT_MAX CCPOPT_DEFLATE /* XXX: should be CCPOPT_RESV but... */
241
242 static const char *ccpconfopts[] = {
243 "OUI", /* (0) */
244 "Pred-1", /* (1) */
245 "Pred-2", /* (2) */
246 "Puddle", /* (3) */
247 "unassigned(4)", /* (4) */
248 "unassigned(5)", /* (5) */
249 "unassigned(6)", /* (6) */
250 "unassigned(7)", /* (7) */
251 "unassigned(8)", /* (8) */
252 "unassigned(9)", /* (9) */
253 "unassigned(10)", /* (10) */
254 "unassigned(11)", /* (11) */
255 "unassigned(12)", /* (12) */
256 "unassigned(13)", /* (13) */
257 "unassigned(14)", /* (14) */
258 "unassigned(15)", /* (15) */
259 "HP-PPC", /* (16) */
260 "Stac-LZS", /* (17) */
261 "MPPC", /* (18) */
262 "Gand-FZA", /* (19) */
263 "V.42bis", /* (20) */
264 "BSD-Comp", /* (21) */
265 "unassigned(22)", /* (22) */
266 "LZS-DCP", /* (23) */
267 "MVRCA", /* (24) */
268 "DEC", /* (25) */
269 "Deflate", /* (26) */
270 };
271
272 /* BACP Config Options */
273
274 #define BACPOPT_FPEER 1 /* RFC2125 */
275
276 /* SDCP - to be supported */
277
278 /* IPCP Config Options */
279
280 #define IPCPOPT_2ADDR 1 /* RFC1172, RFC1332 (deprecated) */
281 #define IPCPOPT_IPCOMP 2 /* RFC1332 */
282 #define IPCPOPT_ADDR 3 /* RFC1332 */
283 #define IPCPOPT_MOBILE4 4 /* RFC2290 */
284
285 #define IPCPOPT_PRIDNS 129 /* RFC1877 */
286 #define IPCPOPT_PRINBNS 130 /* RFC1877 */
287 #define IPCPOPT_SECDNS 131 /* RFC1877 */
288 #define IPCPOPT_SECNBNS 132 /* RFC1877 */
289
290 /* ATCP - to be supported */
291 /* OSINLCP - to be supported */
292 /* BVCP - to be supported */
293 /* BCP - to be supported */
294 /* IPXCP - to be supported */
295 /* MPLSCP - to be supported */
296
297 /* Auth Algorithms */
298
299 /* 0-4 Reserved (RFC1994) */
300 #define AUTHALG_CHAPMD5 5 /* RFC1994 */
301 #define AUTHALG_MSCHAP1 128 /* RFC2433 */
302 #define AUTHALG_MSCHAP2 129 /* RFC2795 */
303
304 /* FCS Alternatives - to be supported */
305
306 /* Multilink Endpoint Discriminator (RFC1717) */
307 #define MEDCLASS_NULL 0 /* Null Class */
308 #define MEDCLASS_LOCAL 1 /* Locally Assigned */
309 #define MEDCLASS_IPV4 2 /* Internet Protocol (IPv4) */
310 #define MEDCLASS_MAC 3 /* IEEE 802.1 global MAC address */
311 #define MEDCLASS_MNB 4 /* PPP Magic Number Block */
312 #define MEDCLASS_PSNDN 5 /* Public Switched Network Director Number */
313
314 /* PPP LCP Callback */
315 #define CALLBACK_AUTH 0 /* Location determined by user auth */
316 #define CALLBACK_DSTR 1 /* Dialing string */
317 #define CALLBACK_LID 2 /* Location identifier */
318 #define CALLBACK_E164 3 /* E.164 number */
319 #define CALLBACK_X500 4 /* X.500 distinguished name */
320 #define CALLBACK_CBCP 6 /* Location is determined during CBCP nego */
321
322 /* CHAP */
323
324 #define CHAP_CHAL 1
325 #define CHAP_RESP 2
326 #define CHAP_SUCC 3
327 #define CHAP_FAIL 4
328
329 #define CHAP_CODEMIN CHAP_CHAL
330 #define CHAP_CODEMAX CHAP_FAIL
331
332 static const char *chapcode[] = {
333 "Chal", /* (1) */
334 "Resp", /* (2) */
335 "Succ", /* (3) */
336 "Fail", /* (4) */
337 };
338
339 /* PAP */
340
341 #define PAP_AREQ 1
342 #define PAP_AACK 2
343 #define PAP_ANAK 3
344
345 #define PAP_CODEMIN PAP_AREQ
346 #define PAP_CODEMAX PAP_ANAK
347
348 static const char *papcode[] = {
349 "Auth-Req", /* (1) */
350 "Auth-Ack", /* (2) */
351 "Auth-Nak", /* (3) */
352 };
353
354 /* BAP */
355 #define BAP_CALLREQ 1
356 #define BAP_CALLRES 2
357 #define BAP_CBREQ 3
358 #define BAP_CBRES 4
359 #define BAP_LDQREQ 5
360 #define BAP_LDQRES 6
361 #define BAP_CSIND 7
362 #define BAP_CSRES 8
363
364 static void handle_ctrl_proto (u_int proto,const u_char *p, int length);
365 static void handle_chap (const u_char *p, int length);
366 static void handle_pap (const u_char *p, int length);
367 static void handle_bap (const u_char *p, int length);
368 static int print_lcp_config_options (const u_char *p, int);
369 static int print_ipcp_config_options (const u_char *p, int);
370 static int print_ccp_config_options (const u_char *p, int);
371 static int print_bacp_config_options (const u_char *p, int);
372 static void handle_ppp (u_int proto, const u_char *p, int length);
373
374 /* generic Control Protocol (e.g. LCP, IPCP, CCP, etc.) handler */
375 static void
376 handle_ctrl_proto(u_int proto, const u_char *pptr, int length)
377 {
378 const char *typestr;
379 u_int code, len;
380 int (*pfunc)(const u_char *, int);
381 int x, j;
382 const u_char *tptr;
383
384 tptr=pptr;
385
386 typestr = tok2str(ppptype2str, "unknown", proto);
387 printf("%s, ",typestr);
388
389 if (length < 4) /* FIXME weak boundary checking */
390 goto trunc;
391 TCHECK2(*tptr, 2);
392
393 code = *tptr++;
394
395 printf("%s (0x%02x), id %u",
396 tok2str(cpcodes, "Unknown Opcode",code),
397 code,
398 *tptr++); /* ID */
399
400 TCHECK2(*tptr, 2);
401 len = EXTRACT_16BITS(tptr);
402 tptr += 2;
403
404 if (length <= 4)
405 return; /* there may be a NULL confreq etc. */
406
407 switch (code) {
408 case CPCODES_VEXT:
409 if (length < 11)
410 break;
411 TCHECK2(*tptr, 4);
412 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
413 tptr += 4;
414 TCHECK2(*tptr, 3);
415 printf(" Vendor: %s (%u)",
416 tok2str(oui_values,"Unknown",EXTRACT_24BITS(tptr)),
417 EXTRACT_24BITS(tptr));
418 /* XXX: need to decode Kind and Value(s)? */
419 break;
420 case CPCODES_CONF_REQ:
421 case CPCODES_CONF_ACK:
422 case CPCODES_CONF_NAK:
423 case CPCODES_CONF_REJ:
424 x = len - 4; /* Code(1), Identifier(1) and Length(2) */
425 do {
426 switch (proto) {
427 case PPP_LCP:
428 pfunc = print_lcp_config_options;
429 break;
430 case PPP_IPCP:
431 pfunc = print_ipcp_config_options;
432 break;
433 case PPP_CCP:
434 pfunc = print_ccp_config_options;
435 break;
436 case PPP_BACP:
437 pfunc = print_bacp_config_options;
438 break;
439 default:
440 /*
441 * This should never happen, but we set
442 * "pfunc" to squelch uninitialized
443 * variable warnings from compilers.
444 */
445 pfunc = NULL;
446 break;
447 }
448 if ((j = (*pfunc)(tptr, len)) == 0)
449 break;
450 x -= j;
451 tptr += j;
452 } while (x > 0);
453 break;
454
455 case CPCODES_TERM_REQ:
456 case CPCODES_TERM_ACK:
457 /* XXX: need to decode Data? */
458 break;
459 case CPCODES_CODE_REJ:
460 /* XXX: need to decode Rejected-Packet? */
461 break;
462 case CPCODES_PROT_REJ:
463 if (length < 6)
464 break;
465 TCHECK2(*tptr, 2);
466 printf(", Rejected %s Protocol (0x%04x)",
467 tok2str(ppptype2str,"unknown", EXTRACT_16BITS(tptr)),
468 EXTRACT_16BITS(tptr));
469 /* XXX: need to decode Rejected-Information? */
470 break;
471 case CPCODES_ECHO_REQ:
472 case CPCODES_ECHO_RPL:
473 case CPCODES_DISC_REQ:
474 case CPCODES_ID:
475 if (length < 8)
476 break;
477 TCHECK2(*tptr, 4);
478 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
479 /* XXX: need to decode Data? */
480 break;
481 case CPCODES_TIME_REM:
482 if (length < 12)
483 break;
484 TCHECK2(*tptr, 4);
485 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
486 TCHECK2(*(tptr + 4), 4);
487 printf(", Seconds-Remaining %us", EXTRACT_32BITS(tptr + 4));
488 /* XXX: need to decode Message? */
489 break;
490 default:
491 /* XXX this is dirty but we do not get the
492 * original pointer passed to the begin
493 * the PPP packet */
494 if (vflag <= 1)
495 print_unknown_data(pptr-2,"\n\t",length+2);
496 break;
497 }
498 printf(", length %u", length);
499
500 if (vflag >1)
501 print_unknown_data(pptr-2,"\n\t",length+2);
502 return;
503
504 trunc:
505 printf("[|%s]", typestr);
506 }
507
508 /* LCP config options */
509 static int
510 print_lcp_config_options(const u_char *p, int length)
511 {
512 int len, opt;
513
514 if (length < 2)
515 return 0;
516 TCHECK2(*p, 2);
517 len = p[1];
518 opt = p[0];
519 if (length < len)
520 return 0;
521 if ((opt >= LCPOPT_MIN) && (opt <= LCPOPT_MAX))
522 printf(", %s (%u)", lcpconfopts[opt],opt);
523 else {
524 printf(", unknown LCP option 0x%02x", opt);
525 return len;
526 }
527
528 switch (opt) {
529 case LCPOPT_VEXT:
530 if (len >= 6) {
531 TCHECK2(*(p + 2), 3);
532 printf(" Vendor: %s (%u)",
533 tok2str(oui_values,"Unknown",EXTRACT_24BITS(p+2)),
534 EXTRACT_24BITS(p+2));
535 #if 0
536 TCHECK(p[5]);
537 printf(", kind: 0x%02x", p[5]);
538 printf(", Value: 0x")
539 for (i = 0; i < len - 6; i++) {
540 TCHECK(p[6 + i]);
541 printf("%02x", p[6 + i]);
542 }
543 #endif
544 }
545 break;
546 case LCPOPT_MRU:
547 if (len == 4) {
548 TCHECK2(*(p + 2), 2);
549 printf(" %u", EXTRACT_16BITS(p + 2));
550 }
551 break;
552 case LCPOPT_ACCM:
553 if (len == 6) {
554 TCHECK2(*(p + 2), 4);
555 printf(" 0x%08x", EXTRACT_32BITS(p + 2));
556 }
557 break;
558 case LCPOPT_AP:
559 if (len >= 4) {
560 TCHECK2(*(p + 2), 2);
561 switch (EXTRACT_16BITS(p+2)) {
562 case PPP_PAP:
563 printf(" PAP");
564 break;
565 case PPP_CHAP:
566 printf(" CHAP");
567 TCHECK(p[4]);
568 switch (p[4]) {
569 default:
570 printf(", unknown-algorithm-%u", p[4]);
571 break;
572 case AUTHALG_CHAPMD5:
573 printf(", MD5");
574 break;
575 case AUTHALG_MSCHAP1:
576 printf(", MSCHAPv1");
577 break;
578 case AUTHALG_MSCHAP2:
579 printf(", MSCHAPv2");
580 break;
581 }
582 break;
583 case PPP_EAP:
584 printf(" EAP");
585 break;
586 case PPP_SPAP:
587 printf(" SPAP");
588 break;
589 case PPP_SPAP_OLD:
590 printf(" Old-SPAP");
591 break;
592 default:
593 printf("unknown");
594 }
595 }
596 break;
597 case LCPOPT_QP:
598 if (len >= 4) {
599 TCHECK2(*(p + 2), 2);
600 if (EXTRACT_16BITS(p+2) == PPP_LQM)
601 printf(" LQR");
602 else
603 printf(" unknown");
604 }
605 break;
606 case LCPOPT_MN:
607 if (len == 6) {
608 TCHECK2(*(p + 2), 4);
609 printf(" 0x%08x", EXTRACT_32BITS(p + 2));
610 }
611 break;
612 case LCPOPT_PFC:
613 break;
614 case LCPOPT_ACFC:
615 break;
616 case LCPOPT_LD:
617 if (len == 4) {
618 TCHECK2(*(p + 2), 2);
619 printf(" 0x%04x", EXTRACT_16BITS(p + 2));
620 }
621 break;
622 case LCPOPT_CBACK:
623 if (len < 3)
624 break;
625 TCHECK(p[2]);
626 switch (p[2]) { /* Operation */
627 case CALLBACK_AUTH:
628 printf(" UserAuth");
629 break;
630 case CALLBACK_DSTR:
631 printf(" DialString");
632 break;
633 case CALLBACK_LID:
634 printf(" LocalID");
635 break;
636 case CALLBACK_E164:
637 printf(" E.164");
638 break;
639 case CALLBACK_X500:
640 printf(" X.500");
641 break;
642 case CALLBACK_CBCP:
643 printf(" CBCP");
644 break;
645 default:
646 printf(" unknown-operation=%u", p[2]);
647 break;
648 }
649 break;
650 case LCPOPT_MLMRRU:
651 if (len == 4) {
652 TCHECK2(*(p + 2), 2);
653 printf(" %u", EXTRACT_16BITS(p + 2));
654 }
655 break;
656 case LCPOPT_MLED:
657 if (len < 3)
658 break;
659 TCHECK(p[2]);
660 switch (p[2]) { /* class */
661 case MEDCLASS_NULL:
662 printf(" Null");
663 break;
664 case MEDCLASS_LOCAL:
665 printf(" Local"); /* XXX */
666 break;
667 case MEDCLASS_IPV4:
668 if (len != 7)
669 break;
670 TCHECK2(*(p + 3), 4);
671 printf(" IPv4 %s", ipaddr_string(p + 3));
672 break;
673 case MEDCLASS_MAC:
674 if (len != 9)
675 break;
676 TCHECK(p[8]);
677 printf(" MAC %02x:%02x:%02x:%02x:%02x:%02x",
678 p[3], p[4], p[5], p[6], p[7], p[8]);
679 break;
680 case MEDCLASS_MNB:
681 printf(" Magic-Num-Block"); /* XXX */
682 break;
683 case MEDCLASS_PSNDN:
684 printf(" PSNDN"); /* XXX */
685 break;
686 }
687 break;
688
689 /* XXX: to be supported */
690 #if 0
691 case LCPOPT_DEP6:
692 case LCPOPT_FCSALT:
693 case LCPOPT_SDP:
694 case LCPOPT_NUMMODE:
695 case LCPOPT_DEP12:
696 case LCPOPT_DEP14:
697 case LCPOPT_DEP15:
698 case LCPOPT_DEP16:
699 case LCPOPT_MLSSNHF:
700 case LCPOPT_PROP:
701 case LCPOPT_DCEID:
702 case LCPOPT_MPP:
703 case LCPOPT_LCPAOPT:
704 case LCPOPT_COBS:
705 case LCPOPT_PE:
706 case LCPOPT_MLHF:
707 case LCPOPT_I18N:
708 case LCPOPT_SDLOS:
709 case LCPOPT_PPPMUX:
710 break;
711 #endif
712 }
713 return len;
714
715 trunc:
716 printf("[|lcp]");
717 return 0;
718 }
719
720 /* CHAP */
721 static void
722 handle_chap(const u_char *p, int length)
723 {
724 u_int code, len;
725 int val_size, name_size, msg_size;
726 const u_char *p0;
727 int i;
728
729 p0 = p;
730 if (length < 1) {
731 printf("[|chap]");
732 return;
733 } else if (length < 4) {
734 TCHECK(*p);
735 printf("[|chap 0x%02x]", *p);
736 return;
737 }
738
739 TCHECK(*p);
740 code = *p;
741 if ((code >= CHAP_CODEMIN) && (code <= CHAP_CODEMAX))
742 printf("%s", chapcode[code - 1]);
743 else {
744 printf("0x%02x", code);
745 return;
746 }
747 p++;
748
749 TCHECK(*p);
750 printf("(%u)", *p); /* ID */
751 p++;
752
753 TCHECK2(*p, 2);
754 len = EXTRACT_16BITS(p);
755 p += 2;
756
757 /*
758 * Note that this is a generic CHAP decoding routine. Since we
759 * don't know which flavor of CHAP (i.e. CHAP-MD5, MS-CHAPv1,
760 * MS-CHAPv2) is used at this point, we can't decode packet
761 * specifically to each algorithms. Instead, we simply decode
762 * the GCD (Gratest Common Denominator) for all algorithms.
763 */
764 switch (code) {
765 case CHAP_CHAL:
766 case CHAP_RESP:
767 if (length - (p - p0) < 1)
768 return;
769 TCHECK(*p);
770 val_size = *p; /* value size */
771 p++;
772 if (length - (p - p0) < val_size)
773 return;
774 printf(", Value ");
775 for (i = 0; i < val_size; i++) {
776 TCHECK(*p);
777 printf("%02x", *p++);
778 }
779 name_size = len - (p - p0);
780 printf(", Name ");
781 for (i = 0; i < name_size; i++) {
782 TCHECK(*p);
783 safeputchar(*p++);
784 }
785 break;
786 case CHAP_SUCC:
787 case CHAP_FAIL:
788 msg_size = len - (p - p0);
789 printf(", Msg ");
790 for (i = 0; i< msg_size; i++) {
791 TCHECK(*p);
792 safeputchar(*p++);
793 }
794 break;
795 }
796 return;
797
798 trunc:
799 printf("[|chap]");
800 }
801
802 /* PAP (see RFC 1334) */
803 static void
804 handle_pap(const u_char *p, int length)
805 {
806 u_int code, len;
807 int peerid_len, passwd_len, msg_len;
808 const u_char *p0;
809 int i;
810
811 p0 = p;
812 if (length < 1) {
813 printf("[|pap]");
814 return;
815 } else if (length < 4) {
816 TCHECK(*p);
817 printf("[|pap 0x%02x]", *p);
818 return;
819 }
820
821 TCHECK(*p);
822 code = *p;
823 if ((code >= PAP_CODEMIN) && (code <= PAP_CODEMAX))
824 printf("%s", papcode[code - 1]);
825 else {
826 printf("0x%02x", code);
827 return;
828 }
829 p++;
830
831 TCHECK(*p);
832 printf("(%u)", *p); /* ID */
833 p++;
834
835 TCHECK2(*p, 2);
836 len = EXTRACT_16BITS(p);
837 p += 2;
838
839 switch (code) {
840 case PAP_AREQ:
841 if (length - (p - p0) < 1)
842 return;
843 TCHECK(*p);
844 peerid_len = *p; /* Peer-ID Length */
845 p++;
846 if (length - (p - p0) < peerid_len)
847 return;
848 printf(", Peer ");
849 for (i = 0; i < peerid_len; i++) {
850 TCHECK(*p);
851 safeputchar(*p++);
852 }
853
854 if (length - (p - p0) < 1)
855 return;
856 TCHECK(*p);
857 passwd_len = *p; /* Password Length */
858 p++;
859 if (length - (p - p0) < passwd_len)
860 return;
861 printf(", Name ");
862 for (i = 0; i < passwd_len; i++) {
863 TCHECK(*p);
864 safeputchar(*p++);
865 }
866 break;
867 case PAP_AACK:
868 case PAP_ANAK:
869 if (length - (p - p0) < 1)
870 return;
871 TCHECK(*p);
872 msg_len = *p; /* Msg-Length */
873 p++;
874 if (length - (p - p0) < msg_len)
875 return;
876 printf(", Msg ");
877 for (i = 0; i< msg_len; i++) {
878 TCHECK(*p);
879 safeputchar(*p++);
880 }
881 break;
882 }
883 return;
884
885 trunc:
886 printf("[|pap]");
887 }
888
889 /* BAP */
890 static void
891 handle_bap(const u_char *p _U_, int length _U_)
892 {
893 /* XXX: to be supported!! */
894 }
895
896
897 /* IPCP config options */
898 static int
899 print_ipcp_config_options(const u_char *p, int length)
900 {
901 int len, opt;
902
903 if (length < 2)
904 return 0;
905 TCHECK2(*p, 2);
906 len = p[1];
907 opt = p[0];
908 if (length < len)
909 return 0;
910 switch (opt) {
911 case IPCPOPT_2ADDR: /* deprecated */
912 if (len != 10)
913 goto invlen;
914 TCHECK2(*(p + 6), 4);
915 printf(", IP-Addrs src %s, dst %s",
916 ipaddr_string(p + 2),
917 ipaddr_string(p + 6));
918 break;
919 case IPCPOPT_IPCOMP:
920 if (len < 4)
921 goto invlen;
922 printf(", IP-Comp");
923 TCHECK2(*(p + 2), 2);
924 if (EXTRACT_16BITS(p + 2) == PPP_VJC) {
925 printf(" VJ-Comp");
926 /* XXX: VJ-Comp parameters should be decoded */
927 } else
928 printf(" unknown-comp-proto=%04x", EXTRACT_16BITS(p + 2));
929 break;
930 case IPCPOPT_ADDR:
931 if (len != 6)
932 goto invlen;
933 TCHECK2(*(p + 2), 4);
934 printf(", IP-Addr %s", ipaddr_string(p + 2));
935 break;
936 case IPCPOPT_MOBILE4:
937 if (len != 6)
938 goto invlen;
939 TCHECK2(*(p + 2), 4);
940 printf(", Home-Addr %s", ipaddr_string(p + 2));
941 break;
942 case IPCPOPT_PRIDNS:
943 if (len != 6)
944 goto invlen;
945 TCHECK2(*(p + 2), 4);
946 printf(", Pri-DNS %s", ipaddr_string(p + 2));
947 break;
948 case IPCPOPT_PRINBNS:
949 if (len != 6)
950 goto invlen;
951 TCHECK2(*(p + 2), 4);
952 printf(", Pri-NBNS %s", ipaddr_string(p + 2));
953 break;
954 case IPCPOPT_SECDNS:
955 if (len != 6)
956 goto invlen;
957 TCHECK2(*(p + 2), 4);
958 printf(", Sec-DNS %s", ipaddr_string(p + 2));
959 break;
960 case IPCPOPT_SECNBNS:
961 if (len != 6)
962 goto invlen;
963 TCHECK2(*(p + 2), 4);
964 printf(", Sec-NBNS %s", ipaddr_string(p + 2));
965 break;
966 default:
967 printf(", unknown-%d", opt);
968 break;
969 }
970 return len;
971
972 invlen:
973 printf(", invalid-length-%d", opt);
974 return 0;
975
976 trunc:
977 printf("[|ipcp]");
978 return 0;
979 }
980
981 /* CCP config options */
982 static int
983 print_ccp_config_options(const u_char *p, int length)
984 {
985 int len, opt;
986
987 if (length < 2)
988 return 0;
989 TCHECK2(*p, 2);
990 len = p[1];
991 opt = p[0];
992 if (length < len)
993 return 0;
994 if ((opt >= CCPOPT_MIN) && (opt <= CCPOPT_MAX))
995 printf(", %s", ccpconfopts[opt]);
996 #if 0 /* XXX */
997 switch (opt) {
998 case CCPOPT_OUI:
999 case CCPOPT_PRED1:
1000 case CCPOPT_PRED2:
1001 case CCPOPT_PJUMP:
1002 case CCPOPT_HPPPC:
1003 case CCPOPT_STACLZS:
1004 case CCPOPT_MPPC:
1005 case CCPOPT_GFZA:
1006 case CCPOPT_V42BIS:
1007 case CCPOPT_BSDCOMP:
1008 case CCPOPT_LZSDCP:
1009 case CCPOPT_MVRCA:
1010 case CCPOPT_DEC:
1011 case CCPOPT_DEFLATE:
1012 case CCPOPT_RESV:
1013 break;
1014
1015 default:
1016 printf(", unknown-%d", opt);
1017 break;
1018 }
1019 #endif
1020 return len;
1021
1022 trunc:
1023 printf("[|ccp]");
1024 return 0;
1025 }
1026
1027 /* BACP config options */
1028 static int
1029 print_bacp_config_options(const u_char *p, int length)
1030 {
1031 int len, opt;
1032
1033 if (length < 2)
1034 return 0;
1035 TCHECK2(*p, 2);
1036 len = p[1];
1037 opt = p[0];
1038 if (length < len)
1039 return 0;
1040 if (opt == BACPOPT_FPEER) {
1041 TCHECK2(*(p + 2), 4);
1042 printf(", Favored-Peer");
1043 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(p + 2));
1044 } else {
1045 printf(", unknown-option-%d", opt);
1046 }
1047 return len;
1048
1049 trunc:
1050 printf("[|bacp]");
1051 return 0;
1052 }
1053
1054
1055 /* PPP */
1056 static void
1057 handle_ppp(u_int proto, const u_char *p, int length)
1058 {
1059 switch (proto) {
1060 case PPP_LCP:
1061 case PPP_IPCP:
1062 case PPP_OSICP:
1063 case PPP_MPLSCP:
1064 case PPP_IPV6CP:
1065 case PPP_CCP:
1066 case PPP_BACP:
1067 handle_ctrl_proto(proto, p, length);
1068 break;
1069 case PPP_CHAP:
1070 handle_chap(p, length);
1071 break;
1072 case PPP_PAP:
1073 handle_pap(p, length);
1074 break;
1075 case PPP_BAP: /* XXX: not yet completed */
1076 handle_bap(p, length);
1077 break;
1078 case ETHERTYPE_IP: /*XXX*/
1079 case PPP_IP:
1080 ip_print(p, length);
1081 break;
1082 #ifdef INET6
1083 case ETHERTYPE_IPV6: /*XXX*/
1084 case PPP_IPV6:
1085 ip6_print(p, length);
1086 break;
1087 #endif
1088 case ETHERTYPE_IPX: /*XXX*/
1089 case PPP_IPX:
1090 ipx_print(p, length);
1091 break;
1092 case PPP_OSI:
1093 isoclns_print(p, length, length);
1094 break;
1095 case PPP_MPLS_UCAST:
1096 case PPP_MPLS_MCAST:
1097 mpls_print(p, length);
1098 break;
1099 default:
1100 printf("unknown PPP protocol (0x%04x)", proto);
1101 print_unknown_data(p,"\n\t",length);
1102 break;
1103 }
1104 }
1105
1106 /* Standard PPP printer */
1107 u_int
1108 ppp_print(register const u_char *p, u_int length)
1109 {
1110 u_int proto;
1111 u_int olen = length; /* _o_riginal length */
1112 u_int hdr_len = 0;
1113
1114 /*
1115 * Here, we assume that p points to the Address and Control
1116 * field (if they present).
1117 */
1118 if (length < 2)
1119 goto trunc;
1120 TCHECK2(*p, 2);
1121 if (*p == PPP_ADDRESS && *(p + 1) == PPP_CONTROL) {
1122 p += 2; /* ACFC not used */
1123 length -= 2;
1124 hdr_len += 2;
1125 }
1126
1127 if (length < 2)
1128 goto trunc;
1129 TCHECK(*p);
1130 if (*p % 2) {
1131 proto = *p; /* PFC is used */
1132 p++;
1133 length--;
1134 hdr_len++;
1135 } else {
1136 TCHECK2(*p, 2);
1137 proto = EXTRACT_16BITS(p);
1138 p += 2;
1139 length -= 2;
1140 hdr_len += 2;
1141 }
1142
1143 if (eflag)
1144 printf("%s (0x%04x), length %u: ",
1145 tok2str(ppptype2str, "unknown", proto),
1146 proto,
1147 olen);
1148
1149 handle_ppp(proto, p, length);
1150 return (hdr_len);
1151 trunc:
1152 printf("[|ppp]");
1153 return (0);
1154 }
1155
1156
1157 /* PPP I/F printer */
1158 u_int
1159 ppp_if_print(const struct pcap_pkthdr *h, register const u_char *p)
1160 {
1161 register u_int length = h->len;
1162 register u_int caplen = h->caplen;
1163
1164 if (caplen < PPP_HDRLEN) {
1165 printf("[|ppp]");
1166 return (caplen);
1167 }
1168
1169 #if 0
1170 /*
1171 * XXX: seems to assume that there are 2 octets prepended to an
1172 * actual PPP frame. The 1st octet looks like Input/Output flag
1173 * while 2nd octet is unknown, at least to me
1174 * (mshindo@mshindo.net).
1175 *
1176 * That was what the original tcpdump code did.
1177 *
1178 * FreeBSD's "if_ppp.c" *does* set the first octet to 1 for outbound
1179 * packets and 0 for inbound packets - but only if the
1180 * protocol field has the 0x8000 bit set (i.e., it's a network
1181 * control protocol); it does so before running the packet through
1182 * "bpf_filter" to see if it should be discarded, and to see
1183 * if we should update the time we sent the most recent packet...
1184 *
1185 * ...but it puts the original address field back after doing
1186 * so.
1187 *
1188 * NetBSD's "if_ppp.c" doesn't set the first octet in that fashion.
1189 *
1190 * I don't know if any PPP implementation handed up to a BPF
1191 * device packets with the first octet being 1 for outbound and
1192 * 0 for inbound packets, so I (guy@alum.mit.edu) don't know
1193 * whether that ever needs to be checked or not.
1194 *
1195 * Note that NetBSD has a DLT_PPP_SERIAL, which it uses for PPP,
1196 * and its tcpdump appears to assume that the frame always
1197 * begins with an address field and a control field, and that
1198 * the address field might be 0x0f or 0x8f, for Cisco
1199 * point-to-point with HDLC framing as per section 4.3.1 of RFC
1200 * 1547, as well as 0xff, for PPP in HDLC-like framing as per
1201 * RFC 1662.
1202 *
1203 * (Is the Cisco framing in question what DLT_C_HDLC, in
1204 * BSD/OS, is?)
1205 */
1206 if (eflag)
1207 printf("%c %4d %02x ", p[0] ? 'O' : 'I', length, p[1]);
1208 #endif
1209
1210 ppp_print(p, length);
1211
1212 return (0);
1213 }
1214
1215 /*
1216 * PPP I/F printer to use if we know that RFC 1662-style PPP in HDLC-like
1217 * framing, or Cisco PPP with HDLC framing as per section 4.3.1 of RFC 1547,
1218 * is being used (i.e., we don't check for PPP_ADDRESS and PPP_CONTROL,
1219 * discard them *if* those are the first two octets, and parse the remaining
1220 * packet as a PPP packet, as "ppp_print()" does).
1221 *
1222 * This handles, for example, DLT_PPP_SERIAL in NetBSD.
1223 */
1224 u_int
1225 ppp_hdlc_if_print(const struct pcap_pkthdr *h, register const u_char *p)
1226 {
1227 register u_int length = h->len;
1228 register u_int caplen = h->caplen;
1229 u_int proto;
1230 u_int hdrlen = 0;
1231
1232 if (caplen < 2) {
1233 printf("[|ppp]");
1234 return (caplen);
1235 }
1236
1237 switch (p[0]) {
1238
1239 case PPP_ADDRESS:
1240 if (caplen < 4) {
1241 printf("[|ppp]");
1242 return (caplen);
1243 }
1244
1245 if (eflag)
1246 printf("%02x %02x %d ", p[0], p[1], length);
1247 p += 2;
1248 length -= 2;
1249 hdrlen += 2;
1250
1251 proto = EXTRACT_16BITS(p);
1252 p += 2;
1253 length -= 2;
1254 hdrlen += 2;
1255 printf("%s: ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", proto));
1256
1257 handle_ppp(proto, p, length);
1258 break;
1259
1260 case CHDLC_UNICAST:
1261 case CHDLC_BCAST:
1262 return (chdlc_if_print(h, p));
1263
1264 default:
1265 if (eflag)
1266 printf("%02x %02x %d ", p[0], p[1], length);
1267 p += 2;
1268 length -= 2;
1269 hdrlen += 2;
1270
1271 /*
1272 * XXX - NetBSD's "ppp_netbsd_serial_if_print()" treats
1273 * the next two octets as an Ethernet type; does that
1274 * ever happen?
1275 */
1276 printf("unknown addr %02x; ctrl %02x", p[0], p[1]);
1277 break;
1278 }
1279
1280 return (hdrlen);
1281 }
1282
1283 #define PPP_BSDI_HDRLEN 24
1284
1285 /* BSD/OS specific PPP printer */
1286 u_int
1287 ppp_bsdos_if_print(const struct pcap_pkthdr *h _U_, register const u_char *p _U_)
1288 {
1289 register int hdrlength;
1290 #ifdef __bsdi__
1291 register u_int length = h->len;
1292 register u_int caplen = h->caplen;
1293 u_int16_t ptype;
1294 const u_char *q;
1295 int i;
1296
1297 if (caplen < PPP_BSDI_HDRLEN) {
1298 printf("[|ppp]");
1299 return (caplen)
1300 }
1301
1302 hdrlength = 0;
1303
1304 #if 0
1305 if (p[0] == PPP_ADDRESS && p[1] == PPP_CONTROL) {
1306 if (eflag)
1307 printf("%02x %02x ", p[0], p[1]);
1308 p += 2;
1309 hdrlength = 2;
1310 }
1311
1312 if (eflag)
1313 printf("%d ", length);
1314 /* Retrieve the protocol type */
1315 if (*p & 01) {
1316 /* Compressed protocol field */
1317 ptype = *p;
1318 if (eflag)
1319 printf("%02x ", ptype);
1320 p++;
1321 hdrlength += 1;
1322 } else {
1323 /* Un-compressed protocol field */
1324 ptype = ntohs(*(u_int16_t *)p);
1325 if (eflag)
1326 printf("%04x ", ptype);
1327 p += 2;
1328 hdrlength += 2;
1329 }
1330 #else
1331 ptype = 0; /*XXX*/
1332 if (eflag)
1333 printf("%c ", p[SLC_DIR] ? 'O' : 'I');
1334 if (p[SLC_LLHL]) {
1335 /* link level header */
1336 struct ppp_header *ph;
1337
1338 q = p + SLC_BPFHDRLEN;
1339 ph = (struct ppp_header *)q;
1340 if (ph->phdr_addr == PPP_ADDRESS
1341 && ph->phdr_ctl == PPP_CONTROL) {
1342 if (eflag)
1343 printf("%02x %02x ", q[0], q[1]);
1344 ptype = ntohs(ph->phdr_type);
1345 if (eflag && (ptype == PPP_VJC || ptype == PPP_VJNC)) {
1346 printf("%s ", tok2str(ppptype2str,
1347 "proto-#%d", ptype));
1348 }
1349 } else {
1350 if (eflag) {
1351 printf("LLH=[");
1352 for (i = 0; i < p[SLC_LLHL]; i++)
1353 printf("%02x", q[i]);
1354 printf("] ");
1355 }
1356 }
1357 }
1358 if (eflag)
1359 printf("%d ", length);
1360 if (p[SLC_CHL]) {
1361 q = p + SLC_BPFHDRLEN + p[SLC_LLHL];
1362
1363 switch (ptype) {
1364 case PPP_VJC:
1365 ptype = vjc_print(q, ptype);
1366 hdrlength = PPP_BSDI_HDRLEN;
1367 p += hdrlength;
1368 switch (ptype) {
1369 case PPP_IP:
1370 ip_print(p, length);
1371 break;
1372 #ifdef INET6
1373 case PPP_IPV6:
1374 ip6_print(p, length);
1375 break;
1376 #endif
1377 case PPP_MPLS_UCAST:
1378 case PPP_MPLS_MCAST:
1379 mpls_print(p, length);
1380 break;
1381 }
1382 goto printx;
1383 case PPP_VJNC:
1384 ptype = vjc_print(q, ptype);
1385 hdrlength = PPP_BSDI_HDRLEN;
1386 p += hdrlength;
1387 switch (ptype) {
1388 case PPP_IP:
1389 ip_print(p, length);
1390 break;
1391 #ifdef INET6
1392 case PPP_IPV6:
1393 ip6_print(p, length);
1394 break;
1395 #endif
1396 case PPP_MPLS_UCAST:
1397 case PPP_MPLS_MCAST:
1398 mpls_print(p, length);
1399 break;
1400 }
1401 goto printx;
1402 default:
1403 if (eflag) {
1404 printf("CH=[");
1405 for (i = 0; i < p[SLC_LLHL]; i++)
1406 printf("%02x", q[i]);
1407 printf("] ");
1408 }
1409 break;
1410 }
1411 }
1412
1413 hdrlength = PPP_BSDI_HDRLEN;
1414 #endif
1415
1416 length -= hdrlength;
1417 p += hdrlength;
1418
1419 switch (ptype) {
1420 case PPP_IP:
1421 ip_print(p, length);
1422 break;
1423 #ifdef INET6
1424 case PPP_IPV6:
1425 ip6_print(p, length);
1426 break;
1427 #endif
1428 case PPP_MPLS_UCAST:
1429 case PPP_MPLS_MCAST:
1430 mpls_print(p, length);
1431 break;
1432 default:
1433 printf("%s ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", ptype));
1434 }
1435
1436 printx:
1437 #else /* __bsdi */
1438 hdrlength = 0;
1439 #endif /* __bsdi__ */
1440 return (hdrlength);
1441 }
[mirror] the TCPdump network dissector