]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-atalk.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Try the new ND_LCHECK*() macros. [skip ci]
[tcpdump] / print-atalk.c
diff --git a/print-atalk.c b/print-atalk.c
index ae19139700c126a0cd0ecef5028cd19ebcac1a83..4e1fa3d2163edd9c7536d0a6a2d3e277196edb76 100644 (file)
--- a/print-atalk.c
+++ b/print-atalk.c
@@ -30,6 +30,7 @@
 #include <stdio.h>
 #include <string.h>
 
 #include <stdio.h>
 #include <string.h>
 
+#define ND_LONGJMP_FROM_TCHECK
 #include "netdissect.h"
 #include "addrtoname.h"
 #include "ethertype.h"
 #include "netdissect.h"
 #include "addrtoname.h"
 #include "ethertype.h"
@@ -94,6 +95,12 @@ struct atNBPtuple {
 #define        nbpBrRq         0x10
 #define        nbpLkUp         0x20
 #define        nbpLkUpReply    0x30
 #define        nbpBrRq         0x10
 #define        nbpLkUp         0x20
 #define        nbpLkUpReply    0x30
+static const struct tok nbp_str[] = {
+       { nbpBrRq,      "brRq"  },
+       { nbpLkUp,      "lkup"  },
+       { nbpLkUpReply, "reply" },
+       { 0, NULL }
+};
 
 #define        ddpRTMP         1       /* RTMP type */
 #define        ddpNBP          2       /* NBP type */
 
 #define        ddpRTMP         1       /* RTMP type */
 #define        ddpNBP          2       /* NBP type */
@@ -128,10 +135,8 @@ static void atp_print(netdissect_options *, const struct atATP *, u_int);
 static void atp_bitmap_print(netdissect_options *, u_char);
 static void nbp_print(netdissect_options *, const struct atNBP *, u_int, u_short, u_char, u_char);
 static const struct atNBPtuple *nbp_tuple_print(netdissect_options *ndo, const struct atNBPtuple *,
 static void atp_bitmap_print(netdissect_options *, u_char);
 static void nbp_print(netdissect_options *, const struct atNBP *, u_int, u_short, u_char, u_char);
 static const struct atNBPtuple *nbp_tuple_print(netdissect_options *ndo, const struct atNBPtuple *,
-                                               const u_char *,
                                                u_short, u_char, u_char);
                                                u_short, u_char, u_char);
-static const struct atNBPtuple *nbp_name_print(netdissect_options *, const struct atNBPtuple *,
-                                              const u_char *);
+static const struct atNBPtuple *nbp_name_print(netdissect_options *, const struct atNBPtuple *);
 static const char *ataddr_string(netdissect_options *, u_short, u_char);
 static void ddp_print(netdissect_options *, const u_char *, u_int, u_int, u_short, u_char, u_char);
 static const char *ddpskt_string(netdissect_options *, u_int);
 static const char *ataddr_string(netdissect_options *, u_short, u_char);
 static void ddp_print(netdissect_options *, const u_char *, u_int, u_int, u_short, u_char, u_char);
 static const char *ddpskt_string(netdissect_options *, u_int);
@@ -143,16 +148,8 @@ void
 ltalk_if_print(netdissect_options *ndo,
                const struct pcap_pkthdr *h, const u_char *p)
 {
 ltalk_if_print(netdissect_options *ndo,
                const struct pcap_pkthdr *h, const u_char *p)
 {
-       u_int hdrlen;
-
        ndo->ndo_protocol = "ltalk";
        ndo->ndo_protocol = "ltalk";
-       hdrlen = llap_print(ndo, p, h->len);
-       if (hdrlen == 0) {
-               /* Cut short by the snapshot length. */
-               ndo->ndo_ll_hdr_len += h->caplen;
-               return;
-       }
-       ndo->ndo_ll_hdr_len += hdrlen;
+       ndo->ndo_ll_hdr_len += llap_print(ndo, p, h->len);
 }
 
 /*
 }
 
 /*
@@ -169,14 +166,7 @@ llap_print(netdissect_options *ndo,
        u_int hdrlen;
 
        ndo->ndo_protocol = "llap";
        u_int hdrlen;
 
        ndo->ndo_protocol = "llap";
-       if (length < sizeof(*lp)) {
-               ND_PRINT(" [|llap %u]", length);
-               return (length);
-       }
-       if (!ND_TTEST_LEN(bp, sizeof(*lp))) {
-               nd_print_trunc(ndo);
-               return (0);     /* cut short by the snapshot length */
-       }
+       ND_LCHECKMSG_ZU(length, sizeof(*lp), "LLAP length");
        lp = (const struct LAP *)bp;
        bp += sizeof(*lp);
        length -= sizeof(*lp);
        lp = (const struct LAP *)bp;
        bp += sizeof(*lp);
        length -= sizeof(*lp);
@@ -184,14 +174,8 @@ llap_print(netdissect_options *ndo,
        switch (GET_U_1(lp->type)) {
 
        case lapShortDDP:
        switch (GET_U_1(lp->type)) {
 
        case lapShortDDP:
-               if (length < ddpSSize) {
-                       ND_PRINT(" [|sddp %u]", length);
-                       return (length);
-               }
-               if (!ND_TTEST_LEN(bp, ddpSSize)) {
-                       ND_PRINT(" [|sddp]");
-                       return (0);     /* cut short by the snapshot length */
-               }
+               ndo->ndo_protocol = "sddp";
+               ND_LCHECKMSG_U(length, ddpSSize, "SDDP length");
                sdp = (const struct atShortDDP *)bp;
                ND_PRINT("%s.%s",
                    ataddr_string(ndo, 0, GET_U_1(lp->src)),
                sdp = (const struct atShortDDP *)bp;
                ND_PRINT("%s.%s",
                    ataddr_string(ndo, 0, GET_U_1(lp->src)),
@@ -207,14 +191,8 @@ llap_print(netdissect_options *ndo,
                break;
 
        case lapDDP:
                break;
 
        case lapDDP:
-               if (length < ddpSize) {
-                       ND_PRINT(" [|ddp %u]", length);
-                       return (length);
-               }
-               if (!ND_TTEST_LEN(bp, ddpSize)) {
-                       ND_PRINT(" [|ddp]");
-                       return (0);     /* cut short by the snapshot length */
-               }
+               ndo->ndo_protocol = "ddp";
+               ND_LCHECKMSG_U(length, ddpSize, "DDP length");
                dp = (const struct atDDP *)bp;
                snet = GET_BE_U_2(dp->srcNet);
                ND_PRINT("%s.%s",
                dp = (const struct atDDP *)bp;
                snet = GET_BE_U_2(dp->srcNet);
                ND_PRINT("%s.%s",
@@ -237,6 +215,9 @@ llap_print(netdissect_options *ndo,
                break;
        }
        return (hdrlen);
                break;
        }
        return (hdrlen);
+invalid:
+       nd_print_invalid(ndo);
+       return length;
 }
 
 /*
 }
 
 /*
@@ -255,14 +236,7 @@ atalk_print(netdissect_options *ndo,
         if(!ndo->ndo_eflag)
             ND_PRINT("AT ");
 
         if(!ndo->ndo_eflag)
             ND_PRINT("AT ");
 
-       if (length < ddpSize) {
-               ND_PRINT(" [|ddp %u]", length);
-               return;
-       }
-       if (!ND_TTEST_LEN(bp, ddpSize)) {
-               ND_PRINT(" [|ddp]");
-               return;
-       }
+       ND_LCHECK_U(length, ddpSize);
        dp = (const struct atDDP *)bp;
        snet = GET_BE_U_2(dp->srcNet);
        ND_PRINT("%s.%s", ataddr_string(ndo, snet, GET_U_1(dp->srcNode)),
        dp = (const struct atDDP *)bp;
        snet = GET_BE_U_2(dp->srcNet);
        ND_PRINT("%s.%s", ataddr_string(ndo, snet, GET_U_1(dp->srcNode)),
@@ -274,6 +248,9 @@ atalk_print(netdissect_options *ndo,
        length -= ddpSize;
        ddp_print(ndo, bp, length, GET_U_1(dp->type), snet,
                  GET_U_1(dp->srcNode), GET_U_1(dp->srcSkt));
        length -= ddpSize;
        ddp_print(ndo, bp, length, GET_U_1(dp->type), snet,
                  GET_U_1(dp->srcNode), GET_U_1(dp->srcSkt));
+       return;
+invalid:
+       nd_print_invalid(ndo);
 }
 
 /* XXX should probably pass in the snap header and do checks like arp_print() */
 }
 
 /* XXX should probably pass in the snap header and do checks like arp_print() */
@@ -283,20 +260,15 @@ aarp_print(netdissect_options *ndo,
 {
        const struct aarp *ap;
 
 {
        const struct aarp *ap;
 
-#define AT(member) ataddr_string(ndo, (ap->member[1]<<8)|ap->member[2],ap->member[3])
+#define AT(member) ataddr_string(ndo, \
+       (GET_U_1(&ap->member[1])<<8)|GET_U_1(&ap->member[2]), \
+       GET_U_1(&ap->member[3]))
 
        ndo->ndo_protocol = "aarp";
        ND_PRINT("aarp ");
        ap = (const struct aarp *)bp;
 
        ndo->ndo_protocol = "aarp";
        ND_PRINT("aarp ");
        ap = (const struct aarp *)bp;
-       if (!ND_TTEST_SIZE(ap)) {
-               /* Just bail if we don't have the whole chunk. */
-               nd_print_trunc(ndo);
-               return;
-       }
-       if (length < sizeof(*ap)) {
-               ND_PRINT(" [|aarp %u]", length);
-               return;
-       }
+       ND_LCHECK_ZU(length, sizeof(*ap));
+       ND_TCHECK_SIZE(ap);
        if (GET_BE_U_2(ap->htype) == 1 &&
            GET_BE_U_2(ap->ptype) == ETHERTYPE_ATALK &&
            GET_U_1(ap->halen) == MAC_ADDR_LEN && GET_U_1(ap->palen) == 4)
        if (GET_BE_U_2(ap->htype) == 1 &&
            GET_BE_U_2(ap->ptype) == ETHERTYPE_ATALK &&
            GET_U_1(ap->halen) == MAC_ADDR_LEN && GET_U_1(ap->palen) == 4)
@@ -317,6 +289,9 @@ aarp_print(netdissect_options *ndo,
        ND_PRINT("len %u op %u htype %u ptype %#x halen %u palen %u",
            length, GET_BE_U_2(ap->op), GET_BE_U_2(ap->htype),
            GET_BE_U_2(ap->ptype), GET_U_1(ap->halen), GET_U_1(ap->palen));
        ND_PRINT("len %u op %u htype %u ptype %#x halen %u palen %u",
            length, GET_BE_U_2(ap->op), GET_BE_U_2(ap->htype),
            GET_BE_U_2(ap->ptype), GET_U_1(ap->halen), GET_U_1(ap->palen));
+       return;
+invalid:
+       nd_print_invalid(ndo);
 }
 
 /*
 }
 
 /*
@@ -355,15 +330,8 @@ atp_print(netdissect_options *ndo,
        uint8_t control;
        uint32_t data;
 
        uint8_t control;
        uint32_t data;
 
-       if ((const u_char *)(ap + 1) > ndo->ndo_snapend) {
-               /* Just bail if we don't have the whole chunk. */
-               nd_print_trunc(ndo);
-               return;
-       }
-       if (length < sizeof(*ap)) {
-               ND_PRINT(" [|atp %u]", length);
-               return;
-       }
+       ndo->ndo_protocol = "atp";
+       ND_LCHECKMSG_ZU(length, sizeof(*ap), "ATP length");
        length -= sizeof(*ap);
        control = GET_U_1(ap->control);
        switch (control & 0xc0) {
        length -= sizeof(*ap);
        control = GET_U_1(ap->control);
        switch (control & 0xc0) {
@@ -444,6 +412,9 @@ atp_print(netdissect_options *ndo,
        data = GET_BE_U_4(ap->userData);
        if (data != 0)
                ND_PRINT(" 0x%x", data);
        data = GET_BE_U_4(ap->userData);
        if (data != 0)
                ND_PRINT(" 0x%x", data);
+       return;
+invalid:
+       nd_print_invalid(ndo);
 }
 
 static void
 }
 
 static void
@@ -486,37 +457,19 @@ nbp_print(netdissect_options *ndo,
                (const struct atNBPtuple *)((const u_char *)np + nbpHeaderSize);
        uint8_t control;
        u_int i;
                (const struct atNBPtuple *)((const u_char *)np + nbpHeaderSize);
        uint8_t control;
        u_int i;
-       const u_char *ep;
-
-       if (length < nbpHeaderSize) {
-               ND_PRINT(" truncated-nbp %u", length);
-               return;
-       }
 
 
+       /* must be room for at least one tuple */
+       ND_LCHECKMSG_U(length, nbpHeaderSize + 8, "undersized-nbp");
        length -= nbpHeaderSize;
        length -= nbpHeaderSize;
-       if (length < 8) {
-               /* must be room for at least one tuple */
-               ND_PRINT(" truncated-nbp %u", length + nbpHeaderSize);
-               return;
-       }
-       /* ep points to end of available data */
-       ep = ndo->ndo_snapend;
-       if ((const u_char *)tp > ep) {
-               nd_print_trunc(ndo);
-               return;
-       }
        control = GET_U_1(np->control);
        control = GET_U_1(np->control);
-       switch (i = (control & 0xf0)) {
+       ND_PRINT(" nbp-%s", tok2str(nbp_str, "0x%x", control & 0xf0));
+       ND_PRINT(" %u", GET_U_1(np->id));
+       switch (control & 0xf0) {
 
        case nbpBrRq:
        case nbpLkUp:
 
        case nbpBrRq:
        case nbpLkUp:
-               ND_PRINT(i == nbpLkUp? " nbp-lkup %u:":" nbp-brRq %u:",
-                        GET_U_1(np->id));
-               if ((const u_char *)(tp + 1) > ep) {
-                       nd_print_trunc(ndo);
-                       return;
-               }
-               (void)nbp_name_print(ndo, tp, ep);
+               ND_PRINT(":");
+               (void)nbp_name_print(ndo, tp);
                /*
                 * look for anomalies: the spec says there can only
                 * be one tuple, the address must match the source
                /*
                 * look for anomalies: the spec says there can only
                 * be one tuple, the address must match the source
@@ -536,63 +489,50 @@ nbp_print(netdissect_options *ndo,
                break;
 
        case nbpLkUpReply:
                break;
 
        case nbpLkUpReply:
-               ND_PRINT(" nbp-reply %u:", GET_U_1(np->id));
+               ND_PRINT(":");
 
                /* print each of the tuples in the reply */
                for (i = control & 0xf; i != 0 && tp; i--)
 
                /* print each of the tuples in the reply */
                for (i = control & 0xf; i != 0 && tp; i--)
-                       tp = nbp_tuple_print(ndo, tp, ep, snet, snode, skt);
+                       tp = nbp_tuple_print(ndo, tp, snet, snode, skt);
                break;
 
        default:
                break;
 
        default:
-               ND_PRINT(" nbp-0x%x  %u (%u)", control, GET_U_1(np->id),
-                        length);
+               ND_PRINT("  (%u)", length);
                break;
        }
                break;
        }
+       return;
+invalid:
+       nd_print_invalid(ndo);
 }
 
 /* print a counted string */
 static const u_char *
 print_cstring(netdissect_options *ndo,
 }
 
 /* print a counted string */
 static const u_char *
 print_cstring(netdissect_options *ndo,
-              const u_char *cp, const u_char *ep)
+              const u_char *cp)
 {
        u_int length;
 
 {
        u_int length;
 
-       if (cp >= ep) {
-               nd_print_trunc(ndo);
-               return (0);
-       }
        length = GET_U_1(cp);
        cp++;
 
        /* Spec says string can be at most 32 bytes long */
        if (length > 32) {
                ND_PRINT("[len=%u]", length);
        length = GET_U_1(cp);
        cp++;
 
        /* Spec says string can be at most 32 bytes long */
        if (length > 32) {
                ND_PRINT("[len=%u]", length);
-               return (0);
+               ND_TCHECK_LEN(cp, length);
+               return NULL;
        }
        }
-       while (length != 0) {
-               if (cp >= ep) {
-                       nd_print_trunc(ndo);
-                       return (0);
-               }
-               fn_print_char(ndo, GET_U_1(cp));
-               cp++;
-               length--;
-       }
-       return (cp);
+       nd_printjn(ndo, cp, length);
+       return cp + length;
 }
 
 static const struct atNBPtuple *
 nbp_tuple_print(netdissect_options *ndo,
 }
 
 static const struct atNBPtuple *
 nbp_tuple_print(netdissect_options *ndo,
-                const struct atNBPtuple *tp, const u_char *ep,
+                const struct atNBPtuple *tp,
                 u_short snet, u_char snode, u_char skt)
 {
        const struct atNBPtuple *tpn;
 
                 u_short snet, u_char snode, u_char skt)
 {
        const struct atNBPtuple *tpn;
 
-       if ((const u_char *)(tp + 1) > ep) {
-               nd_print_trunc(ndo);
-               return 0;
-       }
-       tpn = nbp_name_print(ndo, tp, ep);
+       tpn = nbp_name_print(ndo, tp);
 
        /* if the enumerator isn't 1, print it */
        if (GET_U_1(tp->enumerator) != 1)
 
        /* if the enumerator isn't 1, print it */
        if (GET_U_1(tp->enumerator) != 1)
@@ -613,7 +553,7 @@ nbp_tuple_print(netdissect_options *ndo,
 
 static const struct atNBPtuple *
 nbp_name_print(netdissect_options *ndo,
 
 static const struct atNBPtuple *
 nbp_name_print(netdissect_options *ndo,
-               const struct atNBPtuple *tp, const u_char *ep)
+               const struct atNBPtuple *tp)
 {
        const u_char *cp = (const u_char *)tp + nbpTupleSize;
 
 {
        const u_char *cp = (const u_char *)tp + nbpTupleSize;
 
@@ -621,13 +561,13 @@ nbp_name_print(netdissect_options *ndo,
 
        /* Object */
        ND_PRINT("\"");
 
        /* Object */
        ND_PRINT("\"");
-       if ((cp = print_cstring(ndo, cp, ep)) != NULL) {
+       if ((cp = print_cstring(ndo, cp)) != NULL) {
                /* Type */
                ND_PRINT(":");
                /* Type */
                ND_PRINT(":");
-               if ((cp = print_cstring(ndo, cp, ep)) != NULL) {
+               if ((cp = print_cstring(ndo, cp)) != NULL) {
                        /* Zone */
                        ND_PRINT("@");
                        /* Zone */
                        ND_PRINT("@");
-                       if ((cp = print_cstring(ndo, cp, ep)) != NULL)
+                       if ((cp = print_cstring(ndo, cp)) != NULL)
                                ND_PRINT("\"");
                }
        }
                                ND_PRINT("\"");
                }
        }
[mirror] the TCPdump network dissector