]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-dvmrp.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Avoid collison with error(), clean up code a bit.
[tcpdump] / print-dvmrp.c
diff --git a/print-dvmrp.c b/print-dvmrp.c
index 1be0cfa8cfb055e28c7fcf7d9f494054d10fc1da..8e0083260bd61771c9ff4871abc0485ebae6e8aa 100644 (file)
--- a/print-dvmrp.c
+++ b/print-dvmrp.c
@@ -19,31 +19,11 @@
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
-#ifndef lint
-static const char rcsid[] =
-    "@(#) $Header: /tcpdump/master/tcpdump/print-dvmrp.c,v 1.17 1999-11-22 04:30:34 fenner Exp $ (LBL)";
-#endif
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#include <sys/param.h>
-#include <sys/time.h>
-#include <sys/socket.h>
-
-#include <netinet/in.h>
-#include <netinet/in_systm.h>
-#include <netinet/ip.h>
-#include <netinet/ip_var.h>
-#include <netinet/udp.h>
-#include <netinet/udp_var.h>
-#include <netinet/tcp.h>
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
+#include <tcpdump-stdinc.h>
 
 #include "interface.h"
 #include "extract.h"
 
 #include "interface.h"
 #include "extract.h"
@@ -56,9 +36,7 @@ static const char rcsid[] =
 #define DVMRP_PROBE            1       /* for finding neighbors */
 #define DVMRP_REPORT           2       /* for reporting some or all routes */
 #define DVMRP_ASK_NEIGHBORS    3       /* sent by mapper, asking for a list */
 #define DVMRP_PROBE            1       /* for finding neighbors */
 #define DVMRP_REPORT           2       /* for reporting some or all routes */
 #define DVMRP_ASK_NEIGHBORS    3       /* sent by mapper, asking for a list */
-                                       /*
-                                        * of this router's neighbors
-                                        */
+                                       /* of this router's neighbors */
 #define DVMRP_NEIGHBORS                4       /* response to such a request */
 #define DVMRP_ASK_NEIGHBORS2   5       /* as above, want new format reply */
 #define DVMRP_NEIGHBORS2       6
 #define DVMRP_NEIGHBORS                4       /* response to such a request */
 #define DVMRP_ASK_NEIGHBORS2   5       /* as above, want new format reply */
 #define DVMRP_NEIGHBORS2       6
@@ -75,108 +53,126 @@ static const char rcsid[] =
 #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 void print_probe(const u_char *, const u_char *, u_int);
-static void print_report(const u_char *, const u_char *, u_int);
-static void print_neighbors(const u_char *, const u_char *, u_int);
-static void print_neighbors2(const u_char *, const u_char *, u_int);
-static void print_prune(const u_char *, const u_char *, u_int);
-static void print_graft(const u_char *, const u_char *, u_int);
-static void print_graft_ack(const u_char *, const u_char *, u_int);
+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);
+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 *);
 
 
-static u_int32_t target_level;
+static uint32_t target_level;
 
 void
 
 void
-dvmrp_print(register const u_char *bp, register u_int len)
+dvmrp_print(netdissect_options *ndo,
+            register const u_char *bp, register u_int len)
 {
        register const u_char *ep;
        register u_char type;
 
 {
        register const u_char *ep;
        register u_char type;
 
-       ep = (const u_char *)snapend;
+       ep = (const u_char *)ndo->ndo_snapend;
        if (bp >= ep)
                return;
 
        if (bp >= ep)
                return;
 
+       ND_TCHECK(bp[1]);
        type = bp[1];
        type = bp[1];
-       bp += 8;
-       /*
-        * Skip IGMP header
-        */
 
 
+       /* Skip IGMP header */
+       bp += 8;
        len -= 8;
 
        switch (type) {
 
        case DVMRP_PROBE:
        len -= 8;
 
        switch (type) {
 
        case DVMRP_PROBE:
-               printf(" Probe");
-               if (vflag)
-                       print_probe(bp, ep, len);
+               ND_PRINT((ndo, " Probe"));
+               if (ndo->ndo_vflag) {
+                       if (print_probe(ndo, bp, ep, len) < 0)
+                               goto trunc;
+               }
                break;
 
        case DVMRP_REPORT:
                break;
 
        case DVMRP_REPORT:
-               printf(" Report");
-               if (vflag)
-                       print_report(bp, ep, len);
+               ND_PRINT((ndo, " Report"));
+               if (ndo->ndo_vflag > 1) {
+                       if (print_report(ndo, bp, ep, len) < 0)
+                               goto trunc;
+               }
                break;
 
        case DVMRP_ASK_NEIGHBORS:
                break;
 
        case DVMRP_ASK_NEIGHBORS:
-               printf(" Ask-neighbors(old)");
+               ND_PRINT((ndo, " Ask-neighbors(old)"));
                break;
 
        case DVMRP_NEIGHBORS:
                break;
 
        case DVMRP_NEIGHBORS:
-               printf(" Neighbors(old)");
-               print_neighbors(bp, ep, len);
+               ND_PRINT((ndo, " Neighbors(old)"));
+               if (print_neighbors(ndo, bp, ep, len) < 0)
+                       goto trunc;
                break;
 
        case DVMRP_ASK_NEIGHBORS2:
                break;
 
        case DVMRP_ASK_NEIGHBORS2:
-               printf(" Ask-neighbors2");
+               ND_PRINT((ndo, " Ask-neighbors2"));
                break;
 
        case DVMRP_NEIGHBORS2:
                break;
 
        case DVMRP_NEIGHBORS2:
-               printf(" Neighbors2");
+               ND_PRINT((ndo, " Neighbors2"));
                /*
                 * extract version and capabilities from IGMP group
                 * address field
                 */
                bp -= 4;
                /*
                 * extract version and capabilities from IGMP group
                 * address field
                 */
                bp -= 4;
+               ND_TCHECK2(bp[0], 4);
                target_level = (bp[0] << 24) | (bp[1] << 16) |
                    (bp[2] << 8) | bp[3];
                bp += 4;
                target_level = (bp[0] << 24) | (bp[1] << 16) |
                    (bp[2] << 8) | bp[3];
                bp += 4;
-               print_neighbors2(bp, ep, len);
+               if (print_neighbors2(ndo, bp, ep, len) < 0)
+                       goto trunc;
                break;
 
        case DVMRP_PRUNE:
                break;
 
        case DVMRP_PRUNE:
-               printf(" Prune");
-               print_prune(bp, ep, len);
+               ND_PRINT((ndo, " Prune"));
+               if (print_prune(ndo, bp) < 0)
+                       goto trunc;
                break;
 
        case DVMRP_GRAFT:
                break;
 
        case DVMRP_GRAFT:
-               printf(" Graft");
-               print_graft(bp, ep, len);
+               ND_PRINT((ndo, " Graft"));
+               if (print_graft(ndo, bp) < 0)
+                       goto trunc;
                break;
 
        case DVMRP_GRAFT_ACK:
                break;
 
        case DVMRP_GRAFT_ACK:
-               printf(" Graft-ACK");
-               print_graft_ack(bp, ep, len);
+               ND_PRINT((ndo, " Graft-ACK"));
+               if (print_graft_ack(ndo, bp) < 0)
+                       goto trunc;
                break;
 
        default:
                break;
 
        default:
-               printf(" [type %d]", type);
+               ND_PRINT((ndo, " [type %d]", type));
                break;
        }
                break;
        }
+       return;
+
+trunc:
+       ND_PRINT((ndo, "[|dvmrp]"));
+       return;
 }
 
 }
 
-static void
-print_report(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+static int
+print_report(netdissect_options *ndo,
+             register const u_char *bp, register const u_char *ep,
+             register u_int len)
 {
 {
-       register u_int32_t mask, origin;
-       register int metric, i, width, done;
+       register uint32_t mask, origin;
+       register int metric, done;
+       register u_int i, width;
 
        while (len > 0) {
                if (len < 3) {
 
        while (len > 0) {
                if (len < 3) {
-                       printf(" [|]");
-                       return;
+                       ND_PRINT((ndo, " [|]"));
+                       return (0);
                }
                }
-               mask = (u_int32_t)0xff << 24 | bp[0] << 16 | bp[1] << 8 | bp[2];
+               ND_TCHECK2(bp[0], 3);
+               mask = (uint32_t)0xff << 24 | bp[0] << 16 | bp[1] << 8 | bp[2];
                width = 1;
                if (bp[0])
                        width = 2;
                width = 1;
                if (bp[0])
                        width = 2;
@@ -185,64 +181,75 @@ print_report(register const u_char *bp, register const u_char *ep,
                if (bp[2])
                        width = 4;
 
                if (bp[2])
                        width = 4;
 
-               printf("\n\tMask %s", intoa(htonl(mask)));
+               ND_PRINT((ndo, "\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(" [|]");
-                               return;
+                               ND_PRINT((ndo, " [|]"));
+                               return (0);
                        }
                        if (len < width + 1) {
                        }
                        if (len < width + 1) {
-                               printf("\n\t  [Truncated Report]");
-                               return;
+                               ND_PRINT((ndo, "\n\t  [Truncated Report]"));
+                               return (0);
                        }
                        origin = 0;
                        }
                        origin = 0;
-                       for (i = 0; i < width; ++i)
+                       for (i = 0; i < width; ++i) {
+                               ND_TCHECK(*bp);
                                origin = origin << 8 | *bp++;
                                origin = origin << 8 | *bp++;
+                       }
                        for ( ; i < 4; ++i)
                                origin <<= 8;
 
                        for ( ; i < 4; ++i)
                                origin <<= 8;
 
+                       ND_TCHECK(*bp);
                        metric = *bp++;
                        done = metric & 0x80;
                        metric &= 0x7f;
                        metric = *bp++;
                        done = metric & 0x80;
                        metric &= 0x7f;
-                       printf("\n\t  %s metric %d", intoa(htonl(origin)),
-                               metric);
+                       ND_PRINT((ndo, "\n\t  %s metric %d", intoa(htonl(origin)),
+                               metric));
                        len -= width + 1;
                } while (!done);
        }
                        len -= width + 1;
                } while (!done);
        }
+       return (0);
+trunc:
+       return (-1);
 }
 
 }
 
-static void
-print_probe(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+static int
+print_probe(netdissect_options *ndo,
+            register const u_char *bp, register const u_char *ep,
+            register u_int len)
 {
 {
-       register u_int32_t genid;
+       register uint32_t genid;
 
 
-       TCHECK2(bp[0], 4);
+       ND_TCHECK2(bp[0], 4);
        if ((len < 4) || ((bp + 4) > ep)) {
                /* { (ctags) */
        if ((len < 4) || ((bp + 4) > ep)) {
                /* { (ctags) */
-               printf(" [|}");
-               return;
+               ND_PRINT((ndo, " [|}"));
+               return (0);
        }
        genid = (bp[0] << 24) | (bp[1] << 16) | (bp[2] << 8) | bp[3];
        bp += 4;
        len -= 4;
        }
        genid = (bp[0] << 24) | (bp[1] << 16) | (bp[2] << 8) | bp[3];
        bp += 4;
        len -= 4;
-       printf("\n\tgenid %u", genid);
+       ND_PRINT((ndo, ndo->ndo_vflag > 1 ? "\n\t" : " "));
+       ND_PRINT((ndo, "genid %u", genid));
+       if (ndo->ndo_vflag < 2)
+               return (0);
 
        while ((len > 0) && (bp < ep)) {
 
        while ((len > 0) && (bp < ep)) {
-               TCHECK2(bp[0], 4);
-               printf("\n\tneighbor %s", ipaddr_string(bp));
+               ND_TCHECK2(bp[0], 4);
+               ND_PRINT((ndo, "\n\tneighbor %s", ipaddr_string(ndo, bp)));
                bp += 4; len -= 4;
        }
                bp += 4; len -= 4;
        }
-       return;
+       return (0);
 trunc:
 trunc:
-       (void)printf("[|dvmrp]");
+       return (-1);
 }
 
 }
 
-static void
-print_neighbors(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+static int
+print_neighbors(netdissect_options *ndo,
+                register const u_char *bp, register const u_char *ep,
+                register u_int len)
 {
        const u_char *laddr;
        register u_char metric;
 {
        const u_char *laddr;
        register u_char metric;
@@ -250,7 +257,7 @@ print_neighbors(register const u_char *bp, register const u_char *ep,
        register int ncount;
 
        while (len > 0 && bp < ep) {
        register int ncount;
 
        while (len > 0 && bp < ep) {
-               TCHECK2(bp[0], 7);
+               ND_TCHECK2(bp[0], 7);
                laddr = bp;
                bp += 4;
                metric = *bp++;
                laddr = bp;
                bp += 4;
                metric = *bp++;
@@ -258,33 +265,34 @@ print_neighbors(register const u_char *bp, register const u_char *ep,
                ncount = *bp++;
                len -= 7;
                while (--ncount >= 0) {
                ncount = *bp++;
                len -= 7;
                while (--ncount >= 0) {
-                       TCHECK2(bp[0], 4);
-                       printf(" [%s ->", ipaddr_string(laddr));
-                       printf(" %s, (%d/%d)]",
-                                  ipaddr_string(bp), metric, thresh);
+                       ND_TCHECK2(bp[0], 4);
+                       ND_PRINT((ndo, " [%s ->", ipaddr_string(ndo, laddr)));
+                       ND_PRINT((ndo, " %s, (%d/%d)]",
+                                  ipaddr_string(ndo, bp), metric, thresh));
                        bp += 4;
                        len -= 4;
                }
        }
                        bp += 4;
                        len -= 4;
                }
        }
-       return;
+       return (0);
 trunc:
 trunc:
-       (void)printf("[|dvmrp]");
+       return (-1);
 }
 
 }
 
-static void
-print_neighbors2(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+static int
+print_neighbors2(netdissect_options *ndo,
+                 register const u_char *bp, register const u_char *ep,
+                 register u_int len)
 {
        const u_char *laddr;
        register u_char metric, thresh, flags;
        register int ncount;
 
 {
        const u_char *laddr;
        register u_char metric, thresh, flags;
        register int ncount;
 
-       printf(" (v %d.%d):",
+       ND_PRINT((ndo, " (v %d.%d):",
               (int)target_level & 0xff,
               (int)target_level & 0xff,
-              (int)(target_level >> 8) & 0xff);
+              (int)(target_level >> 8) & 0xff));
 
        while (len > 0 && bp < ep) {
 
        while (len > 0 && bp < ep) {
-               TCHECK2(bp[0], 8);
+               ND_TCHECK2(bp[0], 8);
                laddr = bp;
                bp += 4;
                metric = *bp++;
                laddr = bp;
                bp += 4;
                metric = *bp++;
@@ -293,65 +301,65 @@ print_neighbors2(register const u_char *bp, register const u_char *ep,
                ncount = *bp++;
                len -= 8;
                while (--ncount >= 0 && (len >= 4) && (bp + 4) <= ep) {
                ncount = *bp++;
                len -= 8;
                while (--ncount >= 0 && (len >= 4) && (bp + 4) <= ep) {
-                       printf(" [%s -> ", ipaddr_string(laddr));
-                       printf("%s (%d/%d", ipaddr_string(bp),
-                                    metric, thresh);
+                       ND_PRINT((ndo, " [%s -> ", ipaddr_string(ndo, laddr)));
+                       ND_PRINT((ndo, "%s (%d/%d", ipaddr_string(ndo, bp),
+                                    metric, thresh));
                        if (flags & DVMRP_NF_TUNNEL)
                        if (flags & DVMRP_NF_TUNNEL)
-                               printf("/tunnel");
+                               ND_PRINT((ndo, "/tunnel"));
                        if (flags & DVMRP_NF_SRCRT)
                        if (flags & DVMRP_NF_SRCRT)
-                               printf("/srcrt");
+                               ND_PRINT((ndo, "/srcrt"));
                        if (flags & DVMRP_NF_QUERIER)
                        if (flags & DVMRP_NF_QUERIER)
-                               printf("/querier");
+                               ND_PRINT((ndo, "/querier"));
                        if (flags & DVMRP_NF_DISABLED)
                        if (flags & DVMRP_NF_DISABLED)
-                               printf("/disabled");
+                               ND_PRINT((ndo, "/disabled"));
                        if (flags & DVMRP_NF_DOWN)
                        if (flags & DVMRP_NF_DOWN)
-                               printf("/down");
-                       printf(")]");
+                               ND_PRINT((ndo, "/down"));
+                       ND_PRINT((ndo, ")]"));
                        bp += 4;
                        len -= 4;
                }
                if (ncount != -1) {
                        bp += 4;
                        len -= 4;
                }
                if (ncount != -1) {
-                       printf(" [|]");
-                       return;
+                       ND_PRINT((ndo, " [|]"));
+                       return (0);
                }
        }
                }
        }
-       return;
+       return (0);
 trunc:
 trunc:
-       (void)printf("[|dvmrp]");
+       return (-1);
 }
 
 }
 
-static void
-print_prune(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+static int
+print_prune(netdissect_options *ndo,
+            register const u_char *bp)
 {
 {
-       TCHECK2(bp[0], 12);
-       printf(" src %s grp %s", ipaddr_string(bp), ipaddr_string(bp + 4));
+       ND_TCHECK2(bp[0], 12);
+       ND_PRINT((ndo, " 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));
-       return;
+       ND_PRINT((ndo, " timer "));
+       relts_print(ndo, EXTRACT_32BITS(bp));
+       return (0);
 trunc:
 trunc:
-       (void)printf("[|dvmrp]");
+       return (-1);
 }
 
 }
 
-static void
-print_graft(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+static int
+print_graft(netdissect_options *ndo,
+            register const u_char *bp)
 {
 {
-       TCHECK2(bp[0], 8);
-       printf(" src %s grp %s", ipaddr_string(bp), ipaddr_string(bp + 4));
-       return;
+       ND_TCHECK2(bp[0], 8);
+       ND_PRINT((ndo, " src %s grp %s", ipaddr_string(ndo, bp), ipaddr_string(ndo, bp + 4)));
+       return (0);
 trunc:
 trunc:
-       (void)printf("[|dvmrp]");
+       return (-1);
 }
 
 }
 
-static void
-print_graft_ack(register const u_char *bp, register const u_char *ep,
-    register u_int len)
+static int
+print_graft_ack(netdissect_options *ndo,
+                register const u_char *bp)
 {
 {
-       TCHECK2(bp[0], 8);
-       printf(" src %s grp %s", ipaddr_string(bp), ipaddr_string(bp + 4));
-       return;
+       ND_TCHECK2(bp[0], 8);
+       ND_PRINT((ndo, " src %s grp %s", ipaddr_string(ndo, bp), ipaddr_string(ndo, bp + 4)));
+       return (0);
 trunc:
 trunc:
-       (void)printf("[|dvmrp]");
+       return (-1);
 }
 }
[mirror] the TCPdump network dissector