Add CAP_FCNTL and use cap_fcntls_limit().

[tcpdump] / print-token.c

diff --git a/print-token.c b/print-token.c
index d1b20756a4ae12080f272222d5a62b174d819d2b..b88bcf7925207540c90547ae18c4f8c6a8cfe813 100644 (file)
--- a/print-token.c
+++ b/print-token.c
@@ -23,26 +23,19 @@
  * Further tweaked to more closely resemble print-fddi.c
  *     Guy Harris <[email protected]>
  */
  * Further tweaked to more closely resemble print-fddi.c
  *     Guy Harris <[email protected]>
  */

-#ifndef lint
-static const char rcsid[] _U_ =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-token.c,v 1.27 2005-11-13 12:12:43 guy Exp $";
-#endif

 
 

+#define NETDISSECT_REWORKED

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <tcpdump-stdinc.h>
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <tcpdump-stdinc.h>
 

-#include <pcap.h>
-#include <stdio.h>

 #include <string.h>
 
 #include "interface.h"
 #include "extract.h"
 #include "addrtoname.h"
 #include <string.h>
 
 #include "interface.h"
 #include "extract.h"
 #include "addrtoname.h"

-#include "ethertype.h"
-

 #include "ether.h"
 
 /*
 #include "ether.h"
 
 /*


@@ -89,12 +82,12 @@ static const char rcsid[] _U_ =
 #define SEGMENT_COUNT(trp)     ((int)((RIF_LENGTH(trp) - 2) / 2))
 
 struct token_header {
 #define SEGMENT_COUNT(trp)     ((int)((RIF_LENGTH(trp) - 2) / 2))
 
 struct token_header {

-       u_int8_t  token_ac;
-       u_int8_t  token_fc;
-       u_int8_t  token_dhost[TOKEN_RING_MAC_LEN];
-       u_int8_t  token_shost[TOKEN_RING_MAC_LEN];
-       u_int16_t token_rcf;
-       u_int16_t token_rseg[ROUTING_SEGMENT_MAX];
+       uint8_t  token_ac;
+       uint8_t  token_fc;
+       uint8_t  token_dhost[TOKEN_RING_MAC_LEN];
+       uint8_t  token_shost[TOKEN_RING_MAC_LEN];
+       uint16_t token_rcf;
+       uint16_t token_rseg[ROUTING_SEGMENT_MAX];

 };
 
 static const char tstr[] = "[|token-ring]";
 };
 
 static const char tstr[] = "[|token-ring]";


@@ -111,22 +104,23 @@ extract_token_addrs(const struct token_header *trp, char *fsrc, char *fdst)
  * Print the TR MAC header
  */
 static inline void
  * Print the TR MAC header
  */
 static inline void

-token_hdr_print(register const struct token_header *trp, register u_int length,
-          register const u_char *fsrc, register const u_char *fdst)
+token_hdr_print(netdissect_options *ndo,
+                register const struct token_header *trp, register u_int length,
+                register const u_char *fsrc, register const u_char *fdst)

 {
        const char *srcname, *dstname;
 
 {
        const char *srcname, *dstname;
 

-       srcname = etheraddr_string(fsrc);
-       dstname = etheraddr_string(fdst);
+       srcname = etheraddr_string(ndo, fsrc);
+       dstname = etheraddr_string(ndo, fdst);

 
 

-       if (vflag)
-               (void) printf("%02x %02x %s %s %d: ",
+       if (ndo->ndo_vflag)
+               ND_PRINT((ndo, "%02x %02x %s %s %d: ",

                       trp->token_ac,
                       trp->token_fc,
                       srcname, dstname,
                       trp->token_ac,
                       trp->token_fc,
                       srcname, dstname,

-                      length);
+                      length));

        else
        else

-               printf("%s %s %d: ", srcname, dstname, length);
+               ND_PRINT((ndo, "%s %s %d: ", srcname, dstname, length));

 }
 
 static const char *broadcast_indicator[] = {
 }
 
 static const char *broadcast_indicator[] = {


@@ -152,7 +146,7 @@ static const char *largest_frame[] = {
 };
 
 u_int
 };
 
 u_int

-token_print(const u_char *p, u_int length, u_int caplen)
+token_print(netdissect_options *ndo, const u_char *p, u_int length, u_int caplen)

 {
        const struct token_header *trp;
        u_short extracted_ethertype;
 {
        const struct token_header *trp;
        u_short extracted_ethertype;


@@ -163,7 +157,7 @@ token_print(const u_char *p, u_int length, u_int caplen)
        trp = (const struct token_header *)p;
 
        if (caplen < TOKEN_HDRLEN) {
        trp = (const struct token_header *)p;
 
        if (caplen < TOKEN_HDRLEN) {

-               printf("%s", tstr);
+               ND_PRINT((ndo, "%s", tstr));

                return hdr_len;
        }
 
                return hdr_len;
        }
 


@@ -177,36 +171,36 @@ token_print(const u_char *p, u_int length, u_int caplen)
                /* Clear source-routed bit */
                *ESRC(&ehdr) &= 0x7f;
 
                /* Clear source-routed bit */
                *ESRC(&ehdr) &= 0x7f;
 

-               if (eflag)
-                       token_hdr_print(trp, length, ESRC(&ehdr), EDST(&ehdr));
+               if (ndo->ndo_eflag)
+                       token_hdr_print(ndo, trp, length, ESRC(&ehdr), EDST(&ehdr));

 
                if (caplen < TOKEN_HDRLEN + 2) {
 
                if (caplen < TOKEN_HDRLEN + 2) {

-                       printf("%s", tstr);
+                       ND_PRINT((ndo, "%s", tstr));

                        return hdr_len;
                }
                route_len = RIF_LENGTH(trp);
                hdr_len += route_len;
                if (caplen < hdr_len) {
                        return hdr_len;
                }
                route_len = RIF_LENGTH(trp);
                hdr_len += route_len;
                if (caplen < hdr_len) {

-                       printf("%s", tstr);
+                       ND_PRINT((ndo, "%s", tstr));

                        return hdr_len;
                }
                        return hdr_len;
                }

-               if (vflag) {
-                       printf("%s ", broadcast_indicator[BROADCAST(trp)]);
-                       printf("%s", direction[DIRECTION(trp)]);
+               if (ndo->ndo_vflag) {
+                       ND_PRINT((ndo, "%s ", broadcast_indicator[BROADCAST(trp)]));
+                       ND_PRINT((ndo, "%s", direction[DIRECTION(trp)]));

 
                        for (seg = 0; seg < SEGMENT_COUNT(trp); seg++)
 
                        for (seg = 0; seg < SEGMENT_COUNT(trp); seg++)

-                               printf(" [%d:%d]", RING_NUMBER(trp, seg),
-                                   BRIDGE_NUMBER(trp, seg));
+                               ND_PRINT((ndo, " [%d:%d]", RING_NUMBER(trp, seg),
+                                   BRIDGE_NUMBER(trp, seg)));

                } else {
                } else {

-                       printf("rt = %x", EXTRACT_16BITS(&trp->token_rcf));
+                       ND_PRINT((ndo, "rt = %x", EXTRACT_16BITS(&trp->token_rcf)));

 
                        for (seg = 0; seg < SEGMENT_COUNT(trp); seg++)
 
                        for (seg = 0; seg < SEGMENT_COUNT(trp); seg++)

-                               printf(":%x", EXTRACT_16BITS(&trp->token_rseg[seg]));
+                               ND_PRINT((ndo, ":%x", EXTRACT_16BITS(&trp->token_rseg[seg])));

                }
                }

-               printf(" (%s) ", largest_frame[LARGEST_FRAME(trp)]);
+               ND_PRINT((ndo, " (%s) ", largest_frame[LARGEST_FRAME(trp)]));

        } else {
        } else {

-               if (eflag)
-                       token_hdr_print(trp, length, ESRC(&ehdr), EDST(&ehdr));
+               if (ndo->ndo_eflag)
+                       token_hdr_print(ndo, trp, length, ESRC(&ehdr), EDST(&ehdr));

        }
 
        /* Skip over token ring MAC header and routing information */
        }
 
        /* Skip over token ring MAC header and routing information */


@@ -217,28 +211,28 @@ token_print(const u_char *p, u_int length, u_int caplen)
        /* Frame Control field determines interpretation of packet */
        if (FRAME_TYPE(trp) == TOKEN_FC_LLC) {
                /* Try to print the LLC-layer header & higher layers */
        /* Frame Control field determines interpretation of packet */
        if (FRAME_TYPE(trp) == TOKEN_FC_LLC) {
                /* Try to print the LLC-layer header & higher layers */

-               if (llc_print(p, length, caplen, ESRC(&ehdr), EDST(&ehdr),
+               if (llc_print(ndo, p, length, caplen, ESRC(&ehdr), EDST(&ehdr),

                    &extracted_ethertype) == 0) {
                        /* ether_type not known, print raw packet */
                    &extracted_ethertype) == 0) {
                        /* ether_type not known, print raw packet */

-                       if (!eflag)
-                               token_hdr_print(trp,
+                       if (!ndo->ndo_eflag)
+                               token_hdr_print(ndo, trp,

                                    length + TOKEN_HDRLEN + route_len,
                                    ESRC(&ehdr), EDST(&ehdr));
                        if (extracted_ethertype) {
                                    length + TOKEN_HDRLEN + route_len,
                                    ESRC(&ehdr), EDST(&ehdr));
                        if (extracted_ethertype) {

-                               printf("(LLC %s) ",
-                       etherproto_string(htons(extracted_ethertype)));
+                               ND_PRINT((ndo, "(LLC %s) ",
+                       etherproto_string(htons(extracted_ethertype))));

                        }
                        }

-                       if (!suppress_default_print)
-                               default_print(p, caplen);
+                       if (!ndo->ndo_suppress_default_print)
+                               ND_DEFAULTPRINT(p, caplen);

                }
        } else {
                /* Some kinds of TR packet we cannot handle intelligently */
                /* XXX - dissect MAC packets if frame type is 0 */
                }
        } else {
                /* Some kinds of TR packet we cannot handle intelligently */
                /* XXX - dissect MAC packets if frame type is 0 */

-               if (!eflag)
-                       token_hdr_print(trp, length + TOKEN_HDRLEN + route_len,
+               if (!ndo->ndo_eflag)
+                       token_hdr_print(ndo, trp, length + TOKEN_HDRLEN + route_len,

                            ESRC(&ehdr), EDST(&ehdr));
                            ESRC(&ehdr), EDST(&ehdr));

-               if (!suppress_default_print)
-                       default_print(p, caplen);
+               if (!ndo->ndo_suppress_default_print)
+                       ND_DEFAULTPRINT(p, caplen);

        }
        return (hdr_len);
 }
        }
        return (hdr_len);
 }


@@ -250,7 +244,7 @@ token_print(const u_char *p, u_int length, u_int caplen)
  * is the number of bytes actually captured.
  */
 u_int
  * is the number of bytes actually captured.
  */
 u_int

-token_if_print(const struct pcap_pkthdr *h, const u_char *p)
+token_if_print(netdissect_options *ndo, const struct pcap_pkthdr *h, const u_char *p)

 {
 {

-       return (token_print(p, h->len, h->caplen));
+       return (token_print(ndo, p, h->len, h->caplen));

 }
 }