2 * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
3 * The Regents of the University of California. All rights reserved.
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
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.
21 * Extensively modified by Motonori Shindo (mshindo@mshindo.net) for more
22 * complete PPP support.
29 * o resolve XXX as much as possible
35 static const char rcsid[] =
36 "@(#) $Header: /tcpdump/master/tcpdump/print-ppp.c,v 1.58 2000/12/27 11:09:08 itojun Exp $ (LBL)";
43 #include <sys/param.h>
47 #include <net/slcompress.h>
48 #include <net/if_ppp.h>
51 #include <netinet/in.h>
58 #include "interface.h"
60 #include "addrtoname.h"
63 #include "ethertype.h"
66 * The following constatns are defined by IANA. Please refer to
67 * http://www.isi.edu/in-notes/iana/assignments/ppp-numbers
68 * for the up-to-date information.
71 /* Control Protocols (LCP/IPCP/CCP etc.) Codes */
73 #define CPCODES_VEXT 0 /* Vendor-Specific (RFC2153) */
74 #define CPCODES_CONF_REQ 1 /* Configure-Request */
75 #define CPCODES_CONF_ACK 2 /* Configure-Ack */
76 #define CPCODES_CONF_NAK 3 /* Configure-Nak */
77 #define CPCODES_CONF_REJ 4 /* Configure-Reject */
78 #define CPCODES_TERM_REQ 5 /* Terminate-Request */
79 #define CPCODES_TERM_ACK 6 /* Terminate-Ack */
80 #define CPCODES_CODE_REJ 7 /* Code-Reject */
81 #define CPCODES_PROT_REJ 8 /* Protocol-Reject (LCP only) */
82 #define CPCODES_ECHO_REQ 9 /* Echo-Request (LCP only) */
83 #define CPCODES_ECHO_RPL 10 /* Echo-Reply (LCP only) */
84 #define CPCODES_DISC_REQ 11 /* Discard-Request (LCP only) */
85 #define CPCODES_ID 12 /* Identification (LCP only) */
86 #define CPCODES_TIME_REM 13 /* Time-Remaining (LCP only) */
87 #define CPCODES_RESET_REQ 14 /* Reset-Request (CCP only) */
88 #define CPCODES_RESET_REP 15 /* Reset-Reply (CCP only) */
90 #define CPCODES_MIN CPCODES_VEXT
91 #define CPCODES_MAX CPCODES_RESET_REP
93 static const char *cpcodes[] = {
95 * Control Protocol code values (RFC1661)
97 "Vend-Ext", /* (0) RFC2153 */
100 "Conf-Nak", /* (3) */
101 "Conf-Rej", /* (4) */
102 "Term-Req", /* (5) */
103 "Term-Ack", /* (6) */
104 "Code-Rej", /* (7) */
105 "Prot-Rej", /* (8) */
106 "Echo-Req", /* (9) */
107 "Echo-Rep", /* (10) */
108 "Disc-Req", /* (11) */
109 "Ident", /* (12) RFC1570 */
110 "Time-Rem", /* (13) RFC1570 */
111 "Reset-Req", /* (14) RFC1962 */
112 "Reset-Ack", /* (15) RFC1962 */
115 /* LCP Config Options */
117 #define LCPOPT_VEXT 0
119 #define LCPOPT_ACCM 2
123 #define LCPOPT_DEP6 6
125 #define LCPOPT_ACFC 8
126 #define LCPOPT_FCSALT 9
127 #define LCPOPT_SDP 10
128 #define LCPOPT_NUMMODE 11
129 #define LCPOPT_DEP12 12
130 #define LCPOPT_CBACK 13
131 #define LCPOPT_DEP14 14
132 #define LCPOPT_DEP15 15
133 #define LCPOPT_DEP16 16
134 #define LCPOPT_MLMRRU 17
135 #define LCPOPT_MLSSNHF 18
136 #define LCPOPT_MLED 19
137 #define LCPOPT_PROP 20
138 #define LCPOPT_DCEID 21
139 #define LCPOPT_MPP 22
141 #define LCPOPT_LCPAOPT 24
142 #define LCPOPT_COBS 25
144 #define LCPOPT_MLHF 27
145 #define LCPOPT_I18N 28
146 #define LCPOPT_SDLOS 29
147 #define LCPOPT_PPPMUX 30
149 #define LCPOPT_MIN LCPOPT_VEXT
150 #define LCPOPT_MAX LCPOPT_PPPMUX
152 static const char *lcpconfopts[] = {
153 "Vend-Ext", /* (0) */
156 "Auth-Prot", /* (3) */
157 "Qual-Prot", /* (4) */
158 "Magic-Num", /* (5) */
159 "deprecated(6)", /* used to be a Quality Protocol */
164 "Num-Mode", /* (11) */
165 "deprecated(12)", /* used to be a Multi-Link-Procedure*/
166 "Call-Back", /* (13) */
167 "deprecated(14)", /* used to be a Connect-Time */
168 "deprecated(15)", /* used to be a Compund-Frames */
169 "deprecated(16)", /* used to be a Nominal-Data-Encap */
172 "End-Disc", /* (19) */
173 "Proprietary", /* (20) */
176 "Link-Disc", /* (23) */
177 "LCP-Auth-Opt", /* (24) */
179 "Prefix-elision", /* (26) */
180 "Multilink-header-Form",/* (27) */
182 "SDL-over-SONET/SDH", /* (29) */
183 "PPP-Muxing", /* (30) */
186 /* IPV6CP - to be supported */
187 /* ECP - to be supported */
189 /* CCP Config Options */
191 #define CCPOPT_OUI 0 /* RFC1962 */
192 #define CCPOPT_PRED1 1 /* RFC1962 */
193 #define CCPOPT_PRED2 2 /* RFC1962 */
194 #define CCPOPT_PJUMP 3 /* RFC1962 */
195 /* 4-15 unassigned */
196 #define CCPOPT_HPPPC 16 /* RFC1962 */
197 #define CCPOPT_STACLZS 17 /* RFC1974 */
198 #define CCPOPT_MPPC 18 /* RFC2118 */
199 #define CCPOPT_GFZA 19 /* RFC1962 */
200 #define CCPOPT_V42BIS 20 /* RFC1962 */
201 #define CCPOPT_BSDCOMP 21 /* RFC1977 */
203 #define CCPOPT_LZSDCP 23 /* RFC1967 */
204 #define CCPOPT_MVRCA 24 /* RFC1975 */
205 #define CCPOPT_DEC 25 /* RFC1976 */
206 #define CCPOPT_DEFLATE 26 /* RFC1979 */
207 /* 27-254 unassigned */
208 #define CCPOPT_RESV 255 /* RFC1962 */
210 #define CCPOPT_MIN CCPOPT_OUI
211 #define CCPOPT_MAX CCPOPT_DEFLATE /* XXX: should be CCPOPT_RESV but... */
213 static const char *ccpconfopts[] = {
218 "unassigned(4)", /* (4) */
219 "unassigned(5)", /* (5) */
220 "unassigned(6)", /* (6) */
221 "unassigned(7)", /* (7) */
222 "unassigned(8)", /* (8) */
223 "unassigned(9)", /* (9) */
224 "unassigned(10)", /* (10) */
225 "unassigned(11)", /* (11) */
226 "unassigned(12)", /* (12) */
227 "unassigned(13)", /* (13) */
228 "unassigned(14)", /* (14) */
229 "unassigned(15)", /* (15) */
231 "Stac-LZS", /* (17) */
233 "Gand-FZA", /* (19) */
234 "V.42bis", /* (20) */
235 "BSD-Comp", /* (21) */
236 "unassigned(22)", /* (22) */
237 "LZS-DCP", /* (23) */
240 "Deflate", /* (26) */
243 /* BACP Config Options */
245 #define BACPOPT_FPEER 1 /* RFC2125 */
247 /* SDCP - to be supported */
249 /* IPCP Config Options */
251 #define IPCPOPT_2ADDR 1 /* RFC1172, RFC1332 (deprecated) */
252 #define IPCPOPT_IPCOMP 2 /* RFC1332 */
253 #define IPCPOPT_ADDR 3 /* RFC1332 */
254 #define IPCPOPT_MOBILE4 4 /* RFC2290 */
256 #define IPCPOPT_PRIDNS 129 /* RFC1877 */
257 #define IPCPOPT_PRINBNS 130 /* RFC1877 */
258 #define IPCPOPT_SECDNS 131 /* RFC1877 */
259 #define IPCPOPT_SECNBNS 132 /* RFC1877 */
261 /* ATCP - to be supported */
262 /* OSINLCP - to be supported */
263 /* BVCP - to be supported */
264 /* BCP - to be supported */
265 /* IPXCP - to be supported */
267 /* Auth Algorithms */
269 /* 0-4 Reserved (RFC1994) */
270 #define AUTHALG_CHAPMD5 5 /* RFC1994 */
271 #define AUTHALG_MSCHAP1 128 /* RFC2433 */
272 #define AUTHALG_MSCHAP2 129 /* RFC2795 */
274 /* FCS Alternatives - to be supported */
276 /* Multilink Endpoint Discriminator (RFC1717) */
277 #define MEDCLASS_NULL 0 /* Null Class */
278 #define MEDCLASS_LOCAL 1 /* Locally Assigned */
279 #define MEDCLASS_IPV4 2 /* Internet Protocol (IPv4) */
280 #define MEDCLASS_MAC 3 /* IEEE 802.1 global MAC address */
281 #define MEDCLASS_MNB 4 /* PPP Magic Number Block */
282 #define MEDCLASS_PSNDN 5 /* Public Switched Network Director Number */
284 /* PPP LCP Callback */
285 #define CALLBACK_AUTH 0 /* Location determined by user auth */
286 #define CALLBACK_DSTR 1 /* Dialing string */
287 #define CALLBACK_LID 2 /* Location identifier */
288 #define CALLBACK_E164 3 /* E.164 number */
289 #define CALLBACK_X500 4 /* X.500 distinguished name */
290 #define CALLBACK_CBCP 6 /* Location is determined during CBCP nego */
299 #define CHAP_CODEMIN CHAP_CHAL
300 #define CHAP_CODEMAX CHAP_FAIL
302 static const char *chapcode[] = {
315 #define PAP_CODEMIN PAP_AREQ
316 #define PAP_CODEMAX PAP_ANAK
318 static const char *papcode[] = {
319 "Auth-Req", /* (1) */
320 "Auth-Ack", /* (2) */
321 "Auth-Nak", /* (3) */
325 #define BAP_CALLREQ 1
326 #define BAP_CALLRES 2
334 static const char *ppp_protoname (u_int proto);
335 static void handle_ctrl_proto (u_int proto,const u_char *p, int length);
336 static void handle_chap (const u_char *p, int length);
337 static void handle_pap (const u_char *p, int length);
338 static void handle_bap (const u_char *p, int length);
339 static int print_lcp_config_options (const u_char *p, int);
340 static int print_ipcp_config_options (const u_char *p, int);
341 static int print_ccp_config_options (const u_char *p, int);
342 static int print_bacp_config_options (const u_char *p, int);
343 static void handle_ppp (u_int proto, const u_char *p, int length);
346 ppp_protoname(u_int proto)
351 case PPP_IP: return "IP";
352 case PPP_IPV6: return "IPv6";
354 case PPP_XNS: return "XNS";
356 case PPP_IPX: return "IPX";
357 case PPP_VJC: return "VJC";
358 case PPP_VJNC: return "VJNC";
360 case PPP_COMP: return "COMP";
362 case PPP_IPCP: return "IPCP";
363 case PPP_IPV6CP: return "IPv6CP";
364 case PPP_IPXCP: return "IPXCP";
365 case PPP_CCP: return "CCP";
366 case PPP_LCP: return "LCP";
367 case PPP_PAP: return "PAP";
369 case PPP_LQR: return "LQR";
371 case PPP_CHAP: return "CHAP";
372 case PPP_BACP: return "BACP";
373 case PPP_BAP: return "BAP";
375 snprintf(buf, sizeof(buf), "unknown-0x%04x", proto);
380 /* generic Control Protocol (e.g. LCP, IPCP, CCP, etc.) handler */
382 handle_ctrl_proto(u_int proto, const u_char *p, int length)
385 int (*pfunc)(const u_char *, int);
389 printf("[|%s]", ppp_protoname(proto));
391 } else if (length < 4) {
392 printf("[|%s 0x%02x]", ppp_protoname(proto), *p);
397 if ((code >= CPCODES_MIN) && (code <= CPCODES_MAX))
398 printf("%s", cpcodes[code]);
400 printf("0x%02x", code);
405 printf("(%u)", *p); /* ID */
408 len = EXTRACT_16BITS(p);
412 return; /* there may be a NULL confreq etc. */
418 printf(", Magic-Num=%08x", EXTRACT_32BITS(p));
420 printf(" OUI=%02x%02x%02x", p[0], p[1], p[2]);
421 /* XXX: need to decode Kind and Value(s)? */
423 case CPCODES_CONF_REQ:
424 case CPCODES_CONF_ACK:
425 case CPCODES_CONF_NAK:
426 case CPCODES_CONF_REJ:
427 x = len - 4; /* Code(1), Identifier(1) and Length(2) */
431 pfunc = print_lcp_config_options;
434 pfunc = print_ipcp_config_options;
437 pfunc = print_ccp_config_options;
440 pfunc = print_bacp_config_options;
444 * This should never happen, but we set
445 * "pfunc" to squelch uninitialized
446 * variable warnings from compilers.
451 if ((j = (*pfunc)(p, len)) == 0)
458 case CPCODES_TERM_REQ:
459 case CPCODES_TERM_ACK:
460 /* XXX: need to decode Data? */
462 case CPCODES_CODE_REJ:
463 /* XXX: need to decode Rejected-Packet? */
465 case CPCODES_PROT_REJ:
468 printf(", Rejected-Protocol=%04x", EXTRACT_16BITS(p));
469 /* XXX: need to decode Rejected-Information? */
471 case CPCODES_ECHO_REQ:
472 case CPCODES_ECHO_RPL:
473 case CPCODES_DISC_REQ:
477 printf(", Magic-Num=%08x", EXTRACT_32BITS(p));
478 /* XXX: need to decode Data? */
480 case CPCODES_TIME_REM:
483 printf(", Magic-Num=%08x", EXTRACT_32BITS(p));
484 printf(" Seconds-Remaining=%u", EXTRACT_32BITS(p + 4));
485 /* XXX: need to decode Message? */
488 printf(", unknown-Codes-0x%02x", code);
493 /* LCP config options */
495 print_lcp_config_options(const u_char *p, int length)
505 if ((opt >= LCPOPT_MIN) && (opt <= LCPOPT_MAX))
506 printf(", %s", lcpconfopts[opt]);
508 printf(", unknwhown-%d", opt);
515 printf(" OUI=%02x%02x%02x", p[2], p[3], p[4]);
517 printf(" kind=%02x", p[5]);
519 for (i = 0; i < len - 6; i++) {
520 printf("%02x", p[6 + i]);
527 printf("=%u", EXTRACT_16BITS(p + 2));
531 printf("=%08x", EXTRACT_32BITS(p + 2));
535 if (p[2] == 0xc0 && p[3] == 0x23)
537 else if (p[2] == 0xc2 && p[3] == 0x23) {
541 printf("unknown-algorithm-%u", p[4]);
543 case AUTHALG_CHAPMD5:
546 case AUTHALG_MSCHAP1:
549 case AUTHALG_MSCHAP2:
554 else if (p[2] == 0xc2 && p[3] == 0x27)
556 else if (p[2] == 0xc0 && p[3] == 0x27)
558 else if (p[2] == 0xc1 && p[3] == 0x23)
566 if (p[2] == 0xc0 && p[3] == 0x25)
574 printf("=%08x", EXTRACT_32BITS(p + 2));
582 printf("=%04x", EXTRACT_16BITS(p + 2));
587 switch (p[2]) { /* Operation */
592 printf(" DialString");
607 printf(" unknown-operation=%u", p[2]);
613 printf("=%u", EXTRACT_16BITS(p + 2));
618 switch (p[2]) { /* class */
623 printf(" Local"); /* XXX */
628 printf(" IPv4=%s", ipaddr_string(p + 3));
633 printf(" MAC=%02x:%02x:%02x:%02x:%02x:%02x",
634 p[3], p[4], p[5], p[6], p[7], p[8]);
637 printf(" Magic-Num-Block"); /* XXX */
640 printf(" PSNDN"); /* XXX */
645 /* XXX: to be supported */
674 handle_chap(const u_char *p, int length)
677 int val_size, name_size, msg_size;
685 } else if (length < 4) {
686 printf("[|chap 0x%02x]", *p);
691 if ((code >= CHAP_CODEMIN) && (code <= CHAP_CODEMAX))
692 printf("%s", chapcode[code - 1]);
694 printf("0x%02x", code);
699 printf("(%u)", *p); /* ID */
702 len = EXTRACT_16BITS(p);
706 * Note that this is a generic CHAP decoding routine. Since we
707 * don't know which flavor of CHAP (i.e. CHAP-MD5, MS-CHAPv1,
708 * MS-CHAPv2) is used at this point, we can't decode packet
709 * specifically to each algorithms. Instead, we simply decode
710 * the GCD (Gratest Common Denominator) for all algorithms.
715 if (length - (p - p0) < 1)
717 val_size = *p; /* value size */
719 if (length - (p - p0) < val_size)
722 for (i = 0; i < val_size; i++)
723 printf("%02x", *p++);
724 name_size = len - (p - p0);
726 for (i = 0; i < name_size; i++)
731 msg_size = len - (p - p0);
733 for (i = 0; i< msg_size; i++)
739 /* PAP (see RFC 1334) */
741 handle_pap(const u_char *p, int length)
744 int peerid_len, passwd_len, msg_len;
752 } else if (length < 4) {
753 printf("[|pap 0x%02x]", *p);
758 if ((code >= PAP_CODEMIN) && (code <= PAP_CODEMAX))
759 printf("%s", papcode[code - 1]);
761 printf("0x%02x", code);
766 printf("(%u)", *p); /* ID */
769 len = EXTRACT_16BITS(p);
774 if (length - (p - p0) < 1)
776 peerid_len = *p; /* Peer-ID Length */
778 if (length - (p - p0) < peerid_len)
781 for (i = 0; i < peerid_len; i++)
784 if (length - (p - p0) < 1)
786 passwd_len = *p; /* Password Length */
788 if (length - (p - p0) < passwd_len)
791 for (i = 0; i < passwd_len; i++)
796 if (length - (p - p0) < 1)
798 msg_len = *p; /* Msg-Length */
800 if (length - (p - p0) < msg_len)
803 for (i = 0; i< msg_len; i++)
812 handle_bap(const u_char *p, int length)
814 /* XXX: to be supported!! */
818 /* IPCP config options */
820 print_ipcp_config_options(const u_char *p, int length)
831 case IPCPOPT_2ADDR: /* deprecated */
834 printf(", IP-Addrs src=%s dst=%s",
835 ipaddr_string(p + 2),
836 ipaddr_string(p + 6));
842 if (EXTRACT_16BITS(p + 2) == PPP_VJC) {
844 /* XXX: VJ-Comp parameters should be decoded */
846 printf(" unknown-comp-proto=%04x", EXTRACT_16BITS(p + 2));
851 printf(", IP-Addr=%s", ipaddr_string(p + 2));
853 case IPCPOPT_MOBILE4:
856 printf(", Home-Addr=%s", ipaddr_string(p + 2));
861 printf(", Pri-DNS=%s", ipaddr_string(p + 2));
863 case IPCPOPT_PRINBNS:
866 printf(", Pri-NBNS=%s", ipaddr_string(p + 2));
871 printf(", Sec-DNS=%s", ipaddr_string(p + 2));
873 case IPCPOPT_SECNBNS:
876 printf(", Sec-NBNS=%s", ipaddr_string(p + 2));
879 printf(", unknown-%d", opt);
885 printf(", invalid-length-%d", opt);
889 /* CCP config options */
891 print_ccp_config_options(const u_char *p, int length)
901 if ((opt >= CCPOPT_MIN) && (opt <= CCPOPT_MAX))
902 printf(", %s", ccpconfopts[opt]);
923 printf(", unknown-%d", opt);
930 /* BACP config options */
932 print_bacp_config_options(const u_char *p, int length)
942 if (opt == BACPOPT_FPEER) {
943 printf(", Favored-Peer");
944 printf(" Magic-Num=%08x", EXTRACT_32BITS(p + 2));
946 printf(", unknown-option-%d", opt);
954 handle_ppp(u_int proto, const u_char *p, int length)
961 handle_ctrl_proto(proto, p, length);
964 handle_chap(p, length);
967 handle_pap(p, length);
969 case PPP_BAP: /* XXX: not yet completed */
970 handle_bap(p, length);
972 case ETHERTYPE_IP: /*XXX*/
977 case ETHERTYPE_IPV6: /*XXX*/
979 ip6_print(p, length);
982 case ETHERTYPE_IPX: /*XXX*/
984 ipx_print(p, length);
989 /* Standard PPP printer */
991 ppp_print(register const u_char *p, u_int length)
994 u_int full_length = length;
997 * Here, we assume that p points to the Address and Control
998 * field (if they present).
1002 if (*p == PPP_ADDRESS && *(p + 1) == PPP_CONTROL) {
1003 p += 2; /* ACFC not used */
1010 proto = *p; /* PFC is used */
1014 proto = EXTRACT_16BITS(p);
1019 printf("%s %d: ", ppp_protoname(proto), full_length);
1021 handle_ppp(proto, p, length);
1028 /* PPP I/F printer */
1030 ppp_if_print(u_char *user, const struct pcap_pkthdr *h,
1031 register const u_char *p)
1033 register u_int length = h->len;
1034 register u_int caplen = h->caplen;
1038 if (caplen < PPP_HDRLEN) {
1044 * Some printers want to get back at the link level addresses,
1045 * and/or check that they're not walking off the end of the packet.
1046 * Rather than pass them all the way down, we set these globals. */
1049 snapend = p + caplen;
1053 * XXX: seems to assume that there are 2 octets prepended to an
1054 * actual PPP frame. The 1st octet looks like Input/Output flag
1055 * while 2nd octet is unknown, at least to me
1056 * (mshindo@mshindo.net).
1058 * That was what the original tcpdump code did.
1060 * FreeBSD's "if_ppp.c" *does* set the first octet to 1 for outbound
1061 * packets and 0 for inbound packets - but only if the
1062 * protocol field has the 0x8000 bit set (i.e., it's a network
1063 * control protocol); it does so before running the packet through
1064 * "bpf_filter" to see if it should be discarded, and to see
1065 * if we should update the time we sent the most recent packet...
1067 * ...but it puts the original address field back after doing
1070 * NetBSD's "if_ppp.c" doesn't set the first octet in that fashion.
1072 * I don't know if any PPP implementation handed up to a BPF
1073 * device packets with the first octet being 1 for outbound and
1074 * 0 for inbound packets, so I (guy@alum.mit.edu) don't know
1075 * whether that ever needs to be checked or not.
1077 * Note that NetBSD has a DLT_PPP_SERIAL, which it uses for PPP,
1078 * and its tcpdump appears to assume that the frame always
1079 * begins with an address field and a control field, and that
1080 * the address field might be 0x0f or 0x8f, for Cisco
1081 * point-to-point with HDLC framing as per section 4.3.1 of RFC
1082 * 1547, as well as 0xff, for PPP in HDLC-like framing as per
1085 * (Is the Cisco framing in question what DLT_C_HDLC, in
1089 printf("%c %4d %02x ", p[0] ? 'O' : 'I', length, p[1]);
1092 ppp_print(p, length);
1095 default_print(p, caplen);
1101 * PPP I/F printer to use if we know that RFC 1662-style PPP in HDLC-like
1102 * framing, or Cisco PPP with HDLC framing as per section 4.3.1 of RFC 1547,
1103 * is being used (i.e., we don't check for PPP_ADDRESS and PPP_CONTROL,
1104 * discard them *if* those are the first two octets, and parse the remaining
1105 * packet as a PPP packet, as "ppp_print()" does).
1107 * This handles, for example, DLT_PPP_SERIAL in NetBSD.
1110 ppp_hdlc_if_print(u_char *user, const struct pcap_pkthdr *h,
1111 register const u_char *p)
1113 register u_int length = h->len;
1114 register u_int caplen = h->caplen;
1123 * Some printers want to get back at the link level addresses,
1124 * and/or check that they're not walking off the end of the packet.
1125 * Rather than pass them all the way down, we set these globals.
1128 snapend = p + caplen;
1140 printf("%02x %02x %d ", p[0], p[1], length);
1144 proto = EXTRACT_16BITS(p);
1147 printf("%s: ", ppp_protoname(proto));
1149 handle_ppp(proto, p, length);
1155 * Have the Cisco HDLC print routine do all the work.
1157 chdlc_if_print(user, h, p);
1163 printf("%02x %02x %d ", p[0], p[1], length);
1168 * XXX - NetBSD's "ppp_netbsd_serial_if_print()" treats
1169 * the next two octets as an Ethernet type; does that
1172 printf("unknown addr %02x; ctrl %02x", p[0], p[1]);
1177 default_print(p, caplen);
1184 struct tok ppptype2str[] = {
1188 { PPP_DECNET, "DECNET" },
1189 { PPP_APPLE, "APPLE" },
1192 { PPP_VJNC, "VJNC" },
1193 { PPP_BRPDU, "BRPDU" },
1194 { PPP_STII, "STII" },
1195 { PPP_VINES, "VINES" },
1197 { PPP_HELLO, "HELLO" },
1198 { PPP_LUXCOM, "LUXCOM" },
1200 { PPP_IPCP, "IPCP" },
1201 { PPP_OSICP, "OSICP" },
1202 { PPP_NSCP, "NSCP" },
1203 { PPP_DECNETCP, "DECNETCP" },
1204 { PPP_APPLECP, "APPLECP" },
1205 { PPP_IPXCP, "IPXCP" },
1206 { PPP_STIICP, "STIICP" },
1207 { PPP_VINESCP, "VINESCP" },
1212 { PPP_CHAP, "CHAP" },
1213 { PPP_BACP, "BACP" },
1219 #define PPP_BSDI_HDRLEN 24
1221 /* BSD/OS specific PPP printer */
1223 ppp_bsdos_if_print(u_char *user, const struct pcap_pkthdr *h,
1224 register const u_char *p)
1227 register u_int length = h->len;
1228 register u_int caplen = h->caplen;
1229 register int hdrlength;
1236 if (caplen < PPP_BSDI_HDRLEN) {
1242 * Some printers want to get back at the link level addresses,
1243 * and/or check that they're not walking off the end of the packet.
1244 * Rather than pass them all the way down, we set these globals.
1247 snapend = p + caplen;
1251 if (p[0] == PPP_ADDRESS && p[1] == PPP_CONTROL) {
1253 printf("%02x %02x ", p[0], p[1]);
1259 printf("%d ", length);
1260 /* Retrieve the protocol type */
1262 /* Compressed protocol field */
1265 printf("%02x ", ptype);
1269 /* Un-compressed protocol field */
1270 ptype = ntohs(*(u_int16_t *)p);
1272 printf("%04x ", ptype);
1279 printf("%c ", p[SLC_DIR] ? 'O' : 'I');
1281 /* link level header */
1282 struct ppp_header *ph;
1284 q = p + SLC_BPFHDRLEN;
1285 ph = (struct ppp_header *)q;
1286 if (ph->phdr_addr == PPP_ADDRESS
1287 && ph->phdr_ctl == PPP_CONTROL) {
1289 printf("%02x %02x ", q[0], q[1]);
1290 ptype = ntohs(ph->phdr_type);
1291 if (eflag && (ptype == PPP_VJC || ptype == PPP_VJNC)) {
1292 printf("%s ", tok2str(ppptype2str,
1293 "proto-#%d", ptype));
1298 for (i = 0; i < p[SLC_LLHL]; i++)
1299 printf("%02x", q[i]);
1305 printf("%d ", length);
1307 q = p + SLC_BPFHDRLEN + p[SLC_LLHL];
1311 ptype = vjc_print(q, length - (q - p), ptype);
1312 hdrlength = PPP_BSDI_HDRLEN;
1316 ip_print(p, length);
1320 ip6_print(p, length);
1326 ptype = vjc_print(q, length - (q - p), ptype);
1327 hdrlength = PPP_BSDI_HDRLEN;
1331 ip_print(p, length);
1335 ip6_print(p, length);
1343 for (i = 0; i < p[SLC_LLHL]; i++)
1344 printf("%02x", q[i]);
1351 hdrlength = PPP_BSDI_HDRLEN;
1354 length -= hdrlength;
1359 ip_print(p, length);
1363 ip6_print(p, length);
1367 printf("%s ", tok2str(ppptype2str, "proto-#%d", ptype));
1372 default_print((const u_char *)p, caplen - hdrlength);
1375 #endif /* __bsdi__ */