]> The Tcpdump Group git mirrors - tcpdump/blobdiff - print-atalk.c
projects / tcpdump / blobdiff
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
bgp: Parse BGP extended message support capability
[tcpdump] / print-atalk.c
diff --git a/print-atalk.c b/print-atalk.c
index ae342069cf4f2886bd54375bfc7391f54f955895..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,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);
@@ -116,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)),
@@ -139,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",
@@ -162,12 +208,6 @@ llap_print(netdissect_options *ndo,
                          GET_U_1(dp->srcNode), GET_U_1(dp->srcSkt));
                break;
 
                          GET_U_1(dp->srcNode), GET_U_1(dp->srcSkt));
                break;
 
-#ifdef notdef
-       case lapKLAP:
-               klap_print(bp, length);
-               break;
-#endif
-
        default:
                ND_PRINT("%u > %u at-lap#%u %u",
                    GET_U_1(lp->src), GET_U_1(lp->dst), GET_U_1(lp->type),
        default:
                ND_PRINT("%u > %u at-lap#%u %u",
                    GET_U_1(lp->src), GET_U_1(lp->dst), GET_U_1(lp->type),
@@ -175,6 +215,9 @@ llap_print(netdissect_options *ndo,
                break;
        }
        return (hdrlen);
                break;
        }
        return (hdrlen);
+invalid:
+       nd_print_invalid(ndo);
+       return length;
 }
 
 /*
 }
 
 /*
@@ -193,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)),
@@ -212,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() */
@@ -221,23 +260,18 @@ 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 &&
        if (GET_BE_U_2(ap->htype) == 1 &&
            GET_BE_U_2(ap->ptype) == ETHERTYPE_ATALK &&
-           GET_U_1(ap->halen) == 6 && GET_U_1(ap->palen) == 4 )
+           GET_U_1(ap->halen) == MAC_ADDR_LEN && GET_U_1(ap->palen) == 4)
                switch (GET_BE_U_2(ap->op)) {
 
                case 1:                         /* request */
                switch (GET_BE_U_2(ap->op)) {
 
                case 1:                         /* request */
@@ -255,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);
 }
 
 /*
 }
 
 /*
@@ -293,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) {
@@ -382,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
@@ -424,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
@@ -474,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)
@@ -551,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;
 
@@ -559,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("\"");
                }
        }
@@ -635,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);
                        }
@@ -660,7 +662,7 @@ ataddr_string(netdissect_options *ndo,
                        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);
                }
 
@@ -673,11 +675,15 @@ ataddr_string(netdissect_options *ndo,
        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 */
[mirror] the TCPdump network dissector