tcpdump  4.99.1
About: tcpdump is a tool for network monitoring and data acquisition.
  Fossies Dox: tcpdump-4.99.1.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

print-ppp.c
Go to the documentation of this file.
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 /* \summary: Point to Point Protocol (PPP) printer */
26 
27 /*
28  * TODO:
29  * o resolve XXX as much as possible
30  * o MP support
31  * o BAP support
32  */
33 
34 #ifdef HAVE_CONFIG_H
35 #include <config.h>
36 #endif
37 
38 #include "netdissect-stdinc.h"
39 
40 #ifdef __bsdi__
41 #include <net/slcompress.h>
42 #include <net/if_ppp.h>
43 #endif
44 
45 #include "netdissect.h"
46 #include "extract.h"
47 #include "addrtoname.h"
48 #include "ppp.h"
49 #include "chdlc.h"
50 #include "ethertype.h"
51 #include "oui.h"
52 #include "netdissect-alloc.h"
53 
54 /*
55  * The following constants are defined by IANA. Please refer to
56  * https://www.isi.edu/in-notes/iana/assignments/ppp-numbers
57  * for the up-to-date information.
58  */
59 
60 /* Protocol Codes defined in ppp.h */
61 
62 static const struct tok ppptype2str[] = {
63  { PPP_IP, "IP" },
64  { PPP_OSI, "OSI" },
65  { PPP_NS, "NS" },
66  { PPP_DECNET, "DECNET" },
67  { PPP_APPLE, "APPLE" },
68  { PPP_IPX, "IPX" },
69  { PPP_VJC, "VJC IP" },
70  { PPP_VJNC, "VJNC IP" },
71  { PPP_BRPDU, "BRPDU" },
72  { PPP_STII, "STII" },
73  { PPP_VINES, "VINES" },
74  { PPP_MPLS_UCAST, "MPLS" },
75  { PPP_MPLS_MCAST, "MPLS" },
76  { PPP_COMP, "Compressed"},
77  { PPP_ML, "MLPPP"},
78  { PPP_IPV6, "IP6"},
79 
80  { PPP_HELLO, "HELLO" },
81  { PPP_LUXCOM, "LUXCOM" },
82  { PPP_SNS, "SNS" },
83  { PPP_IPCP, "IPCP" },
84  { PPP_OSICP, "OSICP" },
85  { PPP_NSCP, "NSCP" },
86  { PPP_DECNETCP, "DECNETCP" },
87  { PPP_APPLECP, "APPLECP" },
88  { PPP_IPXCP, "IPXCP" },
89  { PPP_STIICP, "STIICP" },
90  { PPP_VINESCP, "VINESCP" },
91  { PPP_IPV6CP, "IP6CP" },
92  { PPP_MPLSCP, "MPLSCP" },
93 
94  { PPP_LCP, "LCP" },
95  { PPP_PAP, "PAP" },
96  { PPP_LQM, "LQM" },
97  { PPP_CHAP, "CHAP" },
98  { PPP_EAP, "EAP" },
99  { PPP_SPAP, "SPAP" },
100  { PPP_SPAP_OLD, "Old-SPAP" },
101  { PPP_BACP, "BACP" },
102  { PPP_BAP, "BAP" },
103  { PPP_MPCP, "MLPPP-CP" },
104  { PPP_CCP, "CCP" },
105  { 0, NULL }
106 };
107 
108 /* Control Protocols (LCP/IPCP/CCP etc.) Codes defined in RFC 1661 */
109 
110 #define CPCODES_VEXT 0 /* Vendor-Specific (RFC2153) */
111 #define CPCODES_CONF_REQ 1 /* Configure-Request */
112 #define CPCODES_CONF_ACK 2 /* Configure-Ack */
113 #define CPCODES_CONF_NAK 3 /* Configure-Nak */
114 #define CPCODES_CONF_REJ 4 /* Configure-Reject */
115 #define CPCODES_TERM_REQ 5 /* Terminate-Request */
116 #define CPCODES_TERM_ACK 6 /* Terminate-Ack */
117 #define CPCODES_CODE_REJ 7 /* Code-Reject */
118 #define CPCODES_PROT_REJ 8 /* Protocol-Reject (LCP only) */
119 #define CPCODES_ECHO_REQ 9 /* Echo-Request (LCP only) */
120 #define CPCODES_ECHO_RPL 10 /* Echo-Reply (LCP only) */
121 #define CPCODES_DISC_REQ 11 /* Discard-Request (LCP only) */
122 #define CPCODES_ID 12 /* Identification (LCP only) RFC1570 */
123 #define CPCODES_TIME_REM 13 /* Time-Remaining (LCP only) RFC1570 */
124 #define CPCODES_RESET_REQ 14 /* Reset-Request (CCP only) RFC1962 */
125 #define CPCODES_RESET_REP 15 /* Reset-Reply (CCP only) */
126 
127 static const struct tok cpcodes[] = {
128  {CPCODES_VEXT, "Vendor-Extension"}, /* RFC2153 */
129  {CPCODES_CONF_REQ, "Conf-Request"},
130  {CPCODES_CONF_ACK, "Conf-Ack"},
131  {CPCODES_CONF_NAK, "Conf-Nack"},
132  {CPCODES_CONF_REJ, "Conf-Reject"},
133  {CPCODES_TERM_REQ, "Term-Request"},
134  {CPCODES_TERM_ACK, "Term-Ack"},
135  {CPCODES_CODE_REJ, "Code-Reject"},
136  {CPCODES_PROT_REJ, "Prot-Reject"},
137  {CPCODES_ECHO_REQ, "Echo-Request"},
138  {CPCODES_ECHO_RPL, "Echo-Reply"},
139  {CPCODES_DISC_REQ, "Disc-Req"},
140  {CPCODES_ID, "Ident"}, /* RFC1570 */
141  {CPCODES_TIME_REM, "Time-Rem"}, /* RFC1570 */
142  {CPCODES_RESET_REQ, "Reset-Req"}, /* RFC1962 */
143  {CPCODES_RESET_REP, "Reset-Ack"}, /* RFC1962 */
144  {0, NULL}
145 };
146 
147 /* LCP Config Options */
148 
149 #define LCPOPT_VEXT 0
150 #define LCPOPT_MRU 1
151 #define LCPOPT_ACCM 2
152 #define LCPOPT_AP 3
153 #define LCPOPT_QP 4
154 #define LCPOPT_MN 5
155 #define LCPOPT_DEP6 6
156 #define LCPOPT_PFC 7
157 #define LCPOPT_ACFC 8
158 #define LCPOPT_FCSALT 9
159 #define LCPOPT_SDP 10
160 #define LCPOPT_NUMMODE 11
161 #define LCPOPT_DEP12 12
162 #define LCPOPT_CBACK 13
163 #define LCPOPT_DEP14 14
164 #define LCPOPT_DEP15 15
165 #define LCPOPT_DEP16 16
166 #define LCPOPT_MLMRRU 17
167 #define LCPOPT_MLSSNHF 18
168 #define LCPOPT_MLED 19
169 #define LCPOPT_PROP 20
170 #define LCPOPT_DCEID 21
171 #define LCPOPT_MPP 22
172 #define LCPOPT_LD 23
173 #define LCPOPT_LCPAOPT 24
174 #define LCPOPT_COBS 25
175 #define LCPOPT_PE 26
176 #define LCPOPT_MLHF 27
177 #define LCPOPT_I18N 28
178 #define LCPOPT_SDLOS 29
179 #define LCPOPT_PPPMUX 30
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  "12-Bit seq #", /* (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 #define NUM_LCPOPTS (sizeof(lcpconfopts) / sizeof(lcpconfopts[0]))
216 
217 /* ECP - to be supported */
218 
219 /* CCP Config Options */
220 
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 */
232 /* 22 unassigned */
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 */
239 
240 static const struct tok ccpconfopts_values[] = {
241  { CCPOPT_OUI, "OUI" },
242  { CCPOPT_PRED1, "Pred-1" },
243  { CCPOPT_PRED2, "Pred-2" },
244  { CCPOPT_PJUMP, "Puddle" },
245  { CCPOPT_HPPPC, "HP-PPC" },
246  { CCPOPT_STACLZS, "Stac-LZS" },
247  { CCPOPT_MPPC, "MPPC" },
248  { CCPOPT_GFZA, "Gand-FZA" },
249  { CCPOPT_V42BIS, "V.42bis" },
250  { CCPOPT_BSDCOMP, "BSD-Comp" },
251  { CCPOPT_LZSDCP, "LZS-DCP" },
252  { CCPOPT_MVRCA, "MVRCA" },
253  { CCPOPT_DEC, "DEC" },
254  { CCPOPT_DEFLATE, "Deflate" },
255  { CCPOPT_RESV, "Reserved"},
256  {0, NULL}
257 };
258 
259 /* BACP Config Options */
260 
261 #define BACPOPT_FPEER 1 /* RFC2125 */
262 
263 static const struct tok bacconfopts_values[] = {
264  { BACPOPT_FPEER, "Favored-Peer" },
265  {0, NULL}
266 };
267 
268 
269 /* SDCP - to be supported */
270 
271 /* IPCP Config Options */
272 #define IPCPOPT_2ADDR 1 /* RFC1172, RFC1332 (deprecated) */
273 #define IPCPOPT_IPCOMP 2 /* RFC1332 */
274 #define IPCPOPT_ADDR 3 /* RFC1332 */
275 #define IPCPOPT_MOBILE4 4 /* RFC2290 */
276 #define IPCPOPT_PRIDNS 129 /* RFC1877 */
277 #define IPCPOPT_PRINBNS 130 /* RFC1877 */
278 #define IPCPOPT_SECDNS 131 /* RFC1877 */
279 #define IPCPOPT_SECNBNS 132 /* RFC1877 */
280 
281 static const struct tok ipcpopt_values[] = {
282  { IPCPOPT_2ADDR, "IP-Addrs" },
283  { IPCPOPT_IPCOMP, "IP-Comp" },
284  { IPCPOPT_ADDR, "IP-Addr" },
285  { IPCPOPT_MOBILE4, "Home-Addr" },
286  { IPCPOPT_PRIDNS, "Pri-DNS" },
287  { IPCPOPT_PRINBNS, "Pri-NBNS" },
288  { IPCPOPT_SECDNS, "Sec-DNS" },
289  { IPCPOPT_SECNBNS, "Sec-NBNS" },
290  { 0, NULL }
291 };
292 
293 #define IPCPOPT_IPCOMP_HDRCOMP 0x61 /* rfc3544 */
294 #define IPCPOPT_IPCOMP_MINLEN 14
295 
296 static const struct tok ipcpopt_compproto_values[] = {
297  { PPP_VJC, "VJ-Comp" },
298  { IPCPOPT_IPCOMP_HDRCOMP, "IP Header Compression" },
299  { 0, NULL }
300 };
301 
302 static const struct tok ipcpopt_compproto_subopt_values[] = {
303  { 1, "RTP-Compression" },
304  { 2, "Enhanced RTP-Compression" },
305  { 0, NULL }
306 };
307 
308 /* IP6CP Config Options */
309 #define IP6CP_IFID 1
310 
311 static const struct tok ip6cpopt_values[] = {
312  { IP6CP_IFID, "Interface-ID" },
313  { 0, NULL }
314 };
315 
316 /* ATCP - to be supported */
317 /* OSINLCP - to be supported */
318 /* BVCP - to be supported */
319 /* BCP - to be supported */
320 /* IPXCP - to be supported */
321 /* MPLSCP - to be supported */
322 
323 /* Auth Algorithms */
324 
325 /* 0-4 Reserved (RFC1994) */
326 #define AUTHALG_CHAPMD5 5 /* RFC1994 */
327 #define AUTHALG_MSCHAP1 128 /* RFC2433 */
328 #define AUTHALG_MSCHAP2 129 /* RFC2795 */
329 
330 static const struct tok authalg_values[] = {
331  { AUTHALG_CHAPMD5, "MD5" },
332  { AUTHALG_MSCHAP1, "MS-CHAPv1" },
333  { AUTHALG_MSCHAP2, "MS-CHAPv2" },
334  { 0, NULL }
335 };
336 
337 /* FCS Alternatives - to be supported */
338 
339 /* Multilink Endpoint Discriminator (RFC1717) */
340 #define MEDCLASS_NULL 0 /* Null Class */
341 #define MEDCLASS_LOCAL 1 /* Locally Assigned */
342 #define MEDCLASS_IPV4 2 /* Internet Protocol (IPv4) */
343 #define MEDCLASS_MAC 3 /* IEEE 802.1 global MAC address */
344 #define MEDCLASS_MNB 4 /* PPP Magic Number Block */
345 #define MEDCLASS_PSNDN 5 /* Public Switched Network Director Number */
346 
347 /* PPP LCP Callback */
348 #define CALLBACK_AUTH 0 /* Location determined by user auth */
349 #define CALLBACK_DSTR 1 /* Dialing string */
350 #define CALLBACK_LID 2 /* Location identifier */
351 #define CALLBACK_E164 3 /* E.164 number */
352 #define CALLBACK_X500 4 /* X.500 distinguished name */
353 #define CALLBACK_CBCP 6 /* Location is determined during CBCP nego */
354 
355 static const struct tok ppp_callback_values[] = {
356  { CALLBACK_AUTH, "UserAuth" },
357  { CALLBACK_DSTR, "DialString" },
358  { CALLBACK_LID, "LocalID" },
359  { CALLBACK_E164, "E.164" },
360  { CALLBACK_X500, "X.500" },
361  { CALLBACK_CBCP, "CBCP" },
362  { 0, NULL }
363 };
364 
365 /* CHAP */
366 
367 #define CHAP_CHAL 1
368 #define CHAP_RESP 2
369 #define CHAP_SUCC 3
370 #define CHAP_FAIL 4
371 
372 static const struct tok chapcode_values[] = {
373  { CHAP_CHAL, "Challenge" },
374  { CHAP_RESP, "Response" },
375  { CHAP_SUCC, "Success" },
376  { CHAP_FAIL, "Fail" },
377  { 0, NULL}
378 };
379 
380 /* PAP */
381 
382 #define PAP_AREQ 1
383 #define PAP_AACK 2
384 #define PAP_ANAK 3
385 
386 static const struct tok papcode_values[] = {
387  { PAP_AREQ, "Auth-Req" },
388  { PAP_AACK, "Auth-ACK" },
389  { PAP_ANAK, "Auth-NACK" },
390  { 0, NULL }
391 };
392 
393 /* BAP */
394 #define BAP_CALLREQ 1
395 #define BAP_CALLRES 2
396 #define BAP_CBREQ 3
397 #define BAP_CBRES 4
398 #define BAP_LDQREQ 5
399 #define BAP_LDQRES 6
400 #define BAP_CSIND 7
401 #define BAP_CSRES 8
402 
403 static u_int print_lcp_config_options(netdissect_options *, const u_char *p, u_int);
404 static u_int print_ipcp_config_options(netdissect_options *, const u_char *p, u_int);
405 static u_int print_ip6cp_config_options(netdissect_options *, const u_char *p, u_int);
406 static u_int print_ccp_config_options(netdissect_options *, const u_char *p, u_int);
407 static u_int print_bacp_config_options(netdissect_options *, const u_char *p, u_int);
408 static void handle_ppp(netdissect_options *, u_int proto, const u_char *p, u_int length);
409 
410 /* generic Control Protocol (e.g. LCP, IPCP, CCP, etc.) handler */
411 static void
413  u_int proto, const u_char *pptr, u_int length)
414 {
415  const char *typestr;
416  u_int code, len;
417  u_int (*pfunc)(netdissect_options *, const u_char *, u_int);
418  u_int tlen, advance;
419  const u_char *tptr;
420 
421  tptr=pptr;
422 
423  typestr = tok2str(ppptype2str, "unknown ctrl-proto (0x%04x)", proto);
424  ND_PRINT("%s, ", typestr);
425 
426  if (length < 4) /* FIXME weak boundary checking */
427  goto trunc;
428  ND_TCHECK_2(tptr);
429 
430  code = GET_U_1(tptr);
431  tptr++;
432 
433  ND_PRINT("%s (0x%02x), id %u, length %u",
434  tok2str(cpcodes, "Unknown Opcode",code),
435  code,
436  GET_U_1(tptr), /* ID */
437  length + 2);
438  tptr++;
439 
440  if (!ndo->ndo_vflag)
441  return;
442 
443  len = GET_BE_U_2(tptr);
444  tptr += 2;
445 
446  if (len < 4) {
447  ND_PRINT("\n\tencoded length %u (< 4))", len);
448  return;
449  }
450 
451  if (len > length) {
452  ND_PRINT("\n\tencoded length %u (> packet length %u))", len, length);
453  return;
454  }
455  length = len;
456 
457  ND_PRINT("\n\tencoded length %u (=Option(s) length %u)", len, len - 4);
458 
459  if (length == 4)
460  return; /* there may be a NULL confreq etc. */
461 
462  if (ndo->ndo_vflag > 1)
463  print_unknown_data(ndo, pptr - 2, "\n\t", 6);
464 
465 
466  switch (code) {
467  case CPCODES_VEXT:
468  if (length < 11)
469  break;
470  ND_PRINT("\n\t Magic-Num 0x%08x", GET_BE_U_4(tptr));
471  tptr += 4;
472  ND_PRINT(" Vendor: %s (%u)",
473  tok2str(oui_values,"Unknown",GET_BE_U_3(tptr)),
474  GET_BE_U_3(tptr));
475  /* XXX: need to decode Kind and Value(s)? */
476  break;
477  case CPCODES_CONF_REQ:
478  case CPCODES_CONF_ACK:
479  case CPCODES_CONF_NAK:
480  case CPCODES_CONF_REJ:
481  tlen = len - 4; /* Code(1), Identifier(1) and Length(2) */
482  do {
483  switch (proto) {
484  case PPP_LCP:
485  pfunc = print_lcp_config_options;
486  break;
487  case PPP_IPCP:
489  break;
490  case PPP_IPV6CP:
492  break;
493  case PPP_CCP:
494  pfunc = print_ccp_config_options;
495  break;
496  case PPP_BACP:
498  break;
499  default:
500  /*
501  * No print routine for the options for
502  * this protocol.
503  */
504  pfunc = NULL;
505  break;
506  }
507 
508  if (pfunc == NULL) /* catch the above null pointer if unknown CP */
509  break;
510 
511  if ((advance = (*pfunc)(ndo, tptr, len)) == 0)
512  break;
513  if (tlen < advance) {
514  ND_PRINT(" [remaining options length %u < %u]",
515  tlen, advance);
516  nd_print_invalid(ndo);
517  break;
518  }
519  tlen -= advance;
520  tptr += advance;
521  } while (tlen != 0);
522  break;
523 
524  case CPCODES_TERM_REQ:
525  case CPCODES_TERM_ACK:
526  /* XXX: need to decode Data? */
527  break;
528  case CPCODES_CODE_REJ:
529  /* XXX: need to decode Rejected-Packet? */
530  break;
531  case CPCODES_PROT_REJ:
532  if (length < 6)
533  break;
534  ND_PRINT("\n\t Rejected %s Protocol (0x%04x)",
535  tok2str(ppptype2str,"unknown", GET_BE_U_2(tptr)),
536  GET_BE_U_2(tptr));
537  /* XXX: need to decode Rejected-Information? - hexdump for now */
538  if (len > 6) {
539  ND_PRINT("\n\t Rejected Packet");
540  print_unknown_data(ndo, tptr + 2, "\n\t ", len - 2);
541  }
542  break;
543  case CPCODES_ECHO_REQ:
544  case CPCODES_ECHO_RPL:
545  case CPCODES_DISC_REQ:
546  if (length < 8)
547  break;
548  ND_PRINT("\n\t Magic-Num 0x%08x", GET_BE_U_4(tptr));
549  /* XXX: need to decode Data? - hexdump for now */
550  if (len > 8) {
551  ND_PRINT("\n\t -----trailing data-----");
552  ND_TCHECK_LEN(tptr + 4, len - 8);
553  print_unknown_data(ndo, tptr + 4, "\n\t ", len - 8);
554  }
555  break;
556  case CPCODES_ID:
557  if (length < 8)
558  break;
559  ND_PRINT("\n\t Magic-Num 0x%08x", GET_BE_U_4(tptr));
560  /* RFC 1661 says this is intended to be human readable */
561  if (len > 8) {
562  ND_PRINT("\n\t Message\n\t ");
563  if (nd_printn(ndo, tptr + 4, len - 4, ndo->ndo_snapend))
564  goto trunc;
565  }
566  break;
567  case CPCODES_TIME_REM:
568  if (length < 12)
569  break;
570  ND_PRINT("\n\t Magic-Num 0x%08x", GET_BE_U_4(tptr));
571  ND_PRINT(", Seconds-Remaining %us", GET_BE_U_4(tptr + 4));
572  /* XXX: need to decode Message? */
573  break;
574  default:
575  /* XXX this is dirty but we do not get the
576  * original pointer passed to the begin
577  * the PPP packet */
578  if (ndo->ndo_vflag <= 1)
579  print_unknown_data(ndo, pptr - 2, "\n\t ", length + 2);
580  break;
581  }
582  return;
583 
584 trunc:
585  ND_PRINT("[|%s]", typestr);
586 }
587 
588 /* LCP config options */
589 static u_int
591  const u_char *p, u_int length)
592 {
593  u_int opt, len;
594 
595  if (length < 2)
596  return 0;
597  ND_TCHECK_2(p);
598  opt = GET_U_1(p);
599  len = GET_U_1(p + 1);
600  if (length < len)
601  return 0;
602  if (len < 2) {
603  if (opt < NUM_LCPOPTS)
604  ND_PRINT("\n\t %s Option (0x%02x), length %u (length bogus, should be >= 2)",
605  lcpconfopts[opt], opt, len);
606  else
607  ND_PRINT("\n\tunknown LCP option 0x%02x", opt);
608  return 0;
609  }
610  if (opt < NUM_LCPOPTS)
611  ND_PRINT("\n\t %s Option (0x%02x), length %u", lcpconfopts[opt], opt, len);
612  else {
613  ND_PRINT("\n\tunknown LCP option 0x%02x", opt);
614  return len;
615  }
616 
617  switch (opt) {
618  case LCPOPT_VEXT:
619  if (len < 6) {
620  ND_PRINT(" (length bogus, should be >= 6)");
621  return len;
622  }
623  ND_PRINT(": Vendor: %s (%u)",
624  tok2str(oui_values,"Unknown",GET_BE_U_3(p + 2)),
625  GET_BE_U_3(p + 2));
626 #if 0
627  ND_PRINT(", kind: 0x%02x", GET_U_1(p + 5));
628  ND_PRINT(", Value: 0x");
629  for (i = 0; i < len - 6; i++) {
630  ND_PRINT("%02x", GET_U_1(p + 6 + i));
631  }
632 #endif
633  break;
634  case LCPOPT_MRU:
635  if (len != 4) {
636  ND_PRINT(" (length bogus, should be = 4)");
637  return len;
638  }
639  ND_PRINT(": %u", GET_BE_U_2(p + 2));
640  break;
641  case LCPOPT_ACCM:
642  if (len != 6) {
643  ND_PRINT(" (length bogus, should be = 6)");
644  return len;
645  }
646  ND_PRINT(": 0x%08x", GET_BE_U_4(p + 2));
647  break;
648  case LCPOPT_AP:
649  if (len < 4) {
650  ND_PRINT(" (length bogus, should be >= 4)");
651  return len;
652  }
653  ND_PRINT(": %s",
654  tok2str(ppptype2str, "Unknown Auth Proto (0x04x)", GET_BE_U_2(p + 2)));
655 
656  switch (GET_BE_U_2(p + 2)) {
657  case PPP_CHAP:
658  ND_PRINT(", %s",
659  tok2str(authalg_values, "Unknown Auth Alg %u", GET_U_1(p + 4)));
660  break;
661  case PPP_PAP: /* fall through */
662  case PPP_EAP:
663  case PPP_SPAP:
664  case PPP_SPAP_OLD:
665  break;
666  default:
667  print_unknown_data(ndo, p, "\n\t", len);
668  }
669  break;
670  case LCPOPT_QP:
671  if (len < 4) {
672  ND_PRINT(" (length bogus, should be >= 4)");
673  return 0;
674  }
675  if (GET_BE_U_2(p + 2) == PPP_LQM)
676  ND_PRINT(": LQR");
677  else
678  ND_PRINT(": unknown");
679  break;
680  case LCPOPT_MN:
681  if (len != 6) {
682  ND_PRINT(" (length bogus, should be = 6)");
683  return 0;
684  }
685  ND_PRINT(": 0x%08x", GET_BE_U_4(p + 2));
686  break;
687  case LCPOPT_PFC:
688  break;
689  case LCPOPT_ACFC:
690  break;
691  case LCPOPT_LD:
692  if (len != 4) {
693  ND_PRINT(" (length bogus, should be = 4)");
694  return 0;
695  }
696  ND_PRINT(": 0x%04x", GET_BE_U_2(p + 2));
697  break;
698  case LCPOPT_CBACK:
699  if (len < 3) {
700  ND_PRINT(" (length bogus, should be >= 3)");
701  return 0;
702  }
703  ND_PRINT(": ");
704  ND_PRINT(": Callback Operation %s (%u)",
705  tok2str(ppp_callback_values, "Unknown", GET_U_1(p + 2)),
706  GET_U_1(p + 2));
707  break;
708  case LCPOPT_MLMRRU:
709  if (len != 4) {
710  ND_PRINT(" (length bogus, should be = 4)");
711  return 0;
712  }
713  ND_PRINT(": %u", GET_BE_U_2(p + 2));
714  break;
715  case LCPOPT_MLED:
716  if (len < 3) {
717  ND_PRINT(" (length bogus, should be >= 3)");
718  return 0;
719  }
720  switch (GET_U_1(p + 2)) { /* class */
721  case MEDCLASS_NULL:
722  ND_PRINT(": Null");
723  break;
724  case MEDCLASS_LOCAL:
725  ND_PRINT(": Local"); /* XXX */
726  break;
727  case MEDCLASS_IPV4:
728  if (len != 7) {
729  ND_PRINT(" (length bogus, should be = 7)");
730  return 0;
731  }
732  ND_PRINT(": IPv4 %s", GET_IPADDR_STRING(p + 3));
733  break;
734  case MEDCLASS_MAC:
735  if (len != 9) {
736  ND_PRINT(" (length bogus, should be = 9)");
737  return 0;
738  }
739  ND_PRINT(": MAC %s", GET_ETHERADDR_STRING(p + 3));
740  break;
741  case MEDCLASS_MNB:
742  ND_PRINT(": Magic-Num-Block"); /* XXX */
743  break;
744  case MEDCLASS_PSNDN:
745  ND_PRINT(": PSNDN"); /* XXX */
746  break;
747  default:
748  ND_PRINT(": Unknown class %u", GET_U_1(p + 2));
749  break;
750  }
751  break;
752 
753 /* XXX: to be supported */
754 #if 0
755  case LCPOPT_DEP6:
756  case LCPOPT_FCSALT:
757  case LCPOPT_SDP:
758  case LCPOPT_NUMMODE:
759  case LCPOPT_DEP12:
760  case LCPOPT_DEP14:
761  case LCPOPT_DEP15:
762  case LCPOPT_DEP16:
763  case LCPOPT_MLSSNHF:
764  case LCPOPT_PROP:
765  case LCPOPT_DCEID:
766  case LCPOPT_MPP:
767  case LCPOPT_LCPAOPT:
768  case LCPOPT_COBS:
769  case LCPOPT_PE:
770  case LCPOPT_MLHF:
771  case LCPOPT_I18N:
772  case LCPOPT_SDLOS:
773  case LCPOPT_PPPMUX:
774  break;
775 #endif
776  default:
777  /*
778  * Unknown option; dump it as raw bytes now if we're
779  * not going to do so below.
780  */
781  if (ndo->ndo_vflag < 2)
782  print_unknown_data(ndo, p + 2, "\n\t ", len - 2);
783  break;
784  }
785 
786  if (ndo->ndo_vflag > 1)
787  print_unknown_data(ndo, p + 2, "\n\t ", len - 2); /* exclude TLV header */
788 
789  return len;
790 
791 trunc:
792  ND_PRINT("[|lcp]");
793  return 0;
794 }
795 
796 /* ML-PPP*/
797 static const struct tok ppp_ml_flag_values[] = {
798  { 0x80, "begin" },
799  { 0x40, "end" },
800  { 0, NULL }
801 };
802 
803 static void
805  const u_char *p, u_int length)
806 {
807  if (!ndo->ndo_eflag)
808  ND_PRINT("MLPPP, ");
809 
810  if (length < 2) {
811  ND_PRINT("[|mlppp]");
812  return;
813  }
814  if (!ND_TTEST_2(p)) {
815  ND_PRINT("[|mlppp]");
816  return;
817  }
818 
819  ND_PRINT("seq 0x%03x, Flags [%s], length %u",
820  (GET_BE_U_2(p))&0x0fff,
821  /* only support 12-Bit sequence space for now */
822  bittok2str(ppp_ml_flag_values, "none", GET_U_1(p) & 0xc0),
823  length);
824 }
825 
826 /* CHAP */
827 static void
829  const u_char *p, u_int length)
830 {
831  u_int code, len;
832  u_int val_size, name_size, msg_size;
833  const u_char *p0;
834  u_int i;
835 
836  p0 = p;
837  if (length < 1) {
838  ND_PRINT("[|chap]");
839  return;
840  } else if (length < 4) {
841  ND_PRINT("[|chap 0x%02x]", GET_U_1(p));
842  return;
843  }
844 
845  code = GET_U_1(p);
846  ND_PRINT("CHAP, %s (0x%02x)",
847  tok2str(chapcode_values,"unknown",code),
848  code);
849  p++;
850 
851  ND_PRINT(", id %u", GET_U_1(p)); /* ID */
852  p++;
853 
854  len = GET_BE_U_2(p);
855  p += 2;
856 
857  /*
858  * Note that this is a generic CHAP decoding routine. Since we
859  * don't know which flavor of CHAP (i.e. CHAP-MD5, MS-CHAPv1,
860  * MS-CHAPv2) is used at this point, we can't decode packet
861  * specifically to each algorithms. Instead, we simply decode
862  * the GCD (Gratest Common Denominator) for all algorithms.
863  */
864  switch (code) {
865  case CHAP_CHAL:
866  case CHAP_RESP:
867  if (length - (p - p0) < 1)
868  return;
869  val_size = GET_U_1(p); /* value size */
870  p++;
871  if (length - (p - p0) < val_size)
872  return;
873  ND_PRINT(", Value ");
874  for (i = 0; i < val_size; i++) {
875  ND_PRINT("%02x", GET_U_1(p));
876  p++;
877  }
878  name_size = len - (u_int)(p - p0);
879  ND_PRINT(", Name ");
880  for (i = 0; i < name_size; i++) {
881  fn_print_char(ndo, GET_U_1(p));
882  p++;
883  }
884  break;
885  case CHAP_SUCC:
886  case CHAP_FAIL:
887  msg_size = len - (u_int)(p - p0);
888  ND_PRINT(", Msg ");
889  for (i = 0; i< msg_size; i++) {
890  fn_print_char(ndo, GET_U_1(p));
891  p++;
892  }
893  break;
894  }
895 }
896 
897 /* PAP (see RFC 1334) */
898 static void
900  const u_char *p, u_int length)
901 {
902  u_int code, len;
903  u_int peerid_len, passwd_len, msg_len;
904  const u_char *p0;
905  u_int i;
906 
907  p0 = p;
908  if (length < 1) {
909  ND_PRINT("[|pap]");
910  return;
911  } else if (length < 4) {
912  ND_PRINT("[|pap 0x%02x]", GET_U_1(p));
913  return;
914  }
915 
916  code = GET_U_1(p);
917  ND_PRINT("PAP, %s (0x%02x)",
918  tok2str(papcode_values, "unknown", code),
919  code);
920  p++;
921 
922  ND_PRINT(", id %u", GET_U_1(p)); /* ID */
923  p++;
924 
925  len = GET_BE_U_2(p);
926  p += 2;
927 
928  if (len > length) {
929  ND_PRINT(", length %u > packet size", len);
930  return;
931  }
932  length = len;
933  if (length < (size_t)(p - p0)) {
934  ND_PRINT(", length %u < PAP header length", length);
935  return;
936  }
937 
938  switch (code) {
939  case PAP_AREQ:
940  /* A valid Authenticate-Request is 6 or more octets long. */
941  if (len < 6)
942  goto trunc;
943  if (length - (p - p0) < 1)
944  return;
945  peerid_len = GET_U_1(p); /* Peer-ID Length */
946  p++;
947  if (length - (p - p0) < peerid_len)
948  return;
949  ND_PRINT(", Peer ");
950  for (i = 0; i < peerid_len; i++) {
951  fn_print_char(ndo, GET_U_1(p));
952  p++;
953  }
954 
955  if (length - (p - p0) < 1)
956  return;
957  passwd_len = GET_U_1(p); /* Password Length */
958  p++;
959  if (length - (p - p0) < passwd_len)
960  return;
961  ND_PRINT(", Name ");
962  for (i = 0; i < passwd_len; i++) {
963  fn_print_char(ndo, GET_U_1(p));
964  p++;
965  }
966  break;
967  case PAP_AACK:
968  case PAP_ANAK:
969  /* Although some implementations ignore truncation at
970  * this point and at least one generates a truncated
971  * packet, RFC 1334 section 2.2.2 clearly states that
972  * both AACK and ANAK are at least 5 bytes long.
973  */
974  if (len < 5)
975  goto trunc;
976  if (length - (p - p0) < 1)
977  return;
978  msg_len = GET_U_1(p); /* Msg-Length */
979  p++;
980  if (length - (p - p0) < msg_len)
981  return;
982  ND_PRINT(", Msg ");
983  for (i = 0; i< msg_len; i++) {
984  fn_print_char(ndo, GET_U_1(p));
985  p++;
986  }
987  break;
988  }
989  return;
990 
991 trunc:
992  ND_PRINT("[|pap]");
993 }
994 
995 /* BAP */
996 static void
998  const u_char *p _U_, u_int length _U_)
999 {
1000  /* XXX: to be supported!! */
1001 }
1002 
1003 
1004 /* IPCP config options */
1005 static u_int
1007  const u_char *p, u_int length)
1008 {
1009  u_int opt, len;
1010  u_int compproto, ipcomp_subopttotallen, ipcomp_subopt, ipcomp_suboptlen;
1011 
1012  if (length < 2)
1013  return 0;
1014  ND_TCHECK_2(p);
1015  opt = GET_U_1(p);
1016  len = GET_U_1(p + 1);
1017  if (length < len)
1018  return 0;
1019  if (len < 2) {
1020  ND_PRINT("\n\t %s Option (0x%02x), length %u (length bogus, should be >= 2)",
1021  tok2str(ipcpopt_values,"unknown",opt),
1022  opt,
1023  len);
1024  return 0;
1025  }
1026 
1027  ND_PRINT("\n\t %s Option (0x%02x), length %u",
1028  tok2str(ipcpopt_values,"unknown",opt),
1029  opt,
1030  len);
1031 
1032  switch (opt) {
1033  case IPCPOPT_2ADDR: /* deprecated */
1034  if (len != 10) {
1035  ND_PRINT(" (length bogus, should be = 10)");
1036  return len;
1037  }
1038  ND_PRINT(": src %s, dst %s",
1039  GET_IPADDR_STRING(p + 2),
1040  GET_IPADDR_STRING(p + 6));
1041  break;
1042  case IPCPOPT_IPCOMP:
1043  if (len < 4) {
1044  ND_PRINT(" (length bogus, should be >= 4)");
1045  return 0;
1046  }
1047  compproto = GET_BE_U_2(p + 2);
1048 
1049  ND_PRINT(": %s (0x%02x):",
1050  tok2str(ipcpopt_compproto_values, "Unknown", compproto),
1051  compproto);
1052 
1053  switch (compproto) {
1054  case PPP_VJC:
1055  /* XXX: VJ-Comp parameters should be decoded */
1056  break;
1058  if (len < IPCPOPT_IPCOMP_MINLEN) {
1059  ND_PRINT(" (length bogus, should be >= %u)",
1061  return 0;
1062  }
1063 
1065  ND_PRINT("\n\t TCP Space %u, non-TCP Space %u"
1066  ", maxPeriod %u, maxTime %u, maxHdr %u",
1067  GET_BE_U_2(p + 4),
1068  GET_BE_U_2(p + 6),
1069  GET_BE_U_2(p + 8),
1070  GET_BE_U_2(p + 10),
1071  GET_BE_U_2(p + 12));
1072 
1073  /* suboptions present ? */
1074  if (len > IPCPOPT_IPCOMP_MINLEN) {
1075  ipcomp_subopttotallen = len - IPCPOPT_IPCOMP_MINLEN;
1076  p += IPCPOPT_IPCOMP_MINLEN;
1077 
1078  ND_PRINT("\n\t Suboptions, length %u", ipcomp_subopttotallen);
1079 
1080  while (ipcomp_subopttotallen >= 2) {
1081  ND_TCHECK_2(p);
1082  ipcomp_subopt = GET_U_1(p);
1083  ipcomp_suboptlen = GET_U_1(p + 1);
1084 
1085  /* sanity check */
1086  if (ipcomp_subopt == 0 ||
1087  ipcomp_suboptlen == 0 )
1088  break;
1089 
1090  /* XXX: just display the suboptions for now */
1091  ND_PRINT("\n\t\t%s Suboption #%u, length %u",
1093  "Unknown",
1094  ipcomp_subopt),
1095  ipcomp_subopt,
1096  ipcomp_suboptlen);
1097  if (ipcomp_subopttotallen < ipcomp_suboptlen) {
1098  ND_PRINT(" [remaining suboptions length %u < %u]",
1099  ipcomp_subopttotallen, ipcomp_suboptlen);
1100  nd_print_invalid(ndo);
1101  break;
1102  }
1103  ipcomp_subopttotallen -= ipcomp_suboptlen;
1104  p += ipcomp_suboptlen;
1105  }
1106  }
1107  break;
1108  default:
1109  break;
1110  }
1111  break;
1112 
1113  case IPCPOPT_ADDR: /* those options share the same format - fall through */
1114  case IPCPOPT_MOBILE4:
1115  case IPCPOPT_PRIDNS:
1116  case IPCPOPT_PRINBNS:
1117  case IPCPOPT_SECDNS:
1118  case IPCPOPT_SECNBNS:
1119  if (len != 6) {
1120  ND_PRINT(" (length bogus, should be = 6)");
1121  return 0;
1122  }
1123  ND_PRINT(": %s", GET_IPADDR_STRING(p + 2));
1124  break;
1125  default:
1126  /*
1127  * Unknown option; dump it as raw bytes now if we're
1128  * not going to do so below.
1129  */
1130  if (ndo->ndo_vflag < 2)
1131  print_unknown_data(ndo, p + 2, "\n\t ", len - 2);
1132  break;
1133  }
1134  if (ndo->ndo_vflag > 1)
1135  print_unknown_data(ndo, p + 2, "\n\t ", len - 2); /* exclude TLV header */
1136  return len;
1137 
1138 trunc:
1139  ND_PRINT("[|ipcp]");
1140  return 0;
1141 }
1142 
1143 /* IP6CP config options */
1144 static u_int
1146  const u_char *p, u_int length)
1147 {
1148  u_int opt, len;
1149 
1150  if (length < 2)
1151  return 0;
1152  ND_TCHECK_2(p);
1153  opt = GET_U_1(p);
1154  len = GET_U_1(p + 1);
1155  if (length < len)
1156  return 0;
1157  if (len < 2) {
1158  ND_PRINT("\n\t %s Option (0x%02x), length %u (length bogus, should be >= 2)",
1159  tok2str(ip6cpopt_values,"unknown",opt),
1160  opt,
1161  len);
1162  return 0;
1163  }
1164 
1165  ND_PRINT("\n\t %s Option (0x%02x), length %u",
1166  tok2str(ip6cpopt_values,"unknown",opt),
1167  opt,
1168  len);
1169 
1170  switch (opt) {
1171  case IP6CP_IFID:
1172  if (len != 10) {
1173  ND_PRINT(" (length bogus, should be = 10)");
1174  return len;
1175  }
1176  ND_TCHECK_8(p + 2);
1177  ND_PRINT(": %04x:%04x:%04x:%04x",
1178  GET_BE_U_2(p + 2),
1179  GET_BE_U_2(p + 4),
1180  GET_BE_U_2(p + 6),
1181  GET_BE_U_2(p + 8));
1182  break;
1183  default:
1184  /*
1185  * Unknown option; dump it as raw bytes now if we're
1186  * not going to do so below.
1187  */
1188  if (ndo->ndo_vflag < 2)
1189  print_unknown_data(ndo, p + 2, "\n\t ", len - 2);
1190  break;
1191  }
1192  if (ndo->ndo_vflag > 1)
1193  print_unknown_data(ndo, p + 2, "\n\t ", len - 2); /* exclude TLV header */
1194 
1195  return len;
1196 
1197 trunc:
1198  ND_PRINT("[|ip6cp]");
1199  return 0;
1200 }
1201 
1202 
1203 /* CCP config options */
1204 static u_int
1206  const u_char *p, u_int length)
1207 {
1208  u_int opt, len;
1209 
1210  if (length < 2)
1211  return 0;
1212  ND_TCHECK_2(p);
1213  opt = GET_U_1(p);
1214  len = GET_U_1(p + 1);
1215  if (length < len)
1216  return 0;
1217  if (len < 2) {
1218  ND_PRINT("\n\t %s Option (0x%02x), length %u (length bogus, should be >= 2)",
1219  tok2str(ccpconfopts_values, "Unknown", opt),
1220  opt,
1221  len);
1222  return 0;
1223  }
1224 
1225  ND_PRINT("\n\t %s Option (0x%02x), length %u",
1226  tok2str(ccpconfopts_values, "Unknown", opt),
1227  opt,
1228  len);
1229 
1230  switch (opt) {
1231  case CCPOPT_BSDCOMP:
1232  if (len < 3) {
1233  ND_PRINT(" (length bogus, should be >= 3)");
1234  return len;
1235  }
1236  ND_PRINT(": Version: %u, Dictionary Bits: %u",
1237  GET_U_1(p + 2) >> 5,
1238  GET_U_1(p + 2) & 0x1f);
1239  break;
1240  case CCPOPT_MVRCA:
1241  if (len < 4) {
1242  ND_PRINT(" (length bogus, should be >= 4)");
1243  return len;
1244  }
1245  ND_PRINT(": Features: %u, PxP: %s, History: %u, #CTX-ID: %u",
1246  (GET_U_1(p + 2) & 0xc0) >> 6,
1247  (GET_U_1(p + 2) & 0x20) ? "Enabled" : "Disabled",
1248  GET_U_1(p + 2) & 0x1f,
1249  GET_U_1(p + 3));
1250  break;
1251  case CCPOPT_DEFLATE:
1252  if (len < 4) {
1253  ND_PRINT(" (length bogus, should be >= 4)");
1254  return len;
1255  }
1256  ND_PRINT(": Window: %uK, Method: %s (0x%x), MBZ: %u, CHK: %u",
1257  (GET_U_1(p + 2) & 0xf0) >> 4,
1258  ((GET_U_1(p + 2) & 0x0f) == 8) ? "zlib" : "unknown",
1259  GET_U_1(p + 2) & 0x0f,
1260  (GET_U_1(p + 3) & 0xfc) >> 2,
1261  GET_U_1(p + 3) & 0x03);
1262  break;
1263 
1264 /* XXX: to be supported */
1265 #if 0
1266  case CCPOPT_OUI:
1267  case CCPOPT_PRED1:
1268  case CCPOPT_PRED2:
1269  case CCPOPT_PJUMP:
1270  case CCPOPT_HPPPC:
1271  case CCPOPT_STACLZS:
1272  case CCPOPT_MPPC:
1273  case CCPOPT_GFZA:
1274  case CCPOPT_V42BIS:
1275  case CCPOPT_LZSDCP:
1276  case CCPOPT_DEC:
1277  case CCPOPT_RESV:
1278  break;
1279 #endif
1280  default:
1281  /*
1282  * Unknown option; dump it as raw bytes now if we're
1283  * not going to do so below.
1284  */
1285  if (ndo->ndo_vflag < 2)
1286  print_unknown_data(ndo, p + 2, "\n\t ", len - 2);
1287  break;
1288  }
1289  if (ndo->ndo_vflag > 1)
1290  print_unknown_data(ndo, p + 2, "\n\t ", len - 2); /* exclude TLV header */
1291 
1292  return len;
1293 
1294 trunc:
1295  ND_PRINT("[|ccp]");
1296  return 0;
1297 }
1298 
1299 /* BACP config options */
1300 static u_int
1302  const u_char *p, u_int length)
1303 {
1304  u_int opt, len;
1305 
1306  if (length < 2)
1307  return 0;
1308  ND_TCHECK_2(p);
1309  opt = GET_U_1(p);
1310  len = GET_U_1(p + 1);
1311  if (length < len)
1312  return 0;
1313  if (len < 2) {
1314  ND_PRINT("\n\t %s Option (0x%02x), length %u (length bogus, should be >= 2)",
1315  tok2str(bacconfopts_values, "Unknown", opt),
1316  opt,
1317  len);
1318  return 0;
1319  }
1320 
1321  ND_PRINT("\n\t %s Option (0x%02x), length %u",
1322  tok2str(bacconfopts_values, "Unknown", opt),
1323  opt,
1324  len);
1325 
1326  switch (opt) {
1327  case BACPOPT_FPEER:
1328  if (len != 6) {
1329  ND_PRINT(" (length bogus, should be = 6)");
1330  return len;
1331  }
1332  ND_PRINT(": Magic-Num 0x%08x", GET_BE_U_4(p + 2));
1333  break;
1334  default:
1335  /*
1336  * Unknown option; dump it as raw bytes now if we're
1337  * not going to do so below.
1338  */
1339  if (ndo->ndo_vflag < 2)
1340  print_unknown_data(ndo, p + 2, "\n\t ", len - 2);
1341  break;
1342  }
1343  if (ndo->ndo_vflag > 1)
1344  print_unknown_data(ndo, p + 2, "\n\t ", len - 2); /* exclude TLV header */
1345 
1346  return len;
1347 
1348 trunc:
1349  ND_PRINT("[|bacp]");
1350  return 0;
1351 }
1352 
1353 /*
1354  * Un-escape RFC 1662 PPP in HDLC-like framing, with octet escapes.
1355  * The length argument is the on-the-wire length, not the captured
1356  * length; we can only un-escape the captured part.
1357  */
1358 static void
1360  const u_char *p, u_int length)
1361 {
1362  u_int caplen = ND_BYTES_AVAILABLE_AFTER(p);
1363  u_char *b, *t, c;
1364  const u_char *s;
1365  u_int i, proto;
1366  const void *se;
1367 
1368  if (caplen == 0)
1369  return;
1370 
1371  if (length == 0)
1372  return;
1373 
1374  b = (u_char *)nd_malloc(ndo, caplen);
1375  if (b == NULL)
1376  return;
1377 
1378  /*
1379  * Unescape all the data into a temporary, private, buffer.
1380  * Do this so that we don't overwrite the original packet
1381  * contents.
1382  */
1383  for (s = p, t = b, i = caplen; i != 0; i--) {
1384  c = GET_U_1(s);
1385  s++;
1386  if (c == 0x7d) {
1387  if (i <= 1)
1388  break;
1389  i--;
1390  c = GET_U_1(s) ^ 0x20;
1391  s++;
1392  }
1393  *t++ = c;
1394  }
1395 
1396  /*
1397  * Change the end pointer, so bounds checks work.
1398  */
1399  se = ndo->ndo_snapend;
1400  ndo->ndo_snapend = t;
1401  length = ND_BYTES_AVAILABLE_AFTER(b);
1402 
1403  /* now lets guess about the payload codepoint format */
1404  if (length < 1)
1405  goto trunc;
1406  proto = GET_U_1(b); /* start with a one-octet codepoint guess */
1407 
1408  switch (proto) {
1409  case PPP_IP:
1410  ip_print(ndo, b + 1, length - 1);
1411  goto cleanup;
1412  case PPP_IPV6:
1413  ip6_print(ndo, b + 1, length - 1);
1414  goto cleanup;
1415  default: /* no luck - try next guess */
1416  break;
1417  }
1418 
1419  if (length < 2)
1420  goto trunc;
1421  proto = GET_BE_U_2(b); /* next guess - load two octets */
1422 
1423  switch (proto) {
1424  case (PPP_ADDRESS << 8 | PPP_CONTROL): /* looks like a PPP frame */
1425  if (length < 4)
1426  goto trunc;
1427  proto = GET_BE_U_2(b + 2); /* load the PPP proto-id */
1428  handle_ppp(ndo, proto, b + 4, length - 4);
1429  break;
1430  default: /* last guess - proto must be a PPP proto-id */
1431  handle_ppp(ndo, proto, b + 2, length - 2);
1432  break;
1433  }
1434 
1435 cleanup:
1436  ndo->ndo_snapend = se;
1437  return;
1438 
1439 trunc:
1440  ndo->ndo_snapend = se;
1441  nd_print_trunc(ndo);
1442 }
1443 
1444 
1445 /* PPP */
1446 static void
1448  u_int proto, const u_char *p, u_int length)
1449 {
1450  if ((proto & 0xff00) == 0x7e00) { /* is this an escape code ? */
1451  ppp_hdlc(ndo, p - 1, length);
1452  return;
1453  }
1454 
1455  switch (proto) {
1456  case PPP_LCP: /* fall through */
1457  case PPP_IPCP:
1458  case PPP_OSICP:
1459  case PPP_MPLSCP:
1460  case PPP_IPV6CP:
1461  case PPP_CCP:
1462  case PPP_BACP:
1463  handle_ctrl_proto(ndo, proto, p, length);
1464  break;
1465  case PPP_ML:
1466  handle_mlppp(ndo, p, length);
1467  break;
1468  case PPP_CHAP:
1469  handle_chap(ndo, p, length);
1470  break;
1471  case PPP_PAP:
1472  handle_pap(ndo, p, length);
1473  break;
1474  case PPP_BAP: /* XXX: not yet completed */
1475  handle_bap(ndo, p, length);
1476  break;
1477  case ETHERTYPE_IP: /*XXX*/
1478  case PPP_VJNC:
1479  case PPP_IP:
1480  ip_print(ndo, p, length);
1481  break;
1482  case ETHERTYPE_IPV6: /*XXX*/
1483  case PPP_IPV6:
1484  ip6_print(ndo, p, length);
1485  break;
1486  case ETHERTYPE_IPX: /*XXX*/
1487  case PPP_IPX:
1488  ipx_print(ndo, p, length);
1489  break;
1490  case PPP_OSI:
1491  isoclns_print(ndo, p, length);
1492  break;
1493  case PPP_MPLS_UCAST:
1494  case PPP_MPLS_MCAST:
1495  mpls_print(ndo, p, length);
1496  break;
1497  case PPP_COMP:
1498  ND_PRINT("compressed PPP data");
1499  break;
1500  default:
1501  ND_PRINT("%s ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", proto));
1502  print_unknown_data(ndo, p, "\n\t", length);
1503  break;
1504  }
1505 }
1506 
1507 /* Standard PPP printer */
1508 u_int
1510  const u_char *p, u_int length)
1511 {
1512  u_int proto,ppp_header;
1513  u_int olen = length; /* _o_riginal length */
1514  u_int hdr_len = 0;
1515 
1516  ndo->ndo_protocol = "ppp";
1517  /*
1518  * Here, we assume that p points to the Address and Control
1519  * field (if they present).
1520  */
1521  if (length < 2)
1522  goto trunc;
1523  ppp_header = GET_BE_U_2(p);
1524 
1525  switch(ppp_header) {
1526  case (PPP_PPPD_IN << 8 | PPP_CONTROL):
1527  if (ndo->ndo_eflag) ND_PRINT("In ");
1528  p += 2;
1529  length -= 2;
1530  hdr_len += 2;
1531  break;
1532  case (PPP_PPPD_OUT << 8 | PPP_CONTROL):
1533  if (ndo->ndo_eflag) ND_PRINT("Out ");
1534  p += 2;
1535  length -= 2;
1536  hdr_len += 2;
1537  break;
1538  case (PPP_ADDRESS << 8 | PPP_CONTROL):
1539  p += 2; /* ACFC not used */
1540  length -= 2;
1541  hdr_len += 2;
1542  break;
1543 
1544  default:
1545  break;
1546  }
1547 
1548  if (length < 2)
1549  goto trunc;
1550  if (GET_U_1(p) % 2) {
1551  proto = GET_U_1(p); /* PFC is used */
1552  p++;
1553  length--;
1554  hdr_len++;
1555  } else {
1556  proto = GET_BE_U_2(p);
1557  p += 2;
1558  length -= 2;
1559  hdr_len += 2;
1560  }
1561 
1562  if (ndo->ndo_eflag)
1563  ND_PRINT("%s (0x%04x), length %u: ",
1564  tok2str(ppptype2str, "unknown", proto),
1565  proto,
1566  olen);
1567 
1568  handle_ppp(ndo, proto, p, length);
1569  return (hdr_len);
1570 trunc:
1571  nd_print_trunc(ndo);
1572  return (0);
1573 }
1574 
1575 
1576 /* PPP I/F printer */
1577 void
1579  const struct pcap_pkthdr *h, const u_char *p)
1580 {
1581  u_int length = h->len;
1582  u_int caplen = h->caplen;
1583 
1584  ndo->ndo_protocol = "ppp";
1585  if (caplen < PPP_HDRLEN) {
1586  nd_print_trunc(ndo);
1587  ndo->ndo_ll_hdr_len += caplen;
1588  return;
1589  }
1590  ndo->ndo_ll_hdr_len += PPP_HDRLEN;
1591 
1592 #if 0
1593  /*
1594  * XXX: seems to assume that there are 2 octets prepended to an
1595  * actual PPP frame. The 1st octet looks like Input/Output flag
1596  * while 2nd octet is unknown, at least to me
1597  * (mshindo@mshindo.net).
1598  *
1599  * That was what the original tcpdump code did.
1600  *
1601  * FreeBSD's "if_ppp.c" *does* set the first octet to 1 for outbound
1602  * packets and 0 for inbound packets - but only if the
1603  * protocol field has the 0x8000 bit set (i.e., it's a network
1604  * control protocol); it does so before running the packet through
1605  * "bpf_filter" to see if it should be discarded, and to see
1606  * if we should update the time we sent the most recent packet...
1607  *
1608  * ...but it puts the original address field back after doing
1609  * so.
1610  *
1611  * NetBSD's "if_ppp.c" doesn't set the first octet in that fashion.
1612  *
1613  * I don't know if any PPP implementation handed up to a BPF
1614  * device packets with the first octet being 1 for outbound and
1615  * 0 for inbound packets, so I (guy@alum.mit.edu) don't know
1616  * whether that ever needs to be checked or not.
1617  *
1618  * Note that NetBSD has a DLT_PPP_SERIAL, which it uses for PPP,
1619  * and its tcpdump appears to assume that the frame always
1620  * begins with an address field and a control field, and that
1621  * the address field might be 0x0f or 0x8f, for Cisco
1622  * point-to-point with HDLC framing as per section 4.3.1 of RFC
1623  * 1547, as well as 0xff, for PPP in HDLC-like framing as per
1624  * RFC 1662.
1625  *
1626  * (Is the Cisco framing in question what DLT_C_HDLC, in
1627  * BSD/OS, is?)
1628  */
1629  if (ndo->ndo_eflag)
1630  ND_PRINT("%c %4d %02x ", GET_U_1(p) ? 'O' : 'I',
1631  length, GET_U_1(p + 1));
1632 #endif
1633 
1634  ppp_print(ndo, p, length);
1635 }
1636 
1637 /*
1638  * PPP I/F printer to use if we know that RFC 1662-style PPP in HDLC-like
1639  * framing, or Cisco PPP with HDLC framing as per section 4.3.1 of RFC 1547,
1640  * is being used (i.e., we don't check for PPP_ADDRESS and PPP_CONTROL,
1641  * discard them *if* those are the first two octets, and parse the remaining
1642  * packet as a PPP packet, as "ppp_print()" does).
1643  *
1644  * This handles, for example, DLT_PPP_SERIAL in NetBSD.
1645  */
1646 void
1648  const struct pcap_pkthdr *h, const u_char *p)
1649 {
1650  u_int length = h->len;
1651  u_int caplen = h->caplen;
1652  u_int proto;
1653  u_int hdrlen = 0;
1654 
1655  ndo->ndo_protocol = "ppp_hdlc";
1656  if (caplen < 2) {
1657  nd_print_trunc(ndo);
1658  ndo->ndo_ll_hdr_len += caplen;
1659  return;
1660  }
1661 
1662  switch (GET_U_1(p)) {
1663 
1664  case PPP_ADDRESS:
1665  if (caplen < 4) {
1666  nd_print_trunc(ndo);
1667  ndo->ndo_ll_hdr_len += caplen;
1668  return;
1669  }
1670 
1671  if (ndo->ndo_eflag)
1672  ND_PRINT("%02x %02x %u ", GET_U_1(p),
1673  GET_U_1(p + 1), length);
1674  p += 2;
1675  length -= 2;
1676  hdrlen += 2;
1677 
1678  proto = GET_BE_U_2(p);
1679  p += 2;
1680  length -= 2;
1681  hdrlen += 2;
1682  ND_PRINT("%s: ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", proto));
1683 
1684  handle_ppp(ndo, proto, p, length);
1685  break;
1686 
1687  case CHDLC_UNICAST:
1688  case CHDLC_BCAST:
1689  chdlc_if_print(ndo, h, p);
1690  return;
1691 
1692  default:
1693  if (caplen < 4) {
1694  nd_print_trunc(ndo);
1695  ndo->ndo_ll_hdr_len += caplen;
1696  return;
1697  }
1698 
1699  if (ndo->ndo_eflag)
1700  ND_PRINT("%02x %02x %u ", GET_U_1(p),
1701  GET_U_1(p + 1), length);
1702  p += 2;
1703  hdrlen += 2;
1704 
1705  /*
1706  * XXX - NetBSD's "ppp_netbsd_serial_if_print()" treats
1707  * the next two octets as an Ethernet type; does that
1708  * ever happen?
1709  */
1710  ND_PRINT("unknown addr %02x; ctrl %02x", GET_U_1(p),
1711  GET_U_1(p + 1));
1712  break;
1713  }
1714 
1715  ndo->ndo_ll_hdr_len += hdrlen;
1716 }
1717 
1718 #define PPP_BSDI_HDRLEN 24
1719 
1720 /* BSD/OS specific PPP printer */
1721 void
1723  const struct pcap_pkthdr *h _U_, const u_char *p _U_)
1724 {
1725  u_int hdrlength;
1726 #ifdef __bsdi__
1727  u_int length = h->len;
1728  u_int caplen = h->caplen;
1729  uint16_t ptype;
1730  uint8_t llhl;
1731  const u_char *q;
1732  u_int i;
1733 
1734  ndo->ndo_protocol = "ppp_bsdos";
1735  if (caplen < PPP_BSDI_HDRLEN) {
1736  nd_print_trunc(ndo);
1737  ndo->ndo_ll_hdr_len += caplen;
1738  return;
1739  }
1740 
1741  hdrlength = 0;
1742 
1743 #if 0
1744  if (GET_U_1(p) == PPP_ADDRESS &&
1745  GET_U_1(p + 1) == PPP_CONTROL) {
1746  if (ndo->ndo_eflag)
1747  ND_PRINT("%02x %02x ", GET_U_1(p),
1748  GET_U_1(p + 1));
1749  p += 2;
1750  hdrlength = 2;
1751  }
1752 
1753  if (ndo->ndo_eflag)
1754  ND_PRINT("%u ", length);
1755  /* Retrieve the protocol type */
1756  if (GET_U_1(p) & 01) {
1757  /* Compressed protocol field */
1758  ptype = GET_U_1(p);
1759  if (ndo->ndo_eflag)
1760  ND_PRINT("%02x ", ptype);
1761  p++;
1762  hdrlength += 1;
1763  } else {
1764  /* Un-compressed protocol field */
1765  ptype = GET_BE_U_2(p);
1766  if (ndo->ndo_eflag)
1767  ND_PRINT("%04x ", ptype);
1768  p += 2;
1769  hdrlength += 2;
1770  }
1771 #else
1772  ptype = 0; /*XXX*/
1773  if (ndo->ndo_eflag)
1774  ND_PRINT("%c ", GET_U_1(p + SLC_DIR) ? 'O' : 'I');
1775  llhl = GET_U_1(p + SLC_LLHL);
1776  if (llhl) {
1777  /* link level header */
1778  struct ppp_header *ph;
1779 
1780  q = p + SLC_BPFHDRLEN;
1781  ph = (struct ppp_header *)q;
1782  if (ph->phdr_addr == PPP_ADDRESS
1783  && ph->phdr_ctl == PPP_CONTROL) {
1784  if (ndo->ndo_eflag)
1785  ND_PRINT("%02x %02x ", GET_U_1(q),
1786  GET_U_1(q + 1));
1787  ptype = GET_BE_U_2(&ph->phdr_type);
1788  if (ndo->ndo_eflag && (ptype == PPP_VJC || ptype == PPP_VJNC)) {
1789  ND_PRINT("%s ", tok2str(ppptype2str,
1790  "proto-#%u", ptype));
1791  }
1792  } else {
1793  if (ndo->ndo_eflag) {
1794  ND_PRINT("LLH=[");
1795  for (i = 0; i < llhl; i++)
1796  ND_PRINT("%02x", GET_U_1(q + i));
1797  ND_PRINT("] ");
1798  }
1799  }
1800  }
1801  if (ndo->ndo_eflag)
1802  ND_PRINT("%u ", length);
1803  if (GET_U_1(p + SLC_CHL)) {
1804  q = p + SLC_BPFHDRLEN + llhl;
1805 
1806  switch (ptype) {
1807  case PPP_VJC:
1808  ptype = vjc_print(ndo, q, ptype);
1809  hdrlength = PPP_BSDI_HDRLEN;
1810  p += hdrlength;
1811  switch (ptype) {
1812  case PPP_IP:
1813  ip_print(ndo, p, length);
1814  break;
1815  case PPP_IPV6:
1816  ip6_print(ndo, p, length);
1817  break;
1818  case PPP_MPLS_UCAST:
1819  case PPP_MPLS_MCAST:
1820  mpls_print(ndo, p, length);
1821  break;
1822  }
1823  goto printx;
1824  case PPP_VJNC:
1825  ptype = vjc_print(ndo, q, ptype);
1826  hdrlength = PPP_BSDI_HDRLEN;
1827  p += hdrlength;
1828  switch (ptype) {
1829  case PPP_IP:
1830  ip_print(ndo, p, length);
1831  break;
1832  case PPP_IPV6:
1833  ip6_print(ndo, p, length);
1834  break;
1835  case PPP_MPLS_UCAST:
1836  case PPP_MPLS_MCAST:
1837  mpls_print(ndo, p, length);
1838  break;
1839  }
1840  goto printx;
1841  default:
1842  if (ndo->ndo_eflag) {
1843  ND_PRINT("CH=[");
1844  for (i = 0; i < llhl; i++)
1845  ND_PRINT("%02x",
1846  GET_U_1(q + i));
1847  ND_PRINT("] ");
1848  }
1849  break;
1850  }
1851  }
1852 
1853  hdrlength = PPP_BSDI_HDRLEN;
1854 #endif
1855 
1856  length -= hdrlength;
1857  p += hdrlength;
1858 
1859  switch (ptype) {
1860  case PPP_IP:
1861  ip_print(p, length);
1862  break;
1863  case PPP_IPV6:
1864  ip6_print(ndo, p, length);
1865  break;
1866  case PPP_MPLS_UCAST:
1867  case PPP_MPLS_MCAST:
1868  mpls_print(ndo, p, length);
1869  break;
1870  default:
1871  ND_PRINT("%s ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", ptype));
1872  }
1873 
1874 printx:
1875 #else /* __bsdi */
1876  hdrlength = 0;
1877 #endif /* __bsdi__ */
1878  ndo->ndo_ll_hdr_len += hdrlength;
1879 }
#define GET_IPADDR_STRING(p)
Definition: addrtoname.h:120
#define GET_ETHERADDR_STRING(p)
Definition: addrtoname.h:117
#define CHDLC_UNICAST
Definition: chdlc.h:23
#define CHDLC_BCAST
Definition: chdlc.h:24
#define ETHERTYPE_IPV6
Definition: ethertype.h:135
#define ETHERTYPE_IPX
Definition: ethertype.h:132
#define ETHERTYPE_IP
Definition: ethertype.h:52
#define GET_BE_U_4(p)
Definition: extract.h:877
#define GET_BE_U_3(p)
Definition: extract.h:876
#define GET_BE_U_2(p)
Definition: extract.h:875
#define ND_TCHECK_2(p)
Definition: extract.h:555
#define ND_TCHECK_8(p)
Definition: extract.h:573
#define ND_TTEST_2(p)
Definition: extract.h:554
#define GET_U_1(p)
Definition: extract.h:872
void * nd_malloc(netdissect_options *ndo, size_t size)
int vjc_print(netdissect_options *, const u_char *, u_short)
Definition: print-vjc.c:87
void ip6_print(netdissect_options *, const u_char *, u_int)
Definition: print-ip6.c:226
void fn_print_char(netdissect_options *, u_char)
Definition: util-print.c:70
int print_unknown_data(netdissect_options *, const u_char *, const char *, u_int)
Definition: util-print.c:441
#define ND_TCHECK_LEN(p, l)
Definition: netdissect.h:368
const char * tok2str(const struct tok *, const char *, u_int)
Definition: util-print.c:485
void mpls_print(netdissect_options *, const u_char *, u_int)
Definition: print-mpls.c:61
void isoclns_print(netdissect_options *, const u_char *, u_int)
char * bittok2str(const struct tok *, const char *, u_int)
Definition: util-print.c:558
void nd_print_invalid(netdissect_options *)
Definition: util-print.c:429
void nd_print_trunc(netdissect_options *)
Definition: util-print.c:409
void ip_print(netdissect_options *, const u_char *, u_int)
Definition: print-ip.c:319
#define ND_PRINT(...)
Definition: netdissect.h:385
int nd_printn(netdissect_options *, const u_char *, u_int, const u_char *)
Definition: util-print.c:160
void chdlc_if_print(netdissect_options *, const struct pcap_pkthdr *, const u_char *)
Definition: print-chdlc.c:48
void ipx_print(netdissect_options *, const u_char *, u_int)
Definition: print-ipx.c:73
#define ND_BYTES_AVAILABLE_AFTER(p)
Definition: netdissect.h:383
const struct tok oui_values[]
Definition: oui.c:26
#define PPP_SPAP_OLD
Definition: ppp.h:67
#define PPP_VINESCP
Definition: ppp.h:54
#define PPP_COMP
Definition: ppp.h:39
#define PPP_VINES
Definition: ppp.h:36
#define PPP_SPAP
Definition: ppp.h:62
#define PPP_ML
Definition: ppp.h:37
#define PPP_SNS
Definition: ppp.h:43
#define PPP_IPV6CP
Definition: ppp.h:55
#define PPP_IPXCP
Definition: ppp.h:52
#define PPP_APPLECP
Definition: ppp.h:51
#define PPP_IP
Definition: ppp.h:26
#define PPP_OSI
Definition: ppp.h:27
#define PPP_IPX
Definition: ppp.h:31
#define PPP_DECNET
Definition: ppp.h:29
#define PPP_IPCP
Definition: ppp.h:47
#define PPP_VJC
Definition: ppp.h:32
#define PPP_STII
Definition: ppp.h:35
#define PPP_HDRLEN
Definition: ppp.h:17
#define PPP_IPV6
Definition: ppp.h:38
#define PPP_NS
Definition: ppp.h:28
#define PPP_DECNETCP
Definition: ppp.h:50
#define PPP_CCP
Definition: ppp.h:56
#define PPP_BRPDU
Definition: ppp.h:34
#define PPP_BAP
Definition: ppp.h:65
#define PPP_LQM
Definition: ppp.h:61
#define PPP_PAP
Definition: ppp.h:60
#define PPP_OSICP
Definition: ppp.h:48
#define PPP_MPCP
Definition: ppp.h:66
#define PPP_STIICP
Definition: ppp.h:53
#define PPP_LCP
Definition: ppp.h:59
#define PPP_PPPD_IN
Definition: ppp.h:22
#define PPP_HELLO
Definition: ppp.h:41
#define PPP_LUXCOM
Definition: ppp.h:42
#define PPP_BACP
Definition: ppp.h:64
#define PPP_MPLS_MCAST
Definition: ppp.h:45
#define PPP_CONTROL
Definition: ppp.h:20
#define PPP_NSCP
Definition: ppp.h:49
#define PPP_PPPD_OUT
Definition: ppp.h:23
#define PPP_MPLS_UCAST
Definition: ppp.h:44
#define PPP_ADDRESS
Definition: ppp.h:19
#define PPP_VJNC
Definition: ppp.h:33
#define PPP_MPLSCP
Definition: ppp.h:57
#define PPP_CHAP
Definition: ppp.h:63
#define PPP_APPLE
Definition: ppp.h:30
#define PPP_EAP
Definition: ppp.h:68
#define CPCODES_ECHO_REQ
Definition: print-ppp.c:119
#define CPCODES_TERM_ACK
Definition: print-ppp.c:116
static const struct tok authalg_values[]
Definition: print-ppp.c:330
#define CHAP_SUCC
Definition: print-ppp.c:369
#define LCPOPT_MRU
Definition: print-ppp.c:150
#define IP6CP_IFID
Definition: print-ppp.c:309
#define CPCODES_RESET_REQ
Definition: print-ppp.c:124
#define CCPOPT_MPPC
Definition: print-ppp.c:228
static u_int print_bacp_config_options(netdissect_options *, const u_char *p, u_int)
Definition: print-ppp.c:1301
#define LCPOPT_SDP
Definition: print-ppp.c:159
static const struct tok ipcpopt_compproto_subopt_values[]
Definition: print-ppp.c:302
#define LCPOPT_LD
Definition: print-ppp.c:172
#define CCPOPT_OUI
Definition: print-ppp.c:221
#define LCPOPT_ACCM
Definition: print-ppp.c:151
#define LCPOPT_ACFC
Definition: print-ppp.c:157
static void ppp_hdlc(netdissect_options *ndo, const u_char *p, u_int length)
Definition: print-ppp.c:1359
static const struct tok papcode_values[]
Definition: print-ppp.c:386
#define IPCPOPT_SECNBNS
Definition: print-ppp.c:279
#define MEDCLASS_IPV4
Definition: print-ppp.c:342
#define CALLBACK_AUTH
Definition: print-ppp.c:348
#define CCPOPT_DEC
Definition: print-ppp.c:235
#define CCPOPT_DEFLATE
Definition: print-ppp.c:236
#define LCPOPT_MLED
Definition: print-ppp.c:168
void ppp_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h, const u_char *p)
Definition: print-ppp.c:1578
static const struct tok ppptype2str[]
Definition: print-ppp.c:62
void ppp_hdlc_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h, const u_char *p)
Definition: print-ppp.c:1647
#define LCPOPT_NUMMODE
Definition: print-ppp.c:160
#define IPCPOPT_MOBILE4
Definition: print-ppp.c:275
#define LCPOPT_VEXT
Definition: print-ppp.c:149
#define CPCODES_CONF_REQ
Definition: print-ppp.c:111
static const struct tok cpcodes[]
Definition: print-ppp.c:127
#define IPCPOPT_PRIDNS
Definition: print-ppp.c:276
#define CPCODES_TIME_REM
Definition: print-ppp.c:123
#define CCPOPT_RESV
Definition: print-ppp.c:238
#define AUTHALG_MSCHAP2
Definition: print-ppp.c:328
#define PAP_AACK
Definition: print-ppp.c:383
#define CALLBACK_CBCP
Definition: print-ppp.c:353
#define CPCODES_ID
Definition: print-ppp.c:122
#define CHAP_RESP
Definition: print-ppp.c:368
#define CPCODES_CONF_REJ
Definition: print-ppp.c:114
static const struct tok ppp_ml_flag_values[]
Definition: print-ppp.c:797
#define IPCPOPT_ADDR
Definition: print-ppp.c:274
#define CALLBACK_X500
Definition: print-ppp.c:352
#define IPCPOPT_SECDNS
Definition: print-ppp.c:278
void ppp_bsdos_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h, const u_char *p)
Definition: print-ppp.c:1722
#define LCPOPT_PPPMUX
Definition: print-ppp.c:179
static const struct tok ccpconfopts_values[]
Definition: print-ppp.c:240
#define LCPOPT_LCPAOPT
Definition: print-ppp.c:173
#define CPCODES_RESET_REP
Definition: print-ppp.c:125
#define IPCPOPT_2ADDR
Definition: print-ppp.c:272
#define LCPOPT_MN
Definition: print-ppp.c:154
#define PAP_AREQ
Definition: print-ppp.c:382
#define LCPOPT_DEP15
Definition: print-ppp.c:164
#define MEDCLASS_PSNDN
Definition: print-ppp.c:345
#define LCPOPT_PFC
Definition: print-ppp.c:156
#define MEDCLASS_MNB
Definition: print-ppp.c:344
#define CCPOPT_PJUMP
Definition: print-ppp.c:224
static void handle_mlppp(netdissect_options *ndo, const u_char *p, u_int length)
Definition: print-ppp.c:804
#define CPCODES_VEXT
Definition: print-ppp.c:110
#define CCPOPT_HPPPC
Definition: print-ppp.c:226
static const struct tok chapcode_values[]
Definition: print-ppp.c:372
#define IPCPOPT_PRINBNS
Definition: print-ppp.c:277
#define LCPOPT_DCEID
Definition: print-ppp.c:170
#define NUM_LCPOPTS
Definition: print-ppp.c:215
#define PAP_ANAK
Definition: print-ppp.c:384
#define LCPOPT_CBACK
Definition: print-ppp.c:162
static void handle_chap(netdissect_options *ndo, const u_char *p, u_int length)
Definition: print-ppp.c:828
#define CALLBACK_DSTR
Definition: print-ppp.c:349
static const struct tok ipcpopt_values[]
Definition: print-ppp.c:281
#define AUTHALG_MSCHAP1
Definition: print-ppp.c:327
#define BACPOPT_FPEER
Definition: print-ppp.c:261
#define CPCODES_CONF_ACK
Definition: print-ppp.c:112
#define LCPOPT_PE
Definition: print-ppp.c:175
static void handle_ctrl_proto(netdissect_options *ndo, u_int proto, const u_char *pptr, u_int length)
Definition: print-ppp.c:412
static const struct tok ppp_callback_values[]
Definition: print-ppp.c:355
static const struct tok ipcpopt_compproto_values[]
Definition: print-ppp.c:296
#define IPCPOPT_IPCOMP_HDRCOMP
Definition: print-ppp.c:293
#define LCPOPT_DEP6
Definition: print-ppp.c:155
#define LCPOPT_COBS
Definition: print-ppp.c:174
#define CPCODES_DISC_REQ
Definition: print-ppp.c:121
#define CCPOPT_LZSDCP
Definition: print-ppp.c:233
#define CCPOPT_PRED1
Definition: print-ppp.c:222
#define MEDCLASS_NULL
Definition: print-ppp.c:340
static u_int print_lcp_config_options(netdissect_options *, const u_char *p, u_int)
Definition: print-ppp.c:590
static u_int print_ip6cp_config_options(netdissect_options *, const u_char *p, u_int)
Definition: print-ppp.c:1145
#define CHAP_FAIL
Definition: print-ppp.c:370
#define CCPOPT_BSDCOMP
Definition: print-ppp.c:231
#define LCPOPT_DEP12
Definition: print-ppp.c:161
static void handle_ppp(netdissect_options *, u_int proto, const u_char *p, u_int length)
Definition: print-ppp.c:1447
#define LCPOPT_MLSSNHF
Definition: print-ppp.c:167
#define LCPOPT_DEP16
Definition: print-ppp.c:165
#define PPP_BSDI_HDRLEN
Definition: print-ppp.c:1718
#define CPCODES_TERM_REQ
Definition: print-ppp.c:115
#define LCPOPT_MLHF
Definition: print-ppp.c:176
#define CCPOPT_MVRCA
Definition: print-ppp.c:234
static const struct tok ip6cpopt_values[]
Definition: print-ppp.c:311
#define MEDCLASS_MAC
Definition: print-ppp.c:343
#define MEDCLASS_LOCAL
Definition: print-ppp.c:341
#define IPCPOPT_IPCOMP_MINLEN
Definition: print-ppp.c:294
#define LCPOPT_AP
Definition: print-ppp.c:152
#define LCPOPT_QP
Definition: print-ppp.c:153
#define CPCODES_PROT_REJ
Definition: print-ppp.c:118
#define CPCODES_CONF_NAK
Definition: print-ppp.c:113
#define LCPOPT_MLMRRU
Definition: print-ppp.c:166
static void handle_pap(netdissect_options *ndo, const u_char *p, u_int length)
Definition: print-ppp.c:899
#define CHAP_CHAL
Definition: print-ppp.c:367
#define IPCPOPT_IPCOMP
Definition: print-ppp.c:273
static void handle_bap(netdissect_options *ndo, const u_char *p, u_int length)
Definition: print-ppp.c:997
#define CPCODES_ECHO_RPL
Definition: print-ppp.c:120
#define AUTHALG_CHAPMD5
Definition: print-ppp.c:326
static u_int print_ipcp_config_options(netdissect_options *, const u_char *p, u_int)
Definition: print-ppp.c:1006
#define LCPOPT_MPP
Definition: print-ppp.c:171
#define CCPOPT_PRED2
Definition: print-ppp.c:223
#define CALLBACK_LID
Definition: print-ppp.c:350
#define CALLBACK_E164
Definition: print-ppp.c:351
static const char * lcpconfopts[]
Definition: print-ppp.c:181
#define CCPOPT_V42BIS
Definition: print-ppp.c:230
static const struct tok bacconfopts_values[]
Definition: print-ppp.c:263
#define CCPOPT_STACLZS
Definition: print-ppp.c:227
static u_int print_ccp_config_options(netdissect_options *, const u_char *p, u_int)
Definition: print-ppp.c:1205
#define LCPOPT_DEP14
Definition: print-ppp.c:163
#define CCPOPT_GFZA
Definition: print-ppp.c:229
#define CPCODES_CODE_REJ
Definition: print-ppp.c:117
#define LCPOPT_SDLOS
Definition: print-ppp.c:178
#define LCPOPT_PROP
Definition: print-ppp.c:169
#define LCPOPT_I18N
Definition: print-ppp.c:177
#define LCPOPT_FCSALT
Definition: print-ppp.c:158
u_int ppp_print(netdissect_options *ndo, const u_char *p, u_int length)
Definition: print-ppp.c:1509
int code
Definition: smbutil.c:1045
const u_char * ndo_snapend
Definition: netdissect.h:239
const char * ndo_protocol
Definition: netdissect.h:218
const char * s
Definition: netdissect.h:140
static void cleanup(int)
Definition: tcpdump.c:2670
#define _U_
Definition: varattrs.h:56