The third argument to linkaddr_string is one of the LINKADDR_ enums.

[tcpdump] / print-dvmrp.c

diff --git a/print-dvmrp.c b/print-dvmrp.c
index 1353c46cc129ca27b10bf637db9b33e943273ebb..7e57a49bcd605edbf64ed9dd733fede71a97db8c 100644 (file)
--- a/print-dvmrp.c
+++ b/print-dvmrp.c
@@ -19,26 +19,21 @@
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 

-#ifndef lint
-static const char rcsid[] _U_ =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-dvmrp.c,v 1.27 2003-11-19 09:42:04 guy Exp $ (LBL)";
-#endif
+/* \summary: Distance Vector Multicast Routing Protocol printer */

 
 #ifdef HAVE_CONFIG_H
 
 #ifdef HAVE_CONFIG_H

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

 #endif
 
 #endif
 

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

 
 

-#include "interface.h"
+#include "netdissect.h"

 #include "extract.h"
 #include "addrtoname.h"
 
 /*
 #include "extract.h"
 #include "addrtoname.h"
 
 /*

+ * See: RFC 1075 and draft-ietf-idmr-dvmrp-v3
+ *

  * DVMRP message types and flag values shamelessly stolen from
  * mrouted/dvmrp.h.
  */
  * DVMRP message types and flag values shamelessly stolen from
  * mrouted/dvmrp.h.
  */


@@ -62,28 +57,29 @@ static const char rcsid[] _U_ =
 #define DVMRP_NF_DISABLED      0x20    /* administratively disabled */
 #define DVMRP_NF_QUERIER       0x40    /* I am the subnet's querier */
 
 #define DVMRP_NF_DISABLED      0x20    /* administratively disabled */
 #define DVMRP_NF_QUERIER       0x40    /* I am the subnet's querier */
 

-static int print_probe(const u_char *, const u_char *, u_int);
-static int print_report(const u_char *, const u_char *, u_int);
-static int print_neighbors(const u_char *, const u_char *, u_int);
-static int print_neighbors2(const u_char *, const u_char *, u_int);
-static int print_prune(const u_char *);
-static int print_graft(const u_char *);
-static int print_graft_ack(const u_char *);
-
-static u_int32_t target_level;
+static int print_probe(netdissect_options *, const u_char *, const u_char *, u_int);
+static int print_report(netdissect_options *, const u_char *, const u_char *, u_int);
+static int print_neighbors(netdissect_options *, const u_char *, const u_char *, u_int);
+static int print_neighbors2(netdissect_options *, const u_char *, const u_char *, u_int, uint8_t, uint8_t);
+static int print_prune(netdissect_options *, const u_char *);
+static int print_graft(netdissect_options *, const u_char *);
+static int print_graft_ack(netdissect_options *, const u_char *);

 
 void
 
 void

-dvmrp_print(register const u_char *bp, register u_int len)
+dvmrp_print(netdissect_options *ndo,
+            const u_char *bp, u_int len)

 {
 {

-       register const u_char *ep;
-       register u_char type;
+       const u_char *ep;
+       u_char type;
+       uint8_t major_version, minor_version;

 
 

-       ep = (const u_char *)snapend;
+       ndo->ndo_protocol = "dvmrp";
+       ep = ndo->ndo_snapend;

        if (bp >= ep)
                return;
 
        if (bp >= ep)
                return;
 

-       TCHECK(bp[1]);
-       type = bp[1];
+       ND_TCHECK_1(bp + 1);
+       type = GET_U_1(bp + 1);

 
        /* Skip IGMP header */
        bp += 8;
 
        /* Skip IGMP header */
        bp += 8;


@@ -92,127 +88,131 @@ dvmrp_print(register const u_char *bp, register u_int len)
        switch (type) {
 
        case DVMRP_PROBE:
        switch (type) {
 
        case DVMRP_PROBE:

-               printf(" Probe");
-               if (vflag) {
-                       if (print_probe(bp, ep, len) < 0)
+               ND_PRINT(" Probe");
+               if (ndo->ndo_vflag) {
+                       if (print_probe(ndo, bp, ep, len) < 0)

                                goto trunc;
                }
                break;
 
        case DVMRP_REPORT:
                                goto trunc;
                }
                break;
 
        case DVMRP_REPORT:

-               printf(" Report");
-               if (vflag > 1) {
-                       if (print_report(bp, ep, len) < 0)
+               ND_PRINT(" Report");
+               if (ndo->ndo_vflag > 1) {
+                       if (print_report(ndo, bp, ep, len) < 0)

                                goto trunc;
                }
                break;
 
        case DVMRP_ASK_NEIGHBORS:
                                goto trunc;
                }
                break;
 
        case DVMRP_ASK_NEIGHBORS:

-               printf(" Ask-neighbors(old)");
+               ND_PRINT(" Ask-neighbors(old)");

                break;
 
        case DVMRP_NEIGHBORS:
                break;
 
        case DVMRP_NEIGHBORS:

-               printf(" Neighbors(old)");
-               if (print_neighbors(bp, ep, len) < 0)
+               ND_PRINT(" Neighbors(old)");
+               if (print_neighbors(ndo, bp, ep, len) < 0)

                        goto trunc;
                break;
 
        case DVMRP_ASK_NEIGHBORS2:
                        goto trunc;
                break;
 
        case DVMRP_ASK_NEIGHBORS2:

-               printf(" Ask-neighbors2");
+               ND_PRINT(" Ask-neighbors2");

                break;
 
        case DVMRP_NEIGHBORS2:
                break;
 
        case DVMRP_NEIGHBORS2:

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

                /*
                /*

-                * extract version and capabilities from IGMP group
-                * address field
+                * extract version from IGMP group address field

                 */
                bp -= 4;
                 */
                bp -= 4;

-               TCHECK2(bp[0], 4);
-               target_level = (bp[0] << 24) | (bp[1] << 16) |
-                   (bp[2] << 8) | bp[3];
+               ND_TCHECK_4(bp);
+               major_version = GET_U_1(bp + 3);
+               minor_version = GET_U_1(bp + 2);

                bp += 4;
                bp += 4;

-               if (print_neighbors2(bp, ep, len) < 0)
+               if (print_neighbors2(ndo, bp, ep, len, major_version,
+                   minor_version) < 0)

                        goto trunc;
                break;
 
        case DVMRP_PRUNE:
                        goto trunc;
                break;
 
        case DVMRP_PRUNE:

-               printf(" Prune");
-               if (print_prune(bp) < 0)
+               ND_PRINT(" Prune");
+               if (print_prune(ndo, bp) < 0)

                        goto trunc;
                break;
 
        case DVMRP_GRAFT:
                        goto trunc;
                break;
 
        case DVMRP_GRAFT:

-               printf(" Graft");
-               if (print_graft(bp) < 0)
+               ND_PRINT(" Graft");
+               if (print_graft(ndo, bp) < 0)

                        goto trunc;
                break;
 
        case DVMRP_GRAFT_ACK:
                        goto trunc;
                break;
 
        case DVMRP_GRAFT_ACK:

-               printf(" Graft-ACK");
-               if (print_graft_ack(bp) < 0)
+               ND_PRINT(" Graft-ACK");
+               if (print_graft_ack(ndo, bp) < 0)

                        goto trunc;
                break;
 
        default:
                        goto trunc;
                break;
 
        default:

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

                break;
        }
        return;
 
 trunc:
                break;
        }
        return;
 
 trunc:

-       printf("[|dvmrp]");
+       nd_print_trunc(ndo);

        return;
 }
 
 static int
        return;
 }
 
 static int

-print_report(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+print_report(netdissect_options *ndo,
+             const u_char *bp, const u_char *ep,
+             u_int len)

 {
 {

-       register u_int32_t mask, origin;
-       register int metric, done;
-       register u_int i, width;
+       uint32_t mask, origin;
+       u_int metric, done;
+       u_int i, width;

 
        while (len > 0) {
                if (len < 3) {
 
        while (len > 0) {
                if (len < 3) {

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

                        return (0);
                }
                        return (0);
                }

-               TCHECK2(bp[0], 3);
-               mask = (u_int32_t)0xff << 24 | bp[0] << 16 | bp[1] << 8 | bp[2];
+               ND_TCHECK_3(bp);
+               mask = (uint32_t)0xff << 24 | GET_U_1(bp) << 16 |
+                       GET_U_1(bp + 1) << 8 | GET_U_1(bp + 2);

                width = 1;
                width = 1;

-               if (bp[0])
+               if (GET_U_1(bp))

                        width = 2;
                        width = 2;

-               if (bp[1])
+               if (GET_U_1(bp + 1))

                        width = 3;
                        width = 3;

-               if (bp[2])
+               if (GET_U_1(bp + 2))

                        width = 4;
 
                        width = 4;
 

-               printf("\n\tMask %s", intoa(htonl(mask)));
+               ND_PRINT("\n\tMask %s", intoa(htonl(mask)));

                bp += 3;
                len -= 3;
                do {
                        if (bp + width + 1 > ep) {
                bp += 3;
                len -= 3;
                do {
                        if (bp + width + 1 > ep) {

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

                                return (0);
                        }
                        if (len < width + 1) {
                                return (0);
                        }
                        if (len < width + 1) {

-                               printf("\n\t  [Truncated Report]");
+                               ND_PRINT("\n\t  [Truncated Report]");

                                return (0);
                        }
                        origin = 0;
                        for (i = 0; i < width; ++i) {
                                return (0);
                        }
                        origin = 0;
                        for (i = 0; i < width; ++i) {

-                               TCHECK(*bp);
-                               origin = origin << 8 | *bp++;
+                               ND_TCHECK_1(bp);
+                               origin = origin << 8 | GET_U_1(bp);
+                               bp++;

                        }
                        for ( ; i < 4; ++i)
                                origin <<= 8;
 
                        }
                        for ( ; i < 4; ++i)
                                origin <<= 8;
 

-                       TCHECK(*bp);
-                       metric = *bp++;
+                       ND_TCHECK_1(bp);
+                       metric = GET_U_1(bp);
+                       bp++;

                        done = metric & 0x80;
                        metric &= 0x7f;
                        done = metric & 0x80;
                        metric &= 0x7f;

-                       printf("\n\t  %s metric %d", intoa(htonl(origin)),
+                       ND_PRINT("\n\t  %s metric %u", intoa(htonl(origin)),

                                metric);
                        len -= width + 1;
                } while (!done);
                                metric);
                        len -= width + 1;
                } while (!done);


@@ -223,31 +223,29 @@ trunc:
 }
 
 static int
 }
 
 static int

-print_probe(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+print_probe(netdissect_options *ndo,
+            const u_char *bp, const u_char *ep,
+            u_int len)

 {
 {

-       register u_int32_t genid;
+       uint32_t genid;

 
 

-       TCHECK2(bp[0], 4);
+       ND_TCHECK_4(bp);

        if ((len < 4) || ((bp + 4) > ep)) {
                /* { (ctags) */
        if ((len < 4) || ((bp + 4) > ep)) {
                /* { (ctags) */

-               printf(" [|}");
+               ND_PRINT(" [|}");

                return (0);
        }
                return (0);
        }

-       genid = (bp[0] << 24) | (bp[1] << 16) | (bp[2] << 8) | bp[3];
+       genid = GET_BE_U_4(bp);

        bp += 4;
        len -= 4;
        bp += 4;
        len -= 4;

-       if (vflag > 1)
-               printf("\n\t");
-       else
-               printf(" ");
-       printf("genid %u", genid);
-       if (vflag < 2)
+       ND_PRINT(ndo->ndo_vflag > 1 ? "\n\t" : " ");
+       ND_PRINT("genid %u", genid);
+       if (ndo->ndo_vflag < 2)

                return (0);
 
        while ((len > 0) && (bp < ep)) {
                return (0);
 
        while ((len > 0) && (bp < ep)) {

-               TCHECK2(bp[0], 4);
-               printf("\n\tneighbor %s", ipaddr_string(bp));
+               ND_TCHECK_4(bp);
+               ND_PRINT("\n\tneighbor %s", ipaddr_string(ndo, bp));

                bp += 4; len -= 4;
        }
        return (0);
                bp += 4; len -= 4;
        }
        return (0);


@@ -256,27 +254,31 @@ trunc:
 }
 
 static int
 }
 
 static int

-print_neighbors(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+print_neighbors(netdissect_options *ndo,
+                const u_char *bp, const u_char *ep,
+                u_int len)

 {
        const u_char *laddr;
 {
        const u_char *laddr;

-       register u_char metric;
-       register u_char thresh;
-       register int ncount;
+       u_char metric;
+       u_char thresh;
+       int ncount;

 
        while (len > 0 && bp < ep) {
 
        while (len > 0 && bp < ep) {

-               TCHECK2(bp[0], 7);
+               ND_TCHECK_7(bp);

                laddr = bp;
                bp += 4;
                laddr = bp;
                bp += 4;

-               metric = *bp++;
-               thresh = *bp++;
-               ncount = *bp++;
+               metric = GET_U_1(bp);
+               bp++;
+               thresh = GET_U_1(bp);
+               bp++;
+               ncount = GET_U_1(bp);
+               bp++;

                len -= 7;
                while (--ncount >= 0) {
                len -= 7;
                while (--ncount >= 0) {

-                       TCHECK2(bp[0], 4);
-                       printf(" [%s ->", ipaddr_string(laddr));
-                       printf(" %s, (%d/%d)]",
-                                  ipaddr_string(bp), metric, thresh);
+                       ND_TCHECK_4(bp);
+                       ND_PRINT(" [%s ->", ipaddr_string(ndo, laddr));
+                       ND_PRINT(" %s, (%u/%u)]",
+                                  ipaddr_string(ndo, bp), metric, thresh);

                        bp += 4;
                        len -= 4;
                }
                        bp += 4;
                        len -= 4;
                }


@@ -287,46 +289,50 @@ trunc:
 }
 
 static int
 }
 
 static int

-print_neighbors2(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+print_neighbors2(netdissect_options *ndo,
+                 const u_char *bp, const u_char *ep,
+                 u_int len, uint8_t major_version,
+                 uint8_t minor_version)

 {
        const u_char *laddr;
 {
        const u_char *laddr;

-       register u_char metric, thresh, flags;
-       register int ncount;
+       u_char metric, thresh, flags;
+       int ncount;

 
 

-       printf(" (v %d.%d):",
-              (int)target_level & 0xff,
-              (int)(target_level >> 8) & 0xff);
+       ND_PRINT(" (v %u.%u):", major_version, minor_version);

 
        while (len > 0 && bp < ep) {
 
        while (len > 0 && bp < ep) {

-               TCHECK2(bp[0], 8);
+               ND_TCHECK_8(bp);

                laddr = bp;
                bp += 4;
                laddr = bp;
                bp += 4;

-               metric = *bp++;
-               thresh = *bp++;
-               flags = *bp++;
-               ncount = *bp++;
+               metric = GET_U_1(bp);
+               bp++;
+               thresh = GET_U_1(bp);
+               bp++;
+               flags = GET_U_1(bp);
+               bp++;
+               ncount = GET_U_1(bp);
+               bp++;

                len -= 8;
                while (--ncount >= 0 && (len >= 4) && (bp + 4) <= ep) {
                len -= 8;
                while (--ncount >= 0 && (len >= 4) && (bp + 4) <= ep) {

-                       printf(" [%s -> ", ipaddr_string(laddr));
-                       printf("%s (%d/%d", ipaddr_string(bp),
+                       ND_PRINT(" [%s -> ", ipaddr_string(ndo, laddr));
+                       ND_PRINT("%s (%u/%u", ipaddr_string(ndo, bp),

                                     metric, thresh);
                        if (flags & DVMRP_NF_TUNNEL)
                                     metric, thresh);
                        if (flags & DVMRP_NF_TUNNEL)

-                               printf("/tunnel");
+                               ND_PRINT("/tunnel");

                        if (flags & DVMRP_NF_SRCRT)
                        if (flags & DVMRP_NF_SRCRT)

-                               printf("/srcrt");
+                               ND_PRINT("/srcrt");

                        if (flags & DVMRP_NF_QUERIER)
                        if (flags & DVMRP_NF_QUERIER)

-                               printf("/querier");
+                               ND_PRINT("/querier");

                        if (flags & DVMRP_NF_DISABLED)
                        if (flags & DVMRP_NF_DISABLED)

-                               printf("/disabled");
+                               ND_PRINT("/disabled");

                        if (flags & DVMRP_NF_DOWN)
                        if (flags & DVMRP_NF_DOWN)

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

                        bp += 4;
                        len -= 4;
                }
                if (ncount != -1) {
                        bp += 4;
                        len -= 4;
                }
                if (ncount != -1) {

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

                        return (0);
                }
        }
                        return (0);
                }
        }


@@ -336,33 +342,36 @@ trunc:
 }
 
 static int
 }
 
 static int

-print_prune(register const u_char *bp)
+print_prune(netdissect_options *ndo,
+            const u_char *bp)

 {
 {

-       TCHECK2(bp[0], 12);
-       printf(" src %s grp %s", ipaddr_string(bp), ipaddr_string(bp + 4));
+       ND_TCHECK_LEN(bp, 12);
+       ND_PRINT(" src %s grp %s", ipaddr_string(ndo, bp), ipaddr_string(ndo, bp + 4));

        bp += 8;
        bp += 8;

-       (void)printf(" timer ");
-       relts_print(EXTRACT_32BITS(bp));
+       ND_PRINT(" timer ");
+       unsigned_relts_print(ndo, GET_BE_U_4(bp));

        return (0);
 trunc:
        return (-1);
 }
 
 static int
        return (0);
 trunc:
        return (-1);
 }
 
 static int

-print_graft(register const u_char *bp)
+print_graft(netdissect_options *ndo,
+            const u_char *bp)

 {
 {

-       TCHECK2(bp[0], 8);
-       printf(" src %s grp %s", ipaddr_string(bp), ipaddr_string(bp + 4));
+       ND_TCHECK_8(bp);
+       ND_PRINT(" src %s grp %s", ipaddr_string(ndo, bp), ipaddr_string(ndo, bp + 4));

        return (0);
 trunc:
        return (-1);
 }
 
 static int
        return (0);
 trunc:
        return (-1);
 }
 
 static int

-print_graft_ack(register const u_char *bp)
+print_graft_ack(netdissect_options *ndo,
+                const u_char *bp)

 {
 {

-       TCHECK2(bp[0], 8);
-       printf(" src %s grp %s", ipaddr_string(bp), ipaddr_string(bp + 4));
+       ND_TCHECK_8(bp);
+       ND_PRINT(" src %s grp %s", ipaddr_string(ndo, bp), ipaddr_string(ndo, bp + 4));

        return (0);
 trunc:
        return (-1);
        return (0);
 trunc:
        return (-1);