bgp: Parse BGP extended message support capability

[tcpdump] / print-pppoe.c

diff --git a/print-pppoe.c b/print-pppoe.c
index 6b08b6f152a9b510ff4bc73b4f9ee9461f12ef39..65518dff16d97adde75b1d7eb537d602354f7998 100644 (file)
--- a/print-pppoe.c
+++ b/print-pppoe.c
@@ -21,26 +21,19 @@
  * Original code by Greg Stark <[email protected]>
  */
 
  * Original code by Greg Stark <[email protected]>
  */
 

-#ifndef lint
-static const char rcsid[] _U_ =
-"@(#) $Header: /tcpdump/master/tcpdump/print-pppoe.c,v 1.31 2005-04-26 19:48:38 guy Exp $ (LBL)";
-#endif
+/* \summary: PPP-over-Ethernet (PPPoE) printer */

 
 #ifdef HAVE_CONFIG_H
 
 #ifdef HAVE_CONFIG_H

-#include "config.h"
+#include <config.h>

 #endif
 
 #endif
 

-#include <tcpdump-stdinc.h>
+#include "netdissect-stdinc.h"

 
 

-#include <stdio.h>
-#include <string.h>
+#include "netdissect-ctype.h"

 
 

-#include "interface.h"
-#include "addrtoname.h"
-#include "ppp.h"
-#include "ethertype.h"
-#include "ether.h"
-#include "extract.h"                   /* must come after interface.h */
+#define ND_LONGJMP_FROM_TCHECK
+#include "netdissect.h"
+#include "extract.h"

 
 /* Codes */
 enum {
 
 /* Codes */
 enum {


@@ -94,50 +87,52 @@ static const struct tok pppoetag2str[] = {
 #define PPPOE_HDRLEN 6
 #define MAXTAGPRINT 80
 
 #define PPPOE_HDRLEN 6
 #define MAXTAGPRINT 80
 

-u_int
-pppoe_if_print(const struct pcap_pkthdr *h, register const u_char *p)
+void
+pppoe_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h, const u_char *p)

 {
 {

-       return (pppoe_print(p, h->len));
+       ndo->ndo_protocol = "pppoe";
+       ndo->ndo_ll_hdr_len += pppoe_print(ndo, p, h->len);

 }
 
 u_int
 }
 
 u_int

-pppoe_print(register const u_char *bp, u_int length)
+pppoe_print(netdissect_options *ndo, const u_char *bp, u_int length)

 {
 {

-       u_int16_t pppoe_ver, pppoe_type, pppoe_code, pppoe_sessionid;
+       uint16_t pppoe_ver, pppoe_type, pppoe_code, pppoe_sessionid;

        u_int pppoe_length;
        const u_char *pppoe_packet, *pppoe_payload;
 
        u_int pppoe_length;
        const u_char *pppoe_packet, *pppoe_payload;
 

+       ndo->ndo_protocol = "pppoe";

        if (length < PPPOE_HDRLEN) {
        if (length < PPPOE_HDRLEN) {

-               (void)printf("truncated-pppoe %u", length);
-               return (length);
+               ND_PRINT(" (length %u < %u)", length, PPPOE_HDRLEN);
+               goto invalid;

        }
        length -= PPPOE_HDRLEN;
        pppoe_packet = bp;
        }
        length -= PPPOE_HDRLEN;
        pppoe_packet = bp;

-       TCHECK2(*pppoe_packet, PPPOE_HDRLEN);
-       pppoe_ver  = (pppoe_packet[0] & 0xF0) >> 4;
-       pppoe_type  = (pppoe_packet[0] & 0x0F);
-       pppoe_code = pppoe_packet[1];
-       pppoe_sessionid = EXTRACT_16BITS(pppoe_packet + 2);
-       pppoe_length    = EXTRACT_16BITS(pppoe_packet + 4);
+       ND_TCHECK_LEN(pppoe_packet, PPPOE_HDRLEN);
+       pppoe_ver  = (GET_U_1(pppoe_packet) & 0xF0) >> 4;
+       pppoe_type  = (GET_U_1(pppoe_packet) & 0x0F);
+       pppoe_code = GET_U_1(pppoe_packet + 1);
+       pppoe_sessionid = GET_BE_U_2(pppoe_packet + 2);
+       pppoe_length    = GET_BE_U_2(pppoe_packet + 4);

        pppoe_payload = pppoe_packet + PPPOE_HDRLEN;
 
        if (pppoe_ver != 1) {
        pppoe_payload = pppoe_packet + PPPOE_HDRLEN;
 
        if (pppoe_ver != 1) {

-               printf(" [ver %d]",pppoe_ver);
+               ND_PRINT(" [ver %u]",pppoe_ver);

        }
        if (pppoe_type != 1) {
        }
        if (pppoe_type != 1) {

-               printf(" [type %d]",pppoe_type);
+               ND_PRINT(" [type %u]",pppoe_type);

        }
 
        }
 

-       printf("PPPoE %s", tok2str(pppoecode2str, "PAD-%x", pppoe_code));
+       ND_PRINT("PPPoE %s", tok2str(pppoecode2str, "PAD-%x", pppoe_code));

        if (pppoe_code == PPPOE_PADI && pppoe_length > 1484 - PPPOE_HDRLEN) {
        if (pppoe_code == PPPOE_PADI && pppoe_length > 1484 - PPPOE_HDRLEN) {

-               printf(" [len %u!]",pppoe_length);
+               ND_PRINT(" [len %u!]",pppoe_length);

        }
        if (pppoe_length > length) {
        }
        if (pppoe_length > length) {

-               printf(" [len %u > %u!]", pppoe_length, length);
+               ND_PRINT(" [len %u > %u!]", pppoe_length, length);

                pppoe_length = length;
        }
        if (pppoe_sessionid) {
                pppoe_length = length;
        }
        if (pppoe_sessionid) {

-               printf(" [ses 0x%x]", pppoe_sessionid);
+               ND_PRINT(" [ses 0x%x]", pppoe_sessionid);

        }
 
        if (pppoe_code) {
        }
 
        if (pppoe_code) {


@@ -151,61 +146,61 @@ pppoe_print(register const u_char *bp, u_int length)
                 * tag_type is previous tag or 0xffff for first iteration
                 */
                while (tag_type && p < pppoe_payload + pppoe_length) {
                 * tag_type is previous tag or 0xffff for first iteration
                 */
                while (tag_type && p < pppoe_payload + pppoe_length) {

-                       TCHECK2(*p, 4);
-                       tag_type = EXTRACT_16BITS(p);
-                       tag_len = EXTRACT_16BITS(p + 2);
+                       tag_type = GET_BE_U_2(p);
+                       tag_len = GET_BE_U_2(p + 2);

                        p += 4;
                        /* p points to tag_value */
 
                        if (tag_len) {
                        p += 4;
                        /* p points to tag_value */
 
                        if (tag_len) {

-                               unsigned isascii = 0, isgarbage = 0;
+                               unsigned ascii_count = 0, garbage_count = 0;

                                const u_char *v;
                                char tag_str[MAXTAGPRINT];
                                unsigned tag_str_len = 0;
 
                                /* TODO print UTF-8 decoded text */
                                const u_char *v;
                                char tag_str[MAXTAGPRINT];
                                unsigned tag_str_len = 0;
 
                                /* TODO print UTF-8 decoded text */

-                               TCHECK2(*p, tag_len);
+                               ND_TCHECK_LEN(p, tag_len);

                                for (v = p; v < p + tag_len && tag_str_len < MAXTAGPRINT-1; v++)
                                for (v = p; v < p + tag_len && tag_str_len < MAXTAGPRINT-1; v++)

-                                       if (*v >= 32 && *v < 127) {
-                                               tag_str[tag_str_len++] = *v;
-                                               isascii++;
+                                       if (ND_ASCII_ISPRINT(GET_U_1(v))) {
+                                               tag_str[tag_str_len++] = GET_U_1(v);
+                                               ascii_count++;

                                        } else {
                                                tag_str[tag_str_len++] = '.';
                                        } else {
                                                tag_str[tag_str_len++] = '.';

-                                               isgarbage++;
+                                               garbage_count++;

                                        }
                                tag_str[tag_str_len] = 0;
 
                                        }
                                tag_str[tag_str_len] = 0;
 

-                               if (isascii > isgarbage) {
-                                       printf(" [%s \"%*.*s\"]",
+                               if (ascii_count > garbage_count) {
+                                       ND_PRINT(" [%s \"%*.*s\"]",

                                               tok2str(pppoetag2str, "TAG-0x%x", tag_type),
                                               (int)tag_str_len,
                                               (int)tag_str_len,
                                               tag_str);
                                } else {
                                        /* Print hex, not fast to abuse printf but this doesn't get used much */
                                               tok2str(pppoetag2str, "TAG-0x%x", tag_type),
                                               (int)tag_str_len,
                                               (int)tag_str_len,
                                               tag_str);
                                } else {
                                        /* Print hex, not fast to abuse printf but this doesn't get used much */

-                                       printf(" [%s 0x", tok2str(pppoetag2str, "TAG-0x%x", tag_type));
+                                       ND_PRINT(" [%s 0x", tok2str(pppoetag2str, "TAG-0x%x", tag_type));

                                        for (v=p; v<p+tag_len; v++) {
                                        for (v=p; v<p+tag_len; v++) {

-                                               printf("%02X", *v);
+                                               ND_PRINT("%02X", GET_U_1(v));

                                        }
                                        }

-                                       printf("]");
+                                       ND_PRINT("]");

                                }
 
 
                        } else
                                }
 
 
                        } else

-                               printf(" [%s]", tok2str(pppoetag2str,
+                               ND_PRINT(" [%s]", tok2str(pppoetag2str,

                                    "TAG-0x%x", tag_type));
 
                        p += tag_len;
                        /* p points to next tag */
                }
                                    "TAG-0x%x", tag_type));
 
                        p += tag_len;
                        /* p points to next tag */
                }

-               return (0);
+               return PPPOE_HDRLEN;

        } else {
                /* PPPoE data */
        } else {
                /* PPPoE data */

-               printf(" ");
-               return (PPPOE_HDRLEN + ppp_print(pppoe_payload, pppoe_length));
+               ND_PRINT(" ");
+               return (PPPOE_HDRLEN + ppp_print(ndo, pppoe_payload, pppoe_length));

        }
        }

+       /* NOTREACHED */

 
 

-trunc:
-       printf("[|pppoe]");
-       return (PPPOE_HDRLEN);
+invalid:
+       nd_print_invalid(ndo);
+       return 0;

 }
 }