bgp: Parse BGP extended message support capability

[tcpdump] / print-atalk.c

diff --git a/print-atalk.c b/print-atalk.c
index 8faa29f0ce9cefeeb43985f43e970fcdd7f86362..4e1fa3d2163edd9c7536d0a6a2d3e277196edb76 100644 (file)
--- a/print-atalk.c
+++ b/print-atalk.c
@@ -30,13 +30,87 @@
 #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 "extract.h"
 #include "appletalk.h"
 
 #include "netdissect.h"
 #include "addrtoname.h"
 #include "ethertype.h"
 #include "extract.h"
 #include "appletalk.h"
 

+/* Datagram Delivery Protocol */
+
+struct atDDP {
+       nd_uint16_t     length;
+       nd_uint16_t     checksum;
+       nd_uint16_t     dstNet;
+       nd_uint16_t     srcNet;
+       nd_uint8_t      dstNode;
+       nd_uint8_t      srcNode;
+       nd_uint8_t      dstSkt;
+       nd_uint8_t      srcSkt;
+       nd_uint8_t      type;
+};
+#define        ddpSize         13
+
+struct atShortDDP {
+       nd_uint16_t     length;
+       nd_uint8_t      dstSkt;
+       nd_uint8_t      srcSkt;
+       nd_uint8_t      type;
+};
+#define        ddpSSize        5
+
+/* AppleTalk Transaction Protocol */
+
+struct atATP {
+       nd_uint8_t      control;
+       nd_uint8_t      bitmap;
+       nd_uint16_t     transID;
+       nd_uint32_t     userData;
+};
+
+#define        atpReqCode      0x40
+#define        atpRspCode      0x80
+#define        atpRelCode      0xC0
+#define        atpXO           0x20
+#define        atpEOM          0x10
+#define        atpSTS          0x08
+
+/* Name Binding Protocol */
+
+struct atNBP {
+       nd_uint8_t      control;
+       nd_uint8_t      id;
+};
+#define        nbpHeaderSize   2
+
+struct atNBPtuple {
+       nd_uint16_t     net;
+       nd_uint8_t      node;
+       nd_uint8_t      skt;
+       nd_uint8_t      enumerator;
+};
+#define        nbpTupleSize    5
+
+#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        ddpATP          3       /* ATP type */
+#define        ddpECHO         4       /* ECHO type */
+#define        ddpRTMPrequest  5       /* RTMP request type */
+#define        ddpIP           22      /* IP type */
+#define        ddpARP          23      /* ARP type */
+#define        ddpKLAP         0x4b    /* Kinetics KLAP type */
+#define        ddpEIGRP        88      /* EIGRP over Appletalk */

 static const struct tok type2str[] = {
        { ddpRTMP,              "rtmp" },
        { ddpRTMPrequest,       "rtmpReq" },
 static const struct tok type2str[] = {
        { ddpRTMP,              "rtmp" },
        { ddpRTMPrequest,       "rtmpReq" },


@@ -51,9 +125,9 @@ struct aarp {
        nd_uint16_t     htype, ptype;
        nd_uint8_t      halen, palen;
        nd_uint16_t     op;
        nd_uint16_t     htype, ptype;
        nd_uint8_t      halen, palen;
        nd_uint16_t     op;

-       uint8_t         hsaddr[6];
+       nd_mac_addr     hsaddr;

        uint8_t         psaddr[4];
        uint8_t         psaddr[4];

-       uint8_t         hdaddr[6];
+       nd_mac_addr     hdaddr;

        uint8_t         pdaddr[4];
 };
 
        uint8_t         pdaddr[4];
 };
 


@@ -61,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);


@@ -72,19 +144,12 @@ static const char *ddpskt_string(netdissect_options *, u_int);
 /*
  * Print LLAP packets received on a physical LocalTalk interface.
  */
 /*
  * Print LLAP packets received on a physical LocalTalk interface.
  */

-u_int
+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_if";
-       hdrlen = llap_print(ndo, p, h->len);
-       if (hdrlen == 0) {
-               /* Cut short by the snapshot length. */
-               return (h->caplen);
-       }
-       return (hdrlen);
+       ndo->ndo_protocol = "ltalk";
+       ndo->ndo_ll_hdr_len += llap_print(ndo, p, h->len);

 }
 
 /*
 }
 
 /*


@@ -101,74 +166,58 @@ 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);
        hdrlen = sizeof(*lp);
        lp = (const struct LAP *)bp;
        bp += sizeof(*lp);
        length -= sizeof(*lp);
        hdrlen = sizeof(*lp);

-       switch (EXTRACT_U_1(lp->type)) {
+       switch (GET_U_1(lp->type)) {

 
        case lapShortDDP:
 
        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",
                sdp = (const struct atShortDDP *)bp;
                ND_PRINT("%s.%s",

-                   ataddr_string(ndo, 0, EXTRACT_U_1(lp->src)), ddpskt_string(ndo, EXTRACT_U_1(sdp->srcSkt)));
+                   ataddr_string(ndo, 0, GET_U_1(lp->src)),
+                   ddpskt_string(ndo, GET_U_1(sdp->srcSkt)));

                ND_PRINT(" > %s.%s:",
                ND_PRINT(" > %s.%s:",

-                   ataddr_string(ndo, 0, EXTRACT_U_1(lp->dst)), ddpskt_string(ndo, EXTRACT_U_1(sdp->dstSkt)));
+                   ataddr_string(ndo, 0, GET_U_1(lp->dst)),
+                   ddpskt_string(ndo, GET_U_1(sdp->dstSkt)));

                bp += ddpSSize;
                length -= ddpSSize;
                hdrlen += ddpSSize;
                bp += ddpSSize;
                length -= ddpSSize;
                hdrlen += ddpSSize;

-               ddp_print(ndo, bp, length, EXTRACT_U_1(sdp->type), 0, EXTRACT_U_1(lp->src), EXTRACT_U_1(sdp->srcSkt));
+               ddp_print(ndo, bp, length, GET_U_1(sdp->type), 0,
+                         GET_U_1(lp->src), GET_U_1(sdp->srcSkt));

                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;
                dp = (const struct atDDP *)bp;

-               snet = EXTRACT_BE_U_2(dp->srcNet);
-               ND_PRINT("%s.%s", ataddr_string(ndo, snet, EXTRACT_U_1(dp->srcNode)),
-                   ddpskt_string(ndo, EXTRACT_U_1(dp->srcSkt)));
+               snet = GET_BE_U_2(dp->srcNet);
+               ND_PRINT("%s.%s",
+                        ataddr_string(ndo, snet, GET_U_1(dp->srcNode)),
+                        ddpskt_string(ndo, GET_U_1(dp->srcSkt)));

                ND_PRINT(" > %s.%s:",
                ND_PRINT(" > %s.%s:",

-                   ataddr_string(ndo, EXTRACT_BE_U_2(dp->dstNet), EXTRACT_U_1(dp->dstNode)),
-                   ddpskt_string(ndo, EXTRACT_U_1(dp->dstSkt)));
+                   ataddr_string(ndo, GET_BE_U_2(dp->dstNet), GET_U_1(dp->dstNode)),
+                   ddpskt_string(ndo, GET_U_1(dp->dstSkt)));

                bp += ddpSize;
                length -= ddpSize;
                hdrlen += ddpSize;
                bp += ddpSize;
                length -= ddpSize;
                hdrlen += ddpSize;

-               ddp_print(ndo, bp, length, EXTRACT_U_1(dp->type), snet, EXTRACT_U_1(dp->srcNode), EXTRACT_U_1(dp->srcSkt));
-               break;
-
-#ifdef notdef
-       case lapKLAP:
-               klap_print(bp, length);
+               ddp_print(ndo, bp, length, GET_U_1(dp->type), snet,
+                         GET_U_1(dp->srcNode), GET_U_1(dp->srcSkt));

                break;
                break;

-#endif

 
        default:
                ND_PRINT("%u > %u at-lap#%u %u",
 
        default:
                ND_PRINT("%u > %u at-lap#%u %u",

-                   EXTRACT_U_1(lp->src), EXTRACT_U_1(lp->dst), EXTRACT_U_1(lp->type), length);
+                   GET_U_1(lp->src), GET_U_1(lp->dst), GET_U_1(lp->type),
+                   length);

                break;
        }
        return (hdrlen);
                break;
        }
        return (hdrlen);

+invalid:
+       nd_print_invalid(ndo);
+       return length;

 }
 
 /*
 }
 
 /*


@@ -187,24 +236,21 @@ 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;
        dp = (const struct atDDP *)bp;

-       snet = EXTRACT_BE_U_2(dp->srcNet);
-       ND_PRINT("%s.%s", ataddr_string(ndo, snet, EXTRACT_U_1(dp->srcNode)),
-              ddpskt_string(ndo, EXTRACT_U_1(dp->srcSkt)));
+       snet = GET_BE_U_2(dp->srcNet);
+       ND_PRINT("%s.%s", ataddr_string(ndo, snet, GET_U_1(dp->srcNode)),
+                ddpskt_string(ndo, GET_U_1(dp->srcSkt)));

        ND_PRINT(" > %s.%s: ",
        ND_PRINT(" > %s.%s: ",

-              ataddr_string(ndo, EXTRACT_BE_U_2(dp->dstNet), EXTRACT_U_1(dp->dstNode)),
-              ddpskt_string(ndo, EXTRACT_U_1(dp->dstSkt)));
+              ataddr_string(ndo, GET_BE_U_2(dp->dstNet), GET_U_1(dp->dstNode)),
+              ddpskt_string(ndo, GET_U_1(dp->dstSkt)));

        bp += ddpSize;
        length -= ddpSize;
        bp += ddpSize;
        length -= ddpSize;

-       ddp_print(ndo, bp, length, EXTRACT_U_1(dp->type), snet, EXTRACT_U_1(dp->srcNode), EXTRACT_U_1(dp->srcSkt));
+       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() */


@@ -214,31 +260,26 @@ 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;
-       }
-       if (EXTRACT_BE_U_2(ap->htype) == 1 &&
-           EXTRACT_BE_U_2(ap->ptype) == ETHERTYPE_ATALK &&
-           EXTRACT_U_1(ap->halen) == 6 && EXTRACT_U_1(ap->palen) == 4 )
-               switch (EXTRACT_BE_U_2(ap->op)) {
+       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)
+               switch (GET_BE_U_2(ap->op)) {

 
                case 1:                         /* request */
                        ND_PRINT("who-has %s tell %s", AT(pdaddr), AT(psaddr));
                        return;
 
                case 2:                         /* response */
 
                case 1:                         /* request */
                        ND_PRINT("who-has %s tell %s", AT(pdaddr), AT(psaddr));
                        return;
 
                case 2:                         /* response */

-                       ND_PRINT("reply %s is-at %s", AT(psaddr), etheraddr_string(ndo, ap->hsaddr));
+                       ND_PRINT("reply %s is-at %s", AT(psaddr), GET_ETHERADDR_STRING(ap->hsaddr));

                        return;
 
                case 3:                         /* probe (oy!) */
                        return;
 
                case 3:                         /* probe (oy!) */


@@ -246,8 +287,11 @@ aarp_print(netdissect_options *ndo,
                        return;
                }
        ND_PRINT("len %u op %u htype %u ptype %#x halen %u palen %u",
                        return;
                }
        ND_PRINT("len %u op %u htype %u ptype %#x halen %u palen %u",

-           length, EXTRACT_BE_U_2(ap->op), EXTRACT_BE_U_2(ap->htype),
-           EXTRACT_BE_U_2(ap->ptype), EXTRACT_U_1(ap->halen), EXTRACT_U_1(ap->palen));
+           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);

 }
 
 /*
 }
 
 /*


@@ -286,25 +330,18 @@ 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);
        length -= sizeof(*ap);

-       control = EXTRACT_U_1(ap->control);
+       control = GET_U_1(ap->control);

        switch (control & 0xc0) {
 
        case atpReqCode:
                ND_PRINT(" atp-req%s %u",
                             control & atpXO? " " : "*",
        switch (control & 0xc0) {
 
        case atpReqCode:
                ND_PRINT(" atp-req%s %u",
                             control & atpXO? " " : "*",

-                            EXTRACT_BE_U_2(ap->transID));
+                            GET_BE_U_2(ap->transID));

 
 

-               atp_bitmap_print(ndo, EXTRACT_U_1(ap->bitmap));
+               atp_bitmap_print(ndo, GET_U_1(ap->bitmap));

 
                if (length != 0)
                        ND_PRINT(" [len=%u]", length);
 
                if (length != 0)
                        ND_PRINT(" [len=%u]", length);


@@ -325,7 +362,8 @@ atp_print(netdissect_options *ndo,
        case atpRspCode:
                ND_PRINT(" atp-resp%s%u:%u (%u)",
                             control & atpEOM? "*" : " ",
        case atpRspCode:
                ND_PRINT(" atp-resp%s%u:%u (%u)",
                             control & atpEOM? "*" : " ",

-                            EXTRACT_BE_U_2(ap->transID), EXTRACT_U_1(ap->bitmap), length);
+                            GET_BE_U_2(ap->transID), GET_U_1(ap->bitmap),
+                            length);

                switch (control & (atpXO|atpSTS)) {
                case atpXO:
                        ND_PRINT(" [XO]");
                switch (control & (atpXO|atpSTS)) {
                case atpXO:
                        ND_PRINT(" [XO]");


@@ -340,9 +378,9 @@ atp_print(netdissect_options *ndo,
                break;
 
        case atpRelCode:
                break;
 
        case atpRelCode:

-               ND_PRINT(" atp-rel  %u", EXTRACT_BE_U_2(ap->transID));
+               ND_PRINT(" atp-rel  %u", GET_BE_U_2(ap->transID));

 
 

-               atp_bitmap_print(ndo, EXTRACT_U_1(ap->bitmap));
+               atp_bitmap_print(ndo, GET_U_1(ap->bitmap));

 
                /* length should be zero */
                if (length)
 
                /* length should be zero */
                if (length)


@@ -368,12 +406,15 @@ atp_print(netdissect_options *ndo,
 
        default:
                ND_PRINT(" atp-0x%x  %u (%u)", control,
 
        default:
                ND_PRINT(" atp-0x%x  %u (%u)", control,

-                            EXTRACT_BE_U_2(ap->transID), length);
+                            GET_BE_U_2(ap->transID), length);

                break;
        }
                break;
        }

-       data = EXTRACT_BE_U_4(ap->userData);
+       data = GET_BE_U_4(ap->userData);

        if (data != 0)
                ND_PRINT(" 0x%x", data);
        if (data != 0)
                ND_PRINT(" 0x%x", data);

+       return;
+invalid:
+       nd_print_invalid(ndo);

 }
 
 static void
 }
 
 static void


@@ -416,36 +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 = EXTRACT_U_1(np->control);
-       switch (i = (control & 0xf0)) {
+       control = GET_U_1(np->control);
+       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:", EXTRACT_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


@@ -453,95 +477,83 @@ nbp_print(netdissect_options *ndo,
                 */
                if ((control & 0xf) != 1)
                        ND_PRINT(" [ntup=%u]", control & 0xf);
                 */
                if ((control & 0xf) != 1)
                        ND_PRINT(" [ntup=%u]", control & 0xf);

-               if (EXTRACT_U_1(tp->enumerator))
-                       ND_PRINT(" [enum=%u]", EXTRACT_U_1(tp->enumerator));
-               if (EXTRACT_BE_U_2(tp->net) != snet ||
-                   EXTRACT_U_1(tp->node) != snode ||
-                   EXTRACT_U_1(tp->skt) != skt)
+               if (GET_U_1(tp->enumerator))
+                       ND_PRINT(" [enum=%u]", GET_U_1(tp->enumerator));
+               if (GET_BE_U_2(tp->net) != snet ||
+                   GET_U_1(tp->node) != snode ||
+                   GET_U_1(tp->skt) != skt)

                        ND_PRINT(" [addr=%s.%u]",
                        ND_PRINT(" [addr=%s.%u]",

-                           ataddr_string(ndo, EXTRACT_BE_U_2(tp->net),
-                                         EXTRACT_U_1(tp->node)),
-                           EXTRACT_U_1(tp->skt));
+                           ataddr_string(ndo, GET_BE_U_2(tp->net),
+                                         GET_U_1(tp->node)),
+                           GET_U_1(tp->skt));

                break;
 
        case nbpLkUpReply:
                break;
 
        case nbpLkUpReply:

-               ND_PRINT(" nbp-reply %u:", EXTRACT_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, EXTRACT_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 = EXTRACT_U_1(cp);
+       length = GET_U_1(cp);

        cp++;
 
        /* Spec says string can be at most 32 bytes long */
        if (length > 32) {
                ND_PRINT("[len=%u]", length);
        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, EXTRACT_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 the enumerator isn't 1, print it */

-       if (EXTRACT_U_1(tp->enumerator) != 1)
-               ND_PRINT("(%u)", EXTRACT_U_1(tp->enumerator));
+       if (GET_U_1(tp->enumerator) != 1)
+               ND_PRINT("(%u)", GET_U_1(tp->enumerator));

 
        /* if the socket doesn't match the src socket, print it */
 
        /* if the socket doesn't match the src socket, print it */

-       if (EXTRACT_U_1(tp->skt) != skt)
-               ND_PRINT(" %u", EXTRACT_U_1(tp->skt));
+       if (GET_U_1(tp->skt) != skt)
+               ND_PRINT(" %u", GET_U_1(tp->skt));

 
        /* if the address doesn't match the src address, it's an anomaly */
 
        /* if the address doesn't match the src address, it's an anomaly */

-       if (EXTRACT_BE_U_2(tp->net) != snet ||
-           EXTRACT_U_1(tp->node) != snode)
+       if (GET_BE_U_2(tp->net) != snet ||
+           GET_U_1(tp->node) != snode)

                ND_PRINT(" [addr=%s]",
                ND_PRINT(" [addr=%s]",

-                   ataddr_string(ndo, EXTRACT_BE_U_2(tp->net), EXTRACT_U_1(tp->node)));
+                   ataddr_string(ndo, GET_BE_U_2(tp->net), GET_U_1(tp->node)));

 
        return (tpn);
 }
 
 static const struct atNBPtuple *
 nbp_name_print(netdissect_options *ndo,
 
        return (tpn);
 }
 
 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;
 


@@ -549,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("\"");
                }
        }


@@ -625,7 +637,7 @@ ataddr_string(netdissect_options *ndo,
                                        if (tp->name == NULL)
                                                (*ndo->ndo_error)(ndo,
                                                    S_ERR_ND_MEM_ALLOC,
                                        if (tp->name == NULL)
                                                (*ndo->ndo_error)(ndo,
                                                    S_ERR_ND_MEM_ALLOC,

-                                                   "ataddr_string: strdup(nambuf)");
+                                                   "%s: strdup(nambuf)", __func__);

                                }
                                fclose(fp);
                        }
                                }
                                fclose(fp);
                        }


@@ -645,29 +657,33 @@ ataddr_string(netdissect_options *ndo,
                if (tp2->addr == i) {
                        tp->addr = (atnet << 8) | athost;
                        tp->nxt = newhnamemem(ndo);
                if (tp2->addr == i) {
                        tp->addr = (atnet << 8) | athost;
                        tp->nxt = newhnamemem(ndo);

-                       (void)nd_snprintf(nambuf, sizeof(nambuf), "%s.%u",
+                       (void)snprintf(nambuf, sizeof(nambuf), "%s.%u",

                            tp2->name, athost);
                        tp->name = strdup(nambuf);
                        if (tp->name == NULL)
                                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                            tp2->name, athost);
                        tp->name = strdup(nambuf);
                        if (tp->name == NULL)
                                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                       "ataddr_string: strdup(nambuf)");
+                                       "%s: strdup(nambuf)", __func__);

                        return (tp->name);
                }
 
        tp->addr = (atnet << 8) | athost;
        tp->nxt = newhnamemem(ndo);
        if (athost != 255)
                        return (tp->name);
                }
 
        tp->addr = (atnet << 8) | athost;
        tp->nxt = newhnamemem(ndo);
        if (athost != 255)

-               (void)nd_snprintf(nambuf, sizeof(nambuf), "%u.%u", atnet, athost);
+               (void)snprintf(nambuf, sizeof(nambuf), "%u.%u", atnet, athost);

        else
        else

-               (void)nd_snprintf(nambuf, sizeof(nambuf), "%u", atnet);
+               (void)snprintf(nambuf, sizeof(nambuf), "%u", atnet);

        tp->name = strdup(nambuf);
        if (tp->name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
        tp->name = strdup(nambuf);
        if (tp->name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                 "ataddr_string: strdup(nambuf)");
+                                 "%s: strdup(nambuf)", __func__);

 
        return (tp->name);
 }
 
 
        return (tp->name);
 }
 

+#define rtmpSkt 1
+#define nbpSkt  2
+#define echoSkt 4
+#define zipSkt  6

 static const struct tok skt2str[] = {
        { rtmpSkt,      "rtmp" },       /* routing table maintenance */
        { nbpSkt,       "nis" },        /* name info socket */
 static const struct tok skt2str[] = {
        { rtmpSkt,      "rtmp" },       /* routing table maintenance */
        { nbpSkt,       "nis" },        /* name info socket */


@@ -683,7 +699,7 @@ ddpskt_string(netdissect_options *ndo,
        static char buf[8];
 
        if (ndo->ndo_nflag) {
        static char buf[8];
 
        if (ndo->ndo_nflag) {

-               (void)nd_snprintf(buf, sizeof(buf), "%u", skt);
+               (void)snprintf(buf, sizeof(buf), "%u", skt);

                return (buf);
        }
        return (tok2str(skt2str, "%u", skt));
                return (buf);
        }
        return (tok2str(skt2str, "%u", skt));