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[] _U_ =
36 "@(#) $Header: /tcpdump/master/tcpdump/print-ppp.c,v 1.89.2.3 2004/03/24 03:32:43 guy Exp $ (LBL)";
43 #include <tcpdump-stdinc.h>
46 #include <net/slcompress.h>
47 #include <net/if_ppp.h>
53 #include "interface.h"
55 #include "addrtoname.h"
58 #include "ethertype.h"
61 * The following constatns are defined by IANA. Please refer to
62 * http://www.isi.edu/in-notes/iana/assignments/ppp-numbers
63 * for the up-to-date information.
66 /* Protocol Codes defined in ppp.h */
68 struct tok ppptype2str[] = {
72 { PPP_DECNET, "DECNET" },
73 { PPP_APPLE, "APPLE" },
77 { PPP_BRPDU, "BRPDU" },
79 { PPP_VINES, "VINES" },
80 { PPP_MPLS_UCAST, "MPLS" },
81 { PPP_MPLS_MCAST, "MPLS" },
83 { PPP_HELLO, "HELLO" },
84 { PPP_LUXCOM, "LUXCOM" },
87 { PPP_OSICP, "OSICP" },
89 { PPP_DECNETCP, "DECNETCP" },
90 { PPP_APPLECP, "APPLECP" },
91 { PPP_IPXCP, "IPXCP" },
92 { PPP_STIICP, "STIICP" },
93 { PPP_VINESCP, "VINESCP" },
94 { PPP_MPLSCP, "MPLSCP" },
100 { PPP_BACP, "BACP" },
106 /* Control Protocols (LCP/IPCP/CCP etc.) Codes defined in RFC 1661 */
108 #define CPCODES_VEXT 0 /* Vendor-Specific (RFC2153) */
109 #define CPCODES_CONF_REQ 1 /* Configure-Request */
110 #define CPCODES_CONF_ACK 2 /* Configure-Ack */
111 #define CPCODES_CONF_NAK 3 /* Configure-Nak */
112 #define CPCODES_CONF_REJ 4 /* Configure-Reject */
113 #define CPCODES_TERM_REQ 5 /* Terminate-Request */
114 #define CPCODES_TERM_ACK 6 /* Terminate-Ack */
115 #define CPCODES_CODE_REJ 7 /* Code-Reject */
116 #define CPCODES_PROT_REJ 8 /* Protocol-Reject (LCP only) */
117 #define CPCODES_ECHO_REQ 9 /* Echo-Request (LCP only) */
118 #define CPCODES_ECHO_RPL 10 /* Echo-Reply (LCP only) */
119 #define CPCODES_DISC_REQ 11 /* Discard-Request (LCP only) */
120 #define CPCODES_ID 12 /* Identification (LCP only) RFC1570 */
121 #define CPCODES_TIME_REM 13 /* Time-Remaining (LCP only) RFC1570 */
122 #define CPCODES_RESET_REQ 14 /* Reset-Request (CCP only) RFC1962 */
123 #define CPCODES_RESET_REP 15 /* Reset-Reply (CCP only) */
125 struct tok cpcodes[] = {
126 {CPCODES_VEXT, "Vendor-Extension"}, /* RFC2153 */
127 {CPCODES_CONF_REQ, "Conf-Request"},
128 {CPCODES_CONF_ACK, "Conf-Ack"},
129 {CPCODES_CONF_NAK, "Conf-Nack"},
130 {CPCODES_CONF_REJ, "Conf-Reject"},
131 {CPCODES_TERM_REQ, "Term-Request"},
132 {CPCODES_TERM_ACK, "Term-Ack"},
133 {CPCODES_CODE_REJ, "Code-Reject"},
134 {CPCODES_PROT_REJ, "Prot-Reject"},
135 {CPCODES_ECHO_REQ, "Echo-Request"},
136 {CPCODES_ECHO_RPL, "Echo-Reply"},
137 {CPCODES_DISC_REQ, "Disc-Req"},
138 {CPCODES_ID, "Ident"}, /* RFC1570 */
139 {CPCODES_TIME_REM, "Time-Rem"}, /* RFC1570 */
140 {CPCODES_RESET_REQ, "Reset-Req"}, /* RFC1962 */
141 {CPCODES_RESET_REP, "Reset-Ack"}, /* RFC1962 */
145 /* LCP Config Options */
147 #define LCPOPT_VEXT 0
149 #define LCPOPT_ACCM 2
153 #define LCPOPT_DEP6 6
155 #define LCPOPT_ACFC 8
156 #define LCPOPT_FCSALT 9
157 #define LCPOPT_SDP 10
158 #define LCPOPT_NUMMODE 11
159 #define LCPOPT_DEP12 12
160 #define LCPOPT_CBACK 13
161 #define LCPOPT_DEP14 14
162 #define LCPOPT_DEP15 15
163 #define LCPOPT_DEP16 16
164 #define LCPOPT_MLMRRU 17
165 #define LCPOPT_MLSSNHF 18
166 #define LCPOPT_MLED 19
167 #define LCPOPT_PROP 20
168 #define LCPOPT_DCEID 21
169 #define LCPOPT_MPP 22
171 #define LCPOPT_LCPAOPT 24
172 #define LCPOPT_COBS 25
174 #define LCPOPT_MLHF 27
175 #define LCPOPT_I18N 28
176 #define LCPOPT_SDLOS 29
177 #define LCPOPT_PPPMUX 30
179 #define LCPOPT_MIN LCPOPT_VEXT
180 #define LCPOPT_MAX LCPOPT_PPPMUX
182 static const char *lcpconfopts[] = {
183 "Vend-Ext", /* (0) */
186 "Auth-Prot", /* (3) */
187 "Qual-Prot", /* (4) */
188 "Magic-Num", /* (5) */
189 "deprecated(6)", /* used to be a Quality Protocol */
194 "Num-Mode", /* (11) */
195 "deprecated(12)", /* used to be a Multi-Link-Procedure*/
196 "Call-Back", /* (13) */
197 "deprecated(14)", /* used to be a Connect-Time */
198 "deprecated(15)", /* used to be a Compund-Frames */
199 "deprecated(16)", /* used to be a Nominal-Data-Encap */
202 "End-Disc", /* (19) */
203 "Proprietary", /* (20) */
206 "Link-Disc", /* (23) */
207 "LCP-Auth-Opt", /* (24) */
209 "Prefix-elision", /* (26) */
210 "Multilink-header-Form",/* (27) */
212 "SDL-over-SONET/SDH", /* (29) */
213 "PPP-Muxing", /* (30) */
216 /* IPV6CP - to be supported */
217 /* ECP - to be supported */
219 /* CCP Config Options */
221 #define CCPOPT_OUI 0 /* RFC1962 */
222 #define CCPOPT_PRED1 1 /* RFC1962 */
223 #define CCPOPT_PRED2 2 /* RFC1962 */
224 #define CCPOPT_PJUMP 3 /* RFC1962 */
225 /* 4-15 unassigned */
226 #define CCPOPT_HPPPC 16 /* RFC1962 */
227 #define CCPOPT_STACLZS 17 /* RFC1974 */
228 #define CCPOPT_MPPC 18 /* RFC2118 */
229 #define CCPOPT_GFZA 19 /* RFC1962 */
230 #define CCPOPT_V42BIS 20 /* RFC1962 */
231 #define CCPOPT_BSDCOMP 21 /* RFC1977 */
233 #define CCPOPT_LZSDCP 23 /* RFC1967 */
234 #define CCPOPT_MVRCA 24 /* RFC1975 */
235 #define CCPOPT_DEC 25 /* RFC1976 */
236 #define CCPOPT_DEFLATE 26 /* RFC1979 */
237 /* 27-254 unassigned */
238 #define CCPOPT_RESV 255 /* RFC1962 */
240 #define CCPOPT_MIN CCPOPT_OUI
241 #define CCPOPT_MAX CCPOPT_DEFLATE /* XXX: should be CCPOPT_RESV but... */
243 static const char *ccpconfopts[] = {
248 "unassigned(4)", /* (4) */
249 "unassigned(5)", /* (5) */
250 "unassigned(6)", /* (6) */
251 "unassigned(7)", /* (7) */
252 "unassigned(8)", /* (8) */
253 "unassigned(9)", /* (9) */
254 "unassigned(10)", /* (10) */
255 "unassigned(11)", /* (11) */
256 "unassigned(12)", /* (12) */
257 "unassigned(13)", /* (13) */
258 "unassigned(14)", /* (14) */
259 "unassigned(15)", /* (15) */
261 "Stac-LZS", /* (17) */
263 "Gand-FZA", /* (19) */
264 "V.42bis", /* (20) */
265 "BSD-Comp", /* (21) */
266 "unassigned(22)", /* (22) */
267 "LZS-DCP", /* (23) */
270 "Deflate", /* (26) */
273 /* BACP Config Options */
275 #define BACPOPT_FPEER 1 /* RFC2125 */
277 /* SDCP - to be supported */
279 /* IPCP Config Options */
281 #define IPCPOPT_2ADDR 1 /* RFC1172, RFC1332 (deprecated) */
282 #define IPCPOPT_IPCOMP 2 /* RFC1332 */
283 #define IPCPOPT_ADDR 3 /* RFC1332 */
284 #define IPCPOPT_MOBILE4 4 /* RFC2290 */
286 #define IPCPOPT_PRIDNS 129 /* RFC1877 */
287 #define IPCPOPT_PRINBNS 130 /* RFC1877 */
288 #define IPCPOPT_SECDNS 131 /* RFC1877 */
289 #define IPCPOPT_SECNBNS 132 /* RFC1877 */
291 /* ATCP - to be supported */
292 /* OSINLCP - to be supported */
293 /* BVCP - to be supported */
294 /* BCP - to be supported */
295 /* IPXCP - to be supported */
296 /* MPLSCP - to be supported */
298 /* Auth Algorithms */
300 /* 0-4 Reserved (RFC1994) */
301 #define AUTHALG_CHAPMD5 5 /* RFC1994 */
302 #define AUTHALG_MSCHAP1 128 /* RFC2433 */
303 #define AUTHALG_MSCHAP2 129 /* RFC2795 */
305 /* FCS Alternatives - to be supported */
307 /* Multilink Endpoint Discriminator (RFC1717) */
308 #define MEDCLASS_NULL 0 /* Null Class */
309 #define MEDCLASS_LOCAL 1 /* Locally Assigned */
310 #define MEDCLASS_IPV4 2 /* Internet Protocol (IPv4) */
311 #define MEDCLASS_MAC 3 /* IEEE 802.1 global MAC address */
312 #define MEDCLASS_MNB 4 /* PPP Magic Number Block */
313 #define MEDCLASS_PSNDN 5 /* Public Switched Network Director Number */
315 /* PPP LCP Callback */
316 #define CALLBACK_AUTH 0 /* Location determined by user auth */
317 #define CALLBACK_DSTR 1 /* Dialing string */
318 #define CALLBACK_LID 2 /* Location identifier */
319 #define CALLBACK_E164 3 /* E.164 number */
320 #define CALLBACK_X500 4 /* X.500 distinguished name */
321 #define CALLBACK_CBCP 6 /* Location is determined during CBCP nego */
330 #define CHAP_CODEMIN CHAP_CHAL
331 #define CHAP_CODEMAX CHAP_FAIL
333 static const char *chapcode[] = {
346 #define PAP_CODEMIN PAP_AREQ
347 #define PAP_CODEMAX PAP_ANAK
349 static const char *papcode[] = {
350 "Auth-Req", /* (1) */
351 "Auth-Ack", /* (2) */
352 "Auth-Nak", /* (3) */
356 #define BAP_CALLREQ 1
357 #define BAP_CALLRES 2
365 static void handle_ctrl_proto (u_int proto,const u_char *p, int length);
366 static void handle_chap (const u_char *p, int length);
367 static void handle_pap (const u_char *p, int length);
368 static void handle_bap (const u_char *p, int length);
369 static int print_lcp_config_options (const u_char *p, int);
370 static int print_ipcp_config_options (const u_char *p, int);
371 static int print_ccp_config_options (const u_char *p, int);
372 static int print_bacp_config_options (const u_char *p, int);
373 static void handle_ppp (u_int proto, const u_char *p, int length);
375 /* generic Control Protocol (e.g. LCP, IPCP, CCP, etc.) handler */
377 handle_ctrl_proto(u_int proto, const u_char *pptr, int length)
381 int (*pfunc)(const u_char *, int);
387 typestr = tok2str(ppptype2str, "unknown", proto);
388 printf("%s, ",typestr);
390 if (length < 4) /* FIXME weak boundary checking */
396 printf("%s (0x%02x), id %u",
397 tok2str(cpcodes, "Unknown Opcode",code),
402 len = EXTRACT_16BITS(tptr);
406 return; /* there may be a NULL confreq etc. */
413 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
416 printf(" OUI 0x%06x", EXTRACT_24BITS(tptr));
417 /* XXX: need to decode Kind and Value(s)? */
419 case CPCODES_CONF_REQ:
420 case CPCODES_CONF_ACK:
421 case CPCODES_CONF_NAK:
422 case CPCODES_CONF_REJ:
423 x = len - 4; /* Code(1), Identifier(1) and Length(2) */
427 pfunc = print_lcp_config_options;
430 pfunc = print_ipcp_config_options;
433 pfunc = print_ccp_config_options;
436 pfunc = print_bacp_config_options;
440 * This should never happen, but we set
441 * "pfunc" to squelch uninitialized
442 * variable warnings from compilers.
447 if ((j = (*pfunc)(tptr, len)) == 0)
454 case CPCODES_TERM_REQ:
455 case CPCODES_TERM_ACK:
456 /* XXX: need to decode Data? */
458 case CPCODES_CODE_REJ:
459 /* XXX: need to decode Rejected-Packet? */
461 case CPCODES_PROT_REJ:
465 printf(", Rejected %s Protocol (0x%04x)",
466 tok2str(ppptype2str,"unknown", EXTRACT_16BITS(tptr)),
467 EXTRACT_16BITS(tptr));
468 /* XXX: need to decode Rejected-Information? */
470 case CPCODES_ECHO_REQ:
471 case CPCODES_ECHO_RPL:
472 case CPCODES_DISC_REQ:
477 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
478 /* XXX: need to decode Data? */
480 case CPCODES_TIME_REM:
484 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
485 TCHECK2(*(tptr + 4), 4);
486 printf(", Seconds-Remaining %us", EXTRACT_32BITS(tptr + 4));
487 /* XXX: need to decode Message? */
490 /* XXX this is dirty but we do not get the
491 * original pointer passed to the begin
494 print_unknown_data(pptr-2,"\n\t",length+2);
497 printf(", length %u", length);
500 print_unknown_data(pptr-2,"\n\t",length+2);
504 printf("[|%s]", typestr);
507 /* LCP config options */
509 print_lcp_config_options(const u_char *p, int length)
520 if ((opt >= LCPOPT_MIN) && (opt <= LCPOPT_MAX))
521 printf(", %s ", lcpconfopts[opt]);
523 printf(", unknown LCP option 0x%02x", opt);
530 TCHECK2(*(p + 2), 3);
531 printf(" OUI 0x%06x", EXTRACT_24BITS(p+2));
534 printf(" kind 0x%02x", p[5]);
536 for (i = 0; i < len - 6; i++) {
538 printf("%02x", p[6 + i]);
545 TCHECK2(*(p + 2), 2);
546 printf(" %u", EXTRACT_16BITS(p + 2));
551 TCHECK2(*(p + 2), 4);
552 printf(" %08x", EXTRACT_32BITS(p + 2));
557 TCHECK2(*(p + 2), 2);
558 switch (EXTRACT_16BITS(p+2)) {
567 printf(", unknown-algorithm-%u", p[4]);
569 case AUTHALG_CHAPMD5:
572 case AUTHALG_MSCHAP1:
573 printf(", MSCHAPv1");
575 case AUTHALG_MSCHAP2:
576 printf(", MSCHAPv2");
596 TCHECK2(*(p + 2), 2);
597 if (EXTRACT_16BITS(p+2) == PPP_LQM)
605 TCHECK2(*(p + 2), 4);
606 printf(" 0x%08x", EXTRACT_32BITS(p + 2));
615 TCHECK2(*(p + 2), 2);
616 printf(" 0x%04x", EXTRACT_16BITS(p + 2));
623 switch (p[2]) { /* Operation */
628 printf(" DialString");
643 printf(" unknown-operation=%u", p[2]);
649 TCHECK2(*(p + 2), 2);
650 printf(" %u", EXTRACT_16BITS(p + 2));
657 switch (p[2]) { /* class */
662 printf(" Local"); /* XXX */
667 TCHECK2(*(p + 3), 4);
668 printf(" IPv4 %s", ipaddr_string(p + 3));
674 printf(" MAC %02x:%02x:%02x:%02x:%02x:%02x",
675 p[3], p[4], p[5], p[6], p[7], p[8]);
678 printf(" Magic-Num-Block"); /* XXX */
681 printf(" PSNDN"); /* XXX */
686 /* XXX: to be supported */
719 handle_chap(const u_char *p, int length)
722 int val_size, name_size, msg_size;
730 } else if (length < 4) {
732 printf("[|chap 0x%02x]", *p);
738 if ((code >= CHAP_CODEMIN) && (code <= CHAP_CODEMAX))
739 printf("%s", chapcode[code - 1]);
741 printf("0x%02x", code);
747 printf("(%u)", *p); /* ID */
751 len = EXTRACT_16BITS(p);
755 * Note that this is a generic CHAP decoding routine. Since we
756 * don't know which flavor of CHAP (i.e. CHAP-MD5, MS-CHAPv1,
757 * MS-CHAPv2) is used at this point, we can't decode packet
758 * specifically to each algorithms. Instead, we simply decode
759 * the GCD (Gratest Common Denominator) for all algorithms.
764 if (length - (p - p0) < 1)
767 val_size = *p; /* value size */
769 if (length - (p - p0) < val_size)
772 for (i = 0; i < val_size; i++) {
774 printf("%02x", *p++);
776 name_size = len - (p - p0);
778 for (i = 0; i < name_size; i++) {
785 msg_size = len - (p - p0);
787 for (i = 0; i< msg_size; i++) {
799 /* PAP (see RFC 1334) */
801 handle_pap(const u_char *p, int length)
804 int peerid_len, passwd_len, msg_len;
812 } else if (length < 4) {
814 printf("[|pap 0x%02x]", *p);
820 if ((code >= PAP_CODEMIN) && (code <= PAP_CODEMAX))
821 printf("%s", papcode[code - 1]);
823 printf("0x%02x", code);
829 printf("(%u)", *p); /* ID */
833 len = EXTRACT_16BITS(p);
838 if (length - (p - p0) < 1)
841 peerid_len = *p; /* Peer-ID Length */
843 if (length - (p - p0) < peerid_len)
846 for (i = 0; i < peerid_len; i++) {
851 if (length - (p - p0) < 1)
854 passwd_len = *p; /* Password Length */
856 if (length - (p - p0) < passwd_len)
859 for (i = 0; i < passwd_len; i++) {
866 if (length - (p - p0) < 1)
869 msg_len = *p; /* Msg-Length */
871 if (length - (p - p0) < msg_len)
874 for (i = 0; i< msg_len; i++) {
888 handle_bap(const u_char *p _U_, int length _U_)
890 /* XXX: to be supported!! */
894 /* IPCP config options */
896 print_ipcp_config_options(const u_char *p, int length)
908 case IPCPOPT_2ADDR: /* deprecated */
911 TCHECK2(*(p + 6), 4);
912 printf(", IP-Addrs src %s, dst %s",
913 ipaddr_string(p + 2),
914 ipaddr_string(p + 6));
920 TCHECK2(*(p + 2), 2);
921 if (EXTRACT_16BITS(p + 2) == PPP_VJC) {
923 /* XXX: VJ-Comp parameters should be decoded */
925 printf(" unknown-comp-proto=%04x", EXTRACT_16BITS(p + 2));
930 TCHECK2(*(p + 2), 4);
931 printf(", IP-Addr %s", ipaddr_string(p + 2));
933 case IPCPOPT_MOBILE4:
936 TCHECK2(*(p + 2), 4);
937 printf(", Home-Addr %s", ipaddr_string(p + 2));
942 TCHECK2(*(p + 2), 4);
943 printf(", Pri-DNS %s", ipaddr_string(p + 2));
945 case IPCPOPT_PRINBNS:
948 TCHECK2(*(p + 2), 4);
949 printf(", Pri-NBNS %s", ipaddr_string(p + 2));
954 TCHECK2(*(p + 2), 4);
955 printf(", Sec-DNS %s", ipaddr_string(p + 2));
957 case IPCPOPT_SECNBNS:
960 TCHECK2(*(p + 2), 4);
961 printf(", Sec-NBNS %s", ipaddr_string(p + 2));
964 printf(", unknown-%d", opt);
970 printf(", invalid-length-%d", opt);
978 /* CCP config options */
980 print_ccp_config_options(const u_char *p, int length)
991 if ((opt >= CCPOPT_MIN) && (opt <= CCPOPT_MAX))
992 printf(", %s", ccpconfopts[opt]);
1000 case CCPOPT_STACLZS:
1004 case CCPOPT_BSDCOMP:
1008 case CCPOPT_DEFLATE:
1013 printf(", unknown-%d", opt);
1024 /* BACP config options */
1026 print_bacp_config_options(const u_char *p, int length)
1037 if (opt == BACPOPT_FPEER) {
1038 TCHECK2(*(p + 2), 4);
1039 printf(", Favored-Peer");
1040 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(p + 2));
1042 printf(", unknown-option-%d", opt);
1054 handle_ppp(u_int proto, const u_char *p, int length)
1064 handle_ctrl_proto(proto, p, length);
1067 handle_chap(p, length);
1070 handle_pap(p, length);
1072 case PPP_BAP: /* XXX: not yet completed */
1073 handle_bap(p, length);
1075 case ETHERTYPE_IP: /*XXX*/
1077 ip_print(p, length);
1080 case ETHERTYPE_IPV6: /*XXX*/
1082 ip6_print(p, length);
1085 case ETHERTYPE_IPX: /*XXX*/
1087 ipx_print(p, length);
1090 isoclns_print(p, length, length);
1092 case PPP_MPLS_UCAST:
1093 case PPP_MPLS_MCAST:
1094 mpls_print(p, length);
1097 printf("unknown PPP protocol (0x%04x)", proto);
1098 print_unknown_data(p,"\n\t",length);
1103 /* Standard PPP printer */
1105 ppp_print(register const u_char *p, u_int length)
1108 u_int olen = length; /* _o_riginal length */
1112 * Here, we assume that p points to the Address and Control
1113 * field (if they present).
1118 if (*p == PPP_ADDRESS && *(p + 1) == PPP_CONTROL) {
1119 p += 2; /* ACFC not used */
1128 proto = *p; /* PFC is used */
1134 proto = EXTRACT_16BITS(p);
1141 printf("PPP-%s (0x%04x), length %u: ",
1142 tok2str(ppptype2str, "unknown", proto),
1146 handle_ppp(proto, p, length);
1154 /* PPP I/F printer */
1156 ppp_if_print(const struct pcap_pkthdr *h, register const u_char *p)
1158 register u_int length = h->len;
1159 register u_int caplen = h->caplen;
1161 if (caplen < PPP_HDRLEN) {
1168 * XXX: seems to assume that there are 2 octets prepended to an
1169 * actual PPP frame. The 1st octet looks like Input/Output flag
1170 * while 2nd octet is unknown, at least to me
1171 * (mshindo@mshindo.net).
1173 * That was what the original tcpdump code did.
1175 * FreeBSD's "if_ppp.c" *does* set the first octet to 1 for outbound
1176 * packets and 0 for inbound packets - but only if the
1177 * protocol field has the 0x8000 bit set (i.e., it's a network
1178 * control protocol); it does so before running the packet through
1179 * "bpf_filter" to see if it should be discarded, and to see
1180 * if we should update the time we sent the most recent packet...
1182 * ...but it puts the original address field back after doing
1185 * NetBSD's "if_ppp.c" doesn't set the first octet in that fashion.
1187 * I don't know if any PPP implementation handed up to a BPF
1188 * device packets with the first octet being 1 for outbound and
1189 * 0 for inbound packets, so I (guy@alum.mit.edu) don't know
1190 * whether that ever needs to be checked or not.
1192 * Note that NetBSD has a DLT_PPP_SERIAL, which it uses for PPP,
1193 * and its tcpdump appears to assume that the frame always
1194 * begins with an address field and a control field, and that
1195 * the address field might be 0x0f or 0x8f, for Cisco
1196 * point-to-point with HDLC framing as per section 4.3.1 of RFC
1197 * 1547, as well as 0xff, for PPP in HDLC-like framing as per
1200 * (Is the Cisco framing in question what DLT_C_HDLC, in
1204 printf("%c %4d %02x ", p[0] ? 'O' : 'I', length, p[1]);
1207 ppp_print(p, length);
1213 * PPP I/F printer to use if we know that RFC 1662-style PPP in HDLC-like
1214 * framing, or Cisco PPP with HDLC framing as per section 4.3.1 of RFC 1547,
1215 * is being used (i.e., we don't check for PPP_ADDRESS and PPP_CONTROL,
1216 * discard them *if* those are the first two octets, and parse the remaining
1217 * packet as a PPP packet, as "ppp_print()" does).
1219 * This handles, for example, DLT_PPP_SERIAL in NetBSD.
1222 ppp_hdlc_if_print(const struct pcap_pkthdr *h, register const u_char *p)
1224 register u_int length = h->len;
1225 register u_int caplen = h->caplen;
1243 printf("%02x %02x %d ", p[0], p[1], length);
1248 proto = EXTRACT_16BITS(p);
1252 printf("%s: ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", proto));
1254 handle_ppp(proto, p, length);
1259 return (chdlc_if_print(h, p));
1263 printf("%02x %02x %d ", p[0], p[1], length);
1269 * XXX - NetBSD's "ppp_netbsd_serial_if_print()" treats
1270 * the next two octets as an Ethernet type; does that
1273 printf("unknown addr %02x; ctrl %02x", p[0], p[1]);
1280 #define PPP_BSDI_HDRLEN 24
1282 /* BSD/OS specific PPP printer */
1284 ppp_bsdos_if_print(const struct pcap_pkthdr *h _U_, register const u_char *p _U_)
1286 register int hdrlength;
1288 register u_int length = h->len;
1289 register u_int caplen = h->caplen;
1294 if (caplen < PPP_BSDI_HDRLEN) {
1302 if (p[0] == PPP_ADDRESS && p[1] == PPP_CONTROL) {
1304 printf("%02x %02x ", p[0], p[1]);
1310 printf("%d ", length);
1311 /* Retrieve the protocol type */
1313 /* Compressed protocol field */
1316 printf("%02x ", ptype);
1320 /* Un-compressed protocol field */
1321 ptype = ntohs(*(u_int16_t *)p);
1323 printf("%04x ", ptype);
1330 printf("%c ", p[SLC_DIR] ? 'O' : 'I');
1332 /* link level header */
1333 struct ppp_header *ph;
1335 q = p + SLC_BPFHDRLEN;
1336 ph = (struct ppp_header *)q;
1337 if (ph->phdr_addr == PPP_ADDRESS
1338 && ph->phdr_ctl == PPP_CONTROL) {
1340 printf("%02x %02x ", q[0], q[1]);
1341 ptype = ntohs(ph->phdr_type);
1342 if (eflag && (ptype == PPP_VJC || ptype == PPP_VJNC)) {
1343 printf("%s ", tok2str(ppptype2str,
1344 "proto-#%d", ptype));
1349 for (i = 0; i < p[SLC_LLHL]; i++)
1350 printf("%02x", q[i]);
1356 printf("%d ", length);
1358 q = p + SLC_BPFHDRLEN + p[SLC_LLHL];
1362 ptype = vjc_print(q, ptype);
1363 hdrlength = PPP_BSDI_HDRLEN;
1367 ip_print(p, length);
1371 ip6_print(p, length);
1374 case PPP_MPLS_UCAST:
1375 case PPP_MPLS_MCAST:
1376 mpls_print(p, length);
1381 ptype = vjc_print(q, ptype);
1382 hdrlength = PPP_BSDI_HDRLEN;
1386 ip_print(p, length);
1390 ip6_print(p, length);
1393 case PPP_MPLS_UCAST:
1394 case PPP_MPLS_MCAST:
1395 mpls_print(p, length);
1402 for (i = 0; i < p[SLC_LLHL]; i++)
1403 printf("%02x", q[i]);
1410 hdrlength = PPP_BSDI_HDRLEN;
1413 length -= hdrlength;
1418 ip_print(p, length);
1422 ip6_print(p, length);
1425 case PPP_MPLS_UCAST:
1426 case PPP_MPLS_MCAST:
1427 mpls_print(p, length);
1430 printf("%s ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", ptype));
1436 #endif /* __bsdi__ */