ICMPv6: Add the IPv6-Only flag

[tcpdump] / addrtoname.c

diff --git a/addrtoname.c b/addrtoname.c
index 2c1c6403beefd6de81dae45f1cbf2dd865107501..1c80c39f0e7891f9244c3266da54787aff606c20 100644 (file)
--- a/addrtoname.c
+++ b/addrtoname.c
@@ -21,64 +21,129 @@
  *  Internet, ethernet, port, and protocol string to address
  *  and address to string conversion routines
  */
  *  Internet, ethernet, port, and protocol string to address
  *  and address to string conversion routines
  */

-#ifndef lint
-static const char rcsid[] _U_ =
-    "@(#) $Header: /tcpdump/master/tcpdump/addrtoname.c,v 1.106 2005-01-04 00:07:09 guy Exp $ (LBL)";
-#endif

 
 #ifdef HAVE_CONFIG_H
 
 #ifdef HAVE_CONFIG_H

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

 #endif
 
 #endif
 

-#include <tcpdump-stdinc.h>
+#ifdef HAVE_CASPER
+#include <libcasper.h>
+#include <casper/cap_dns.h>
+#endif /* HAVE_CASPER */

 
 

-#ifdef USE_ETHER_NTOHOST
-#ifdef HAVE_NETINET_IF_ETHER_H
-struct mbuf;           /* Squelch compiler warnings on some platforms for */
-struct rtentry;                /* declarations in <net/if.h> */
-#include <net/if.h>    /* for "struct ifnet" in "struct arpcom" on Solaris */
-#include <netinet/if_ether.h>
-#endif /* HAVE_NETINET_IF_ETHER_H */
-#ifdef HAVE_NETINET_ETHER_H
-#include <netinet/ether.h>  /* ether_ntohost on linux */
-#endif /* HAVE_NETINET_ETHER_H */
-#endif /* USE_ETHER_NTOHOST */
+#include "netdissect-stdinc.h"
+
+#ifndef NTOHL
+#define NTOHL(x)       (x) = ntohl(x)
+#define NTOHS(x)       (x) = ntohs(x)
+#define HTONL(x)       (x) = htonl(x)
+#define HTONS(x)       (x) = htons(x)
+#endif
+
+#ifdef _WIN32
+  /*
+   * We have our own ether_ntohost(), reading from the system's
+   * Ethernet address file.
+   */
+  #include "missing/win_ether_ntohost.h"
+#else
+  #ifdef USE_ETHER_NTOHOST
+    #if defined(NET_ETHERNET_H_DECLARES_ETHER_NTOHOST)
+      /*
+       * OK, just include <net/ethernet.h>.
+       */
+      #include <net/ethernet.h>
+    #elif defined(NETINET_ETHER_H_DECLARES_ETHER_NTOHOST)
+      /*
+       * OK, just include <netinet/ether.h>
+       */
+      #include <netinet/ether.h>
+    #elif defined(SYS_ETHERNET_H_DECLARES_ETHER_NTOHOST)
+      /*
+       * OK, just include <sys/ethernet.h>
+       */
+      #include <sys/ethernet.h>
+    #elif defined(ARPA_INET_H_DECLARES_ETHER_NTOHOST)
+      /*
+       * OK, just include <arpa/inet.h>
+       */
+      #include <arpa/inet.h>
+    #elif defined(NETINET_IF_ETHER_H_DECLARES_ETHER_NTOHOST)
+      /*
+       * OK, include <netinet/if_ether.h>, after all the other stuff we
+       * need to include or define for its benefit.
+       */
+      #define NEED_NETINET_IF_ETHER_H
+    #else
+      /*
+       * We'll have to declare it ourselves.
+       * If <netinet/if_ether.h> defines struct ether_addr, include
+       * it.  Otherwise, define it ourselves.
+       */
+      #ifdef HAVE_STRUCT_ETHER_ADDR
+        #define NEED_NETINET_IF_ETHER_H
+      #else /* HAVE_STRUCT_ETHER_ADDR */
+       struct ether_addr {
+               unsigned char ether_addr_octet[6];
+       };
+      #endif /* HAVE_STRUCT_ETHER_ADDR */
+    #endif /* what declares ether_ntohost() */
+
+    #ifdef NEED_NETINET_IF_ETHER_H
+      #include <net/if.h>      /* Needed on some platforms */
+      #include <netinet/in.h>  /* Needed on some platforms */
+      #include <netinet/if_ether.h>
+    #endif /* NEED_NETINET_IF_ETHER_H */
+
+    #ifndef HAVE_DECL_ETHER_NTOHOST
+      /*
+       * No header declares it, so declare it ourselves.
+       */
+      extern int ether_ntohost(char *, const struct ether_addr *);
+    #endif /* !defined(HAVE_DECL_ETHER_NTOHOST) */
+  #endif /* USE_ETHER_NTOHOST */
+#endif /* _WIN32 */

 
 #include <pcap.h>
 #include <pcap-namedb.h>
 
 #include <pcap.h>
 #include <pcap-namedb.h>

+#ifndef HAVE_GETSERVENT
+#include <getservent.h>
+#endif

 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 

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

 #include "addrtoname.h"
 #include "addrtoname.h"

+#include "addrtostr.h"
+#include "ethertype.h"

 #include "llc.h"
 #include "llc.h"

-#include "setsignal.h"
+#include "extract.h"
+#include "oui.h"

 
 /*
  * hash tables for whatever-to-name translations
  *
 
 /*
  * hash tables for whatever-to-name translations
  *

- * XXX there has to be error checks against strdup(3) failure
+ * ndo_error() called on strdup(3) failure with S_ERR_ND_MEM_ALLOC status

  */
 
 #define HASHNAMESIZE 4096
 
 struct hnamemem {
  */
 
 #define HASHNAMESIZE 4096
 
 struct hnamemem {

-       u_int32_t addr;
+       uint32_t addr;

        const char *name;
        struct hnamemem *nxt;
 };
 
        const char *name;
        struct hnamemem *nxt;
 };
 

-struct hnamemem hnametable[HASHNAMESIZE];
-struct hnamemem tporttable[HASHNAMESIZE];
-struct hnamemem uporttable[HASHNAMESIZE];
-struct hnamemem eprototable[HASHNAMESIZE];
-struct hnamemem dnaddrtable[HASHNAMESIZE];
-struct hnamemem llcsaptable[HASHNAMESIZE];
-struct hnamemem ipxsaptable[HASHNAMESIZE];
+static struct hnamemem hnametable[HASHNAMESIZE];
+static struct hnamemem tporttable[HASHNAMESIZE];
+static struct hnamemem uporttable[HASHNAMESIZE];
+static struct hnamemem eprototable[HASHNAMESIZE];
+static struct hnamemem dnaddrtable[HASHNAMESIZE];
+static struct hnamemem ipxsaptable[HASHNAMESIZE];

 
 

-#if defined(INET6) && defined(WIN32)
+#ifdef _WIN32

 /*
  * fake gethostbyaddr for Win2k/XP
  * gethostbyaddr() returns incorrect value when AF_INET6 is passed
 /*
  * fake gethostbyaddr for Win2k/XP
  * gethostbyaddr() returns incorrect value when AF_INET6 is passed


@@ -107,7 +172,7 @@ win32_gethostbyaddr(const char *addr, int len, int type)
                    hname, sizeof(hname), NULL, 0, 0)) {
                        return NULL;
                } else {
                    hname, sizeof(hname), NULL, 0, 0)) {
                        return NULL;
                } else {

-                       strcpy(host.h_name, hname);
+                       strlcpy(host.h_name, hname, NI_MAXHOST);

                        return &host;
                }
                break;
                        return &host;
                }
                break;


@@ -116,17 +181,15 @@ win32_gethostbyaddr(const char *addr, int len, int type)
        }
 }
 #define gethostbyaddr win32_gethostbyaddr
        }
 }
 #define gethostbyaddr win32_gethostbyaddr

-#endif /* INET6 & WIN32 */
+#endif /* _WIN32 */

 
 

-#ifdef INET6

 struct h6namemem {
        struct in6_addr addr;
        char *name;
        struct h6namemem *nxt;
 };
 
 struct h6namemem {
        struct in6_addr addr;
        char *name;
        struct h6namemem *nxt;
 };
 

-struct h6namemem h6nametable[HASHNAMESIZE];
-#endif /* INET6 */
+static struct h6namemem h6nametable[HASHNAMESIZE];

 
 struct enamemem {
        u_short e_addr0;
 
 struct enamemem {
        u_short e_addr0;


@@ -134,48 +197,58 @@ struct enamemem {
        u_short e_addr2;
        const char *e_name;
        u_char *e_nsap;                 /* used only for nsaptable[] */
        u_short e_addr2;
        const char *e_name;
        u_char *e_nsap;                 /* used only for nsaptable[] */

-#define e_bs e_nsap                    /* for bytestringtable */

        struct enamemem *e_nxt;
 };
 
        struct enamemem *e_nxt;
 };
 

-struct enamemem enametable[HASHNAMESIZE];
-struct enamemem nsaptable[HASHNAMESIZE];
-struct enamemem bytestringtable[HASHNAMESIZE];
+static struct enamemem enametable[HASHNAMESIZE];
+static struct enamemem nsaptable[HASHNAMESIZE];
+
+struct bsnamemem {
+       u_short bs_addr0;
+       u_short bs_addr1;
+       u_short bs_addr2;
+       const char *bs_name;
+       u_char *bs_bytes;
+       unsigned int bs_nbytes;
+       struct bsnamemem *bs_nxt;
+};
+
+static struct bsnamemem bytestringtable[HASHNAMESIZE];

 
 struct protoidmem {
 
 struct protoidmem {

-       u_int32_t p_oui;
+       uint32_t p_oui;

        u_short p_proto;
        const char *p_name;
        struct protoidmem *p_nxt;
 };
 
        u_short p_proto;
        const char *p_name;
        struct protoidmem *p_nxt;
 };
 

-struct protoidmem protoidtable[HASHNAMESIZE];
+static struct protoidmem protoidtable[HASHNAMESIZE];

 
 /*
  * A faster replacement for inet_ntoa().
  */
 const char *
 
 /*
  * A faster replacement for inet_ntoa().
  */
 const char *

-intoa(u_int32_t addr)
+intoa(uint32_t addr)

 {
 {

-       register char *cp;
-       register u_int byte;
-       register int n;
+       char *cp;
+       u_int byte;
+       int n;

        static char buf[sizeof(".xxx.xxx.xxx.xxx")];
 
        NTOHL(addr);
        static char buf[sizeof(".xxx.xxx.xxx.xxx")];
 
        NTOHL(addr);

-       cp = &buf[sizeof buf];
+       cp = buf + sizeof(buf);

        *--cp = '\0';
 
        n = 4;
        do {
                byte = addr & 0xff;
        *--cp = '\0';
 
        n = 4;
        do {
                byte = addr & 0xff;

-               *--cp = byte % 10 + '0';
+               *--cp = (char)(byte % 10) + '0';

                byte /= 10;
                if (byte > 0) {
                byte /= 10;
                if (byte > 0) {

-                       *--cp = byte % 10 + '0';
+                       *--cp = (char)(byte % 10) + '0';

                        byte /= 10;
                        if (byte > 0)
                        byte /= 10;
                        if (byte > 0)

-                               *--cp = byte + '0';
+                               *--cp = (char)byte + '0';

                }
                *--cp = '.';
                addr >>= 8;
                }
                *--cp = '.';
                addr >>= 8;


@@ -184,8 +257,11 @@ intoa(u_int32_t addr)
        return cp + 1;
 }
 
        return cp + 1;
 }
 

-static u_int32_t f_netmask;
-static u_int32_t f_localnet;
+static uint32_t f_netmask;
+static uint32_t f_localnet;
+#ifdef HAVE_CASPER
+extern cap_channel_t *capdns;
+#endif

 
 /*
  * Return a name for the IP address pointed to by ap.  This address
 
 /*
  * Return a name for the IP address pointed to by ap.  This address


@@ -193,7 +269,7 @@ static u_int32_t f_localnet;
  *
  * NOTE: ap is *NOT* necessarily part of the packet data (not even if
  * this is being called with the "ipaddr_string()" macro), so you
  *
  * NOTE: ap is *NOT* necessarily part of the packet data (not even if
  * this is being called with the "ipaddr_string()" macro), so you

- * *CANNOT* use the TCHECK{2}/TTEST{2} macros on it.  Furthermore,
+ * *CANNOT* use the ND_TCHECK_* or ND_TTEST_* macros on it.  Furthermore,

  * even in cases where it *is* part of the packet data, the caller
  * would still have to check for a null return value, even if it's
  * just printing the return value with "%s" - not all versions of
  * even in cases where it *is* part of the packet data, the caller
  * would still have to check for a null return value, even if it's
  * just printing the return value with "%s" - not all versions of


@@ -207,11 +283,11 @@ static u_int32_t f_localnet;
  * also needs to check whether they're present in the packet buffer.
  */
 const char *
  * also needs to check whether they're present in the packet buffer.
  */
 const char *

-getname(const u_char *ap)
+ipaddr_string(netdissect_options *ndo, const u_char *ap)

 {
 {

-       register struct hostent *hp;
-       u_int32_t addr;
-       static struct hnamemem *p;              /* static for longjmp() */
+       struct hostent *hp;
+       uint32_t addr;
+       struct hnamemem *p;

 
        memcpy(&addr, ap, sizeof(addr));
        p = &hnametable[addr & (HASHNAMESIZE-1)];
 
        memcpy(&addr, ap, sizeof(addr));
        p = &hnametable[addr & (HASHNAMESIZE-1)];


@@ -220,7 +296,7 @@ getname(const u_char *ap)
                        return (p->name);
        }
        p->addr = addr;
                        return (p->name);
        }
        p->addr = addr;

-       p->nxt = newhnamemem();
+       p->nxt = newhnamemem(ndo);

 
        /*
         * Print names unless:
 
        /*
         * Print names unless:


@@ -229,14 +305,23 @@ getname(const u_char *ap)
         *          given, f_netmask and f_localnet are 0 and the test
         *          evaluates to true)
         */
         *          given, f_netmask and f_localnet are 0 and the test
         *          evaluates to true)
         */

-       if (!nflag &&
+       if (!ndo->ndo_nflag &&

            (addr & f_netmask) == f_localnet) {
            (addr & f_netmask) == f_localnet) {

-               hp = gethostbyaddr((char *)&addr, 4, AF_INET);
+#ifdef HAVE_CASPER
+               if (capdns != NULL) {
+                       hp = cap_gethostbyaddr(capdns, (char *)&addr, 4,
+                           AF_INET);
+               } else
+#endif
+                       hp = gethostbyaddr((char *)&addr, 4, AF_INET);

                if (hp) {
                        char *dotp;
 
                        p->name = strdup(hp->h_name);
                if (hp) {
                        char *dotp;
 
                        p->name = strdup(hp->h_name);

-                       if (Nflag) {
+                       if (p->name == NULL)
+                               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                       "ipaddr_string: strdup(hp->h_name)");
+                       if (ndo->ndo_Nflag) {

                                /* Remove domain qualifications */
                                dotp = strchr(p->name, '.');
                                if (dotp)
                                /* Remove domain qualifications */
                                dotp = strchr(p->name, '.');
                                if (dotp)


@@ -246,42 +331,60 @@ getname(const u_char *ap)
                }
        }
        p->name = strdup(intoa(addr));
                }
        }
        p->name = strdup(intoa(addr));

+       if (p->name == NULL)
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "ipaddr_string: strdup(intoa(addr))");

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

-#ifdef INET6

 /*
  * Return a name for the IP6 address pointed to by ap.  This address
  * is assumed to be in network byte order.
  */
 const char *
 /*
  * Return a name for the IP6 address pointed to by ap.  This address
  * is assumed to be in network byte order.
  */
 const char *

-getname6(const u_char *ap)
+ip6addr_string(netdissect_options *ndo, const u_char *ap)

 {
 {

-       register struct hostent *hp;
-       struct in6_addr addr;
-       static struct h6namemem *p;             /* static for longjmp() */
-       register const char *cp;
+       struct hostent *hp;
+       union {
+               struct in6_addr addr;
+               struct for_hash_addr {
+                       char fill[14];
+                       uint16_t d;
+               } addra;
+       } addr;
+       struct h6namemem *p;
+       const char *cp;

        char ntop_buf[INET6_ADDRSTRLEN];
 
        memcpy(&addr, ap, sizeof(addr));
        char ntop_buf[INET6_ADDRSTRLEN];
 
        memcpy(&addr, ap, sizeof(addr));

-       p = &h6nametable[*(u_int16_t *)&addr.s6_addr[14] & (HASHNAMESIZE-1)];
+       p = &h6nametable[addr.addra.d & (HASHNAMESIZE-1)];

        for (; p->nxt; p = p->nxt) {
                if (memcmp(&p->addr, &addr, sizeof(addr)) == 0)
                        return (p->name);
        }
        for (; p->nxt; p = p->nxt) {
                if (memcmp(&p->addr, &addr, sizeof(addr)) == 0)
                        return (p->name);
        }

-       p->addr = addr;
-       p->nxt = newh6namemem();
+       p->addr = addr.addr;
+       p->nxt = newh6namemem(ndo);

 
        /*
         * Do not print names if -n was given.
         */
 
        /*
         * Do not print names if -n was given.
         */

-       if (!nflag) {
-               hp = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET6);
+       if (!ndo->ndo_nflag) {
+#ifdef HAVE_CASPER
+               if (capdns != NULL) {
+                       hp = cap_gethostbyaddr(capdns, (char *)&addr,
+                           sizeof(addr), AF_INET6);
+               } else
+#endif
+                       hp = gethostbyaddr((char *)&addr, sizeof(addr),
+                           AF_INET6);

                if (hp) {
                        char *dotp;
 
                        p->name = strdup(hp->h_name);
                if (hp) {
                        char *dotp;
 
                        p->name = strdup(hp->h_name);

-                       if (Nflag) {
+                       if (p->name == NULL)
+                               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                       "ip6addr_string: strdup(hp->h_name)");
+                       if (ndo->ndo_Nflag) {

                                /* Remove domain qualifications */
                                dotp = strchr(p->name, '.');
                                if (dotp)
                                /* Remove domain qualifications */
                                dotp = strchr(p->name, '.');
                                if (dotp)


@@ -290,21 +393,25 @@ getname6(const u_char *ap)
                        return (p->name);
                }
        }
                        return (p->name);
                }
        }

-       cp = inet_ntop(AF_INET6, &addr, ntop_buf, sizeof(ntop_buf));
+       cp = addrtostr6(ap, ntop_buf, sizeof(ntop_buf));

        p->name = strdup(cp);
        p->name = strdup(cp);

+       if (p->name == NULL)
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "ip6addr_string: strdup(cp)");

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

-#endif /* INET6 */
-
-static char hex[] = "0123456789abcdef";

 
 

+static const char hex[16] = {
+       '0', '1', '2', '3', '4', '5', '6', '7',
+       '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+};

 
 /* Find the hash node that corresponds the ether address 'ep' */
 
 
 /* Find the hash node that corresponds the ether address 'ep' */
 

-static inline struct enamemem *
-lookup_emem(const u_char *ep)
+static struct enamemem *
+lookup_emem(netdissect_options *ndo, const u_char *ep)

 {
 {

-       register u_int i, j, k;
+       u_int i, j, k;

        struct enamemem *tp;
 
        k = (ep[0] << 8) | ep[1];
        struct enamemem *tp;
 
        k = (ep[0] << 8) | ep[1];


@@ -319,12 +426,12 @@ lookup_emem(const u_char *ep)
                        return tp;
                else
                        tp = tp->e_nxt;
                        return tp;
                else
                        tp = tp->e_nxt;

-       tp->e_addr0 = i;
-       tp->e_addr1 = j;
-       tp->e_addr2 = k;
+       tp->e_addr0 = (u_short)i;
+       tp->e_addr1 = (u_short)j;
+       tp->e_addr2 = (u_short)k;

        tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
        if (tp->e_nxt == NULL)
        tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
        if (tp->e_nxt == NULL)

-               error("lookup_emem: calloc");
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_emem: calloc");

 
        return tp;
 }
 
        return tp;
 }


@@ -334,11 +441,12 @@ lookup_emem(const u_char *ep)
  * with length 'nlen'
  */
 
  * with length 'nlen'
  */
 

-static inline struct enamemem *
-lookup_bytestring(register const u_char *bs, const unsigned int nlen)
+static struct bsnamemem *
+lookup_bytestring(netdissect_options *ndo, const u_char *bs,
+                 const unsigned int nlen)

 {
 {

-       struct enamemem *tp;
-       register u_int i, j, k;
+       struct bsnamemem *tp;
+       u_int i, j, k;

 
        if (nlen >= 6) {
                k = (bs[0] << 8) | bs[1];
 
        if (nlen >= 6) {
                k = (bs[0] << 8) | bs[1];


@@ -352,39 +460,47 @@ lookup_bytestring(register const u_char *bs, const unsigned int nlen)
                i = j = k = 0;
 
        tp = &bytestringtable[(i ^ j) & (HASHNAMESIZE-1)];
                i = j = k = 0;
 
        tp = &bytestringtable[(i ^ j) & (HASHNAMESIZE-1)];

-       while (tp->e_nxt)
-               if (tp->e_addr0 == i &&
-                   tp->e_addr1 == j &&
-                   tp->e_addr2 == k &&
-                   memcmp((const char *)bs, (const char *)(tp->e_bs), nlen) == 0)
+       while (tp->bs_nxt)
+               if (nlen == tp->bs_nbytes &&
+                   tp->bs_addr0 == i &&
+                   tp->bs_addr1 == j &&
+                   tp->bs_addr2 == k &&
+                   memcmp((const char *)bs, (const char *)(tp->bs_bytes), nlen) == 0)

                        return tp;
                else
                        return tp;
                else

-                       tp = tp->e_nxt;
+                       tp = tp->bs_nxt;

 
 

-       tp->e_addr0 = i;
-       tp->e_addr1 = j;
-       tp->e_addr2 = k;
+       tp->bs_addr0 = (u_short)i;
+       tp->bs_addr1 = (u_short)j;
+       tp->bs_addr2 = (u_short)k;

 
 

-       tp->e_bs = (u_char *) calloc(1, nlen + 1);
-       memcpy(tp->e_bs, bs, nlen);
-       tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
-       if (tp->e_nxt == NULL)
-               error("lookup_bytestring: calloc");
+       tp->bs_bytes = (u_char *) calloc(1, nlen);
+       if (tp->bs_bytes == NULL)
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "lookup_bytestring: calloc");
+
+       memcpy(tp->bs_bytes, bs, nlen);
+       tp->bs_nbytes = nlen;
+       tp->bs_nxt = (struct bsnamemem *)calloc(1, sizeof(*tp));
+       if (tp->bs_nxt == NULL)
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "lookup_bytestring: calloc");

 
        return tp;
 }
 
 /* Find the hash node that corresponds the NSAP 'nsap' */
 
 
        return tp;
 }
 
 /* Find the hash node that corresponds the NSAP 'nsap' */
 

-static inline struct enamemem *
-lookup_nsap(register const u_char *nsap)
+static struct enamemem *
+lookup_nsap(netdissect_options *ndo, const u_char *nsap,
+           u_int nsap_length)

 {
 {

-       register u_int i, j, k;
-       unsigned int nlen = *nsap;
+       u_int i, j, k;

        struct enamemem *tp;
        struct enamemem *tp;

-       const u_char *ensap = nsap + nlen - 6;
+       const u_char *ensap;

 
 

-       if (nlen > 6) {
+       if (nsap_length > 6) {
+               ensap = nsap + nsap_length - 6;

                k = (ensap[0] << 8) | ensap[1];
                j = (ensap[2] << 8) | ensap[3];
                i = (ensap[4] << 8) | ensap[5];
                k = (ensap[0] << 8) | ensap[1];
                j = (ensap[2] << 8) | ensap[3];
                i = (ensap[4] << 8) | ensap[5];


@@ -394,35 +510,36 @@ lookup_nsap(register const u_char *nsap)
 
        tp = &nsaptable[(i ^ j) & (HASHNAMESIZE-1)];
        while (tp->e_nxt)
 
        tp = &nsaptable[(i ^ j) & (HASHNAMESIZE-1)];
        while (tp->e_nxt)

-               if (tp->e_addr0 == i &&
+               if (nsap_length == tp->e_nsap[0] &&
+                   tp->e_addr0 == i &&

                    tp->e_addr1 == j &&
                    tp->e_addr2 == k &&
                    tp->e_addr1 == j &&
                    tp->e_addr2 == k &&

-                   tp->e_nsap[0] == nlen &&
-                   memcmp((const char *)&(nsap[1]),
-                       (char *)&(tp->e_nsap[1]), nlen) == 0)
+                   memcmp((const char *)nsap,
+                       (char *)&(tp->e_nsap[1]), nsap_length) == 0)

                        return tp;
                else
                        tp = tp->e_nxt;
                        return tp;
                else
                        tp = tp->e_nxt;

-       tp->e_addr0 = i;
-       tp->e_addr1 = j;
-       tp->e_addr2 = k;
-       tp->e_nsap = (u_char *)malloc(nlen + 1);
+       tp->e_addr0 = (u_short)i;
+       tp->e_addr1 = (u_short)j;
+       tp->e_addr2 = (u_short)k;
+       tp->e_nsap = (u_char *)malloc(nsap_length + 1);

        if (tp->e_nsap == NULL)
        if (tp->e_nsap == NULL)

-               error("lookup_nsap: malloc");
-       memcpy((char *)tp->e_nsap, (const char *)nsap, nlen + 1);
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_nsap: malloc");
+       tp->e_nsap[0] = (u_char)nsap_length;    /* guaranteed < ISONSAP_MAX_LENGTH */
+       memcpy((char *)&tp->e_nsap[1], (const char *)nsap, nsap_length);

        tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
        if (tp->e_nxt == NULL)
        tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
        if (tp->e_nxt == NULL)

-               error("lookup_nsap: calloc");
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_nsap: calloc");

 
        return tp;
 }
 
 /* Find the hash node that corresponds the protoid 'pi'. */
 
 
        return tp;
 }
 
 /* Find the hash node that corresponds the protoid 'pi'. */
 

-static inline struct protoidmem *
-lookup_protoid(const u_char *pi)
+static struct protoidmem *
+lookup_protoid(netdissect_options *ndo, const u_char *pi)

 {
 {

-       register u_int i, j;
+       u_int i, j;

        struct protoidmem *tp;
 
        /* 5 octets won't be aligned */
        struct protoidmem *tp;
 
        /* 5 octets won't be aligned */


@@ -437,177 +554,166 @@ lookup_protoid(const u_char *pi)
                else
                        tp = tp->p_nxt;
        tp->p_oui = i;
                else
                        tp = tp->p_nxt;
        tp->p_oui = i;

-       tp->p_proto = j;
+       tp->p_proto = (u_short)j;

        tp->p_nxt = (struct protoidmem *)calloc(1, sizeof(*tp));
        if (tp->p_nxt == NULL)
        tp->p_nxt = (struct protoidmem *)calloc(1, sizeof(*tp));
        if (tp->p_nxt == NULL)

-               error("lookup_protoid: calloc");
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_protoid: calloc");

 
        return tp;
 }
 
 const char *
 
        return tp;
 }
 
 const char *

-etheraddr_string(register const u_char *ep)
+etheraddr_string(netdissect_options *ndo, const uint8_t *ep)

 {
 {

-       register u_int i;
-       register char *cp;
-       register struct enamemem *tp;
-       char buf[sizeof("00:00:00:00:00:00")];
+       int i;
+       char *cp;
+       struct enamemem *tp;
+       int oui;
+       char buf[BUFSIZE];

 
 

-       tp = lookup_emem(ep);
+       tp = lookup_emem(ndo, ep);

        if (tp->e_name)
                return (tp->e_name);
 #ifdef USE_ETHER_NTOHOST
        if (tp->e_name)
                return (tp->e_name);
 #ifdef USE_ETHER_NTOHOST

-       if (!nflag) {
-               char buf2[128];
+       if (!ndo->ndo_nflag) {
+               char buf2[BUFSIZE];
+

                if (ether_ntohost(buf2, (const struct ether_addr *)ep) == 0) {
                        tp->e_name = strdup(buf2);
                if (ether_ntohost(buf2, (const struct ether_addr *)ep) == 0) {
                        tp->e_name = strdup(buf2);

+                       if (tp->e_name == NULL)
+                               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                       "etheraddr_string: strdup(buf2)");

                        return (tp->e_name);
                }
        }
 #endif
        cp = buf;
                        return (tp->e_name);
                }
        }
 #endif
        cp = buf;

-        *cp++ = hex[*ep >> 4 ];
+       oui = EXTRACT_BE_U_3(ep);
+       *cp++ = hex[*ep >> 4 ];

        *cp++ = hex[*ep++ & 0xf];
        *cp++ = hex[*ep++ & 0xf];

-       for (i = 5; (int)--i >= 0;) {
+       for (i = 5; --i >= 0;) {

                *cp++ = ':';
                *cp++ = ':';

-                *cp++ = hex[*ep >> 4 ];
+               *cp++ = hex[*ep >> 4 ];

                *cp++ = hex[*ep++ & 0xf];
        }
                *cp++ = hex[*ep++ & 0xf];
        }

-       *cp = '\0';
+
+       if (!ndo->ndo_nflag) {
+               nd_snprintf(cp, BUFSIZE - (2 + 5*3), " (oui %s)",
+                   tok2str(oui_values, "Unknown", oui));
+       } else
+               *cp = '\0';

        tp->e_name = strdup(buf);
        tp->e_name = strdup(buf);

+       if (tp->e_name == NULL)
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "etheraddr_string: strdup(buf)");

        return (tp->e_name);
 }
 
 const char *
        return (tp->e_name);
 }
 
 const char *

-linkaddr_string(const u_char *ep, const unsigned int len)
+le64addr_string(netdissect_options *ndo, const uint8_t *ep)

 {
 {

-       register u_int i;
-       register char *cp;
-       register struct enamemem *tp;
+       const unsigned int len = 8;
+       u_int i;
+       char *cp;
+       struct bsnamemem *tp;
+       char buf[BUFSIZE];

 
 

-       if (len == 6)   /* XXX not totally correct... */
-               return etheraddr_string(ep);
+       tp = lookup_bytestring(ndo, ep, len);
+       if (tp->bs_name)
+               return (tp->bs_name);

 
 

-       tp = lookup_bytestring(ep, len);
-       if (tp->e_name)
-               return (tp->e_name);
-
-       tp->e_name = cp = (char *)malloc(len*3);
-       if (tp->e_name == NULL)
-               error("linkaddr_string: malloc");
-       *cp++ = hex[*ep >> 4];
-       *cp++ = hex[*ep++ & 0xf];
-       for (i = len-1; i > 0 ; --i) {
+       cp = buf;
+       for (i = len; i > 0 ; --i) {
+               *cp++ = hex[*(ep + i - 1) >> 4];
+               *cp++ = hex[*(ep + i - 1) & 0xf];

                *cp++ = ':';
                *cp++ = ':';

-               *cp++ = hex[*ep >> 4];
-               *cp++ = hex[*ep++ & 0xf];

        }
        }

+       cp --;
+

        *cp = '\0';
        *cp = '\0';

-       return (tp->e_name);
+
+       tp->bs_name = strdup(buf);
+       if (tp->bs_name == NULL)
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "le64addr_string: strdup(buf)");
+
+       return (tp->bs_name);

 }
 
 const char *
 }
 
 const char *

-etherproto_string(u_short port)
+linkaddr_string(netdissect_options *ndo, const uint8_t *ep,
+               const unsigned int type, const unsigned int len)

 {
 {

-       register char *cp;
-       register struct hnamemem *tp;
-       register u_int32_t i = port;
-       char buf[sizeof("0000")];
-
-       for (tp = &eprototable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
-               if (tp->addr == i)
-                       return (tp->name);
+       u_int i;
+       char *cp;
+       struct bsnamemem *tp;

 
 

-       tp->addr = i;
-       tp->nxt = newhnamemem();
+       if (len == 0)
+               return ("<empty>");

 
 

-       cp = buf;
-       NTOHS(port);
-       *cp++ = hex[port >> 12 & 0xf];
-       *cp++ = hex[port >> 8 & 0xf];
-       *cp++ = hex[port >> 4 & 0xf];
-       *cp++ = hex[port & 0xf];
-       *cp++ = '\0';
-       tp->name = strdup(buf);
-       return (tp->name);
-}
+       if (type == LINKADDR_ETHER && len == MAC_ADDR_LEN)
+               return (etheraddr_string(ndo, ep));

 
 

-const char *
-protoid_string(register const u_char *pi)
-{
-       register u_int i, j;
-       register char *cp;
-       register struct protoidmem *tp;
-       char buf[sizeof("00:00:00:00:00")];
+       if (type == LINKADDR_FRELAY)
+               return (q922_string(ndo, ep, len));

 
 

-       tp = lookup_protoid(pi);
-       if (tp->p_name)
-               return tp->p_name;
+       tp = lookup_bytestring(ndo, ep, len);
+       if (tp->bs_name)
+               return (tp->bs_name);

 
 

-       cp = buf;
-       if ((j = *pi >> 4) != 0)
-               *cp++ = hex[j];
-       *cp++ = hex[*pi++ & 0xf];
-       for (i = 4; (int)--i >= 0;) {
+       tp->bs_name = cp = (char *)malloc(len*3);
+       if (tp->bs_name == NULL)
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "linkaddr_string: malloc");
+       *cp++ = hex[*ep >> 4];
+       *cp++ = hex[*ep++ & 0xf];
+       for (i = len-1; i > 0 ; --i) {

                *cp++ = ':';
                *cp++ = ':';

-               if ((j = *pi >> 4) != 0)
-                       *cp++ = hex[j];
-               *cp++ = hex[*pi++ & 0xf];
+               *cp++ = hex[*ep >> 4];
+               *cp++ = hex[*ep++ & 0xf];

        }
        *cp = '\0';
        }
        *cp = '\0';

-       tp->p_name = strdup(buf);
-       return (tp->p_name);
+       return (tp->bs_name);

 }
 
 }
 

+#define ISONSAP_MAX_LENGTH 20

 const char *
 const char *

-llcsap_string(u_char sap)
+isonsap_string(netdissect_options *ndo, const uint8_t *nsap,
+              u_int nsap_length)

 {
 {

-       register struct hnamemem *tp;
-       register u_int32_t i = sap;
-       char buf[sizeof("sap 00")];
-
-       for (tp = &llcsaptable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
-               if (tp->addr == i)
-                       return (tp->name);
-
-       tp->addr = i;
-       tp->nxt = newhnamemem();
-
-       snprintf(buf, sizeof(buf), "sap %02x", sap & 0xff);
-       tp->name = strdup(buf);
-       return (tp->name);
-}
+       u_int nsap_idx;
+       char *cp;
+       struct enamemem *tp;

 
 

-const char *
-isonsap_string(const u_char *nsap)
-{
-       register u_int i, nlen = nsap[0];
-       register char *cp;
-       register struct enamemem *tp;
+       if (nsap_length < 1 || nsap_length > ISONSAP_MAX_LENGTH)
+               return ("isonsap_string: illegal length");

 
 

-       tp = lookup_nsap(nsap);
+       tp = lookup_nsap(ndo, nsap, nsap_length);

        if (tp->e_name)
                return tp->e_name;
 
        if (tp->e_name)
                return tp->e_name;
 

-       tp->e_name = cp = (char *)malloc(nlen * 2 + 2);
+       tp->e_name = cp = (char *)malloc(sizeof("xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xx"));

        if (cp == NULL)
        if (cp == NULL)

-               error("isonsap_string: malloc");
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "isonsap_string: malloc");

 
 

-       nsap++;
-       *cp++ = '/';
-       for (i = nlen; (int)--i >= 0;) {
+       for (nsap_idx = 0; nsap_idx < nsap_length; nsap_idx++) {

                *cp++ = hex[*nsap >> 4];
                *cp++ = hex[*nsap++ & 0xf];
                *cp++ = hex[*nsap >> 4];
                *cp++ = hex[*nsap++ & 0xf];

+               if (((nsap_idx & 1) == 0) &&
+                    (nsap_idx + 1 < nsap_length)) {
+                       *cp++ = '.';
+               }

        }
        *cp = '\0';
        return (tp->e_name);
 }
 
 const char *
        }
        *cp = '\0';
        return (tp->e_name);
 }
 
 const char *

-tcpport_string(u_short port)
+tcpport_string(netdissect_options *ndo, u_short port)

 {
 {

-       register struct hnamemem *tp;
-       register u_int32_t i = port;
+       struct hnamemem *tp;
+       uint32_t i = port;

        char buf[sizeof("00000")];
 
        for (tp = &tporttable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
        char buf[sizeof("00000")];
 
        for (tp = &tporttable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)


@@ -615,18 +721,21 @@ tcpport_string(u_short port)
                        return (tp->name);
 
        tp->addr = i;
                        return (tp->name);
 
        tp->addr = i;

-       tp->nxt = newhnamemem();
+       tp->nxt = newhnamemem(ndo);

 
 

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

        tp->name = strdup(buf);
        tp->name = strdup(buf);

+       if (tp->name == NULL)
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "tcpport_string: strdup(buf)");

        return (tp->name);
 }
 
 const char *
        return (tp->name);
 }
 
 const char *

-udpport_string(register u_short port)
+udpport_string(netdissect_options *ndo, u_short port)

 {
 {

-       register struct hnamemem *tp;
-       register u_int32_t i = port;
+       struct hnamemem *tp;
+       uint32_t i = port;

        char buf[sizeof("00000")];
 
        for (tp = &uporttable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
        char buf[sizeof("00000")];
 
        for (tp = &uporttable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)


@@ -634,19 +743,22 @@ udpport_string(register u_short port)
                        return (tp->name);
 
        tp->addr = i;
                        return (tp->name);
 
        tp->addr = i;

-       tp->nxt = newhnamemem();
+       tp->nxt = newhnamemem(ndo);

 
 

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

        tp->name = strdup(buf);
        tp->name = strdup(buf);

+       if (tp->name == NULL)
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "udpport_string: strdup(buf)");

        return (tp->name);
 }
 
 const char *
        return (tp->name);
 }
 
 const char *

-ipxsap_string(u_short port)
+ipxsap_string(netdissect_options *ndo, u_short port)

 {
 {

-       register char *cp;
-       register struct hnamemem *tp;
-       register u_int32_t i = port;
+       char *cp;
+       struct hnamemem *tp;
+       uint32_t i = port;

        char buf[sizeof("0000")];
 
        for (tp = &ipxsaptable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)
        char buf[sizeof("0000")];
 
        for (tp = &ipxsaptable[i & (HASHNAMESIZE-1)]; tp->nxt; tp = tp->nxt)


@@ -654,7 +766,7 @@ ipxsap_string(u_short port)
                        return (tp->name);
 
        tp->addr = i;
                        return (tp->name);
 
        tp->addr = i;

-       tp->nxt = newhnamemem();
+       tp->nxt = newhnamemem(ndo);

 
        cp = buf;
        NTOHS(port);
 
        cp = buf;
        NTOHS(port);


@@ -664,15 +776,18 @@ ipxsap_string(u_short port)
        *cp++ = hex[port & 0xf];
        *cp++ = '\0';
        tp->name = strdup(buf);
        *cp++ = hex[port & 0xf];
        *cp++ = '\0';
        tp->name = strdup(buf);

+       if (tp->name == NULL)
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "ipxsap_string: strdup(buf)");

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

-init_servarray(void)
+init_servarray(netdissect_options *ndo)

 {
        struct servent *sv;
 {
        struct servent *sv;

-       register struct hnamemem *table;
-       register int i;
+       struct hnamemem *table;
+       int i;

        char buf[sizeof("0000000000")];
 
        while ((sv = getservent()) != NULL) {
        char buf[sizeof("0000000000")];
 
        while ((sv = getservent()) != NULL) {


@@ -687,33 +802,53 @@ init_servarray(void)
 
                while (table->name)
                        table = table->nxt;
 
                while (table->name)
                        table = table->nxt;

-               if (nflag) {
-                       (void)snprintf(buf, sizeof(buf), "%d", port);
+               if (ndo->ndo_nflag) {
+                       (void)nd_snprintf(buf, sizeof(buf), "%d", port);

                        table->name = strdup(buf);
                } else
                        table->name = strdup(sv->s_name);
                        table->name = strdup(buf);
                } else
                        table->name = strdup(sv->s_name);

+               if (table->name == NULL)
+                       (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                         "init_servarray: strdup");
+

                table->addr = port;
                table->addr = port;

-               table->nxt = newhnamemem();
+               table->nxt = newhnamemem(ndo);

        }
        endservent();
 }
 
        }
        endservent();
 }
 

-/* in libpcap.a (nametoaddr.c) */
-#if defined(WIN32) && !defined(USE_STATIC_LIBPCAP)
-__declspec(dllimport)
-#else
-extern
-#endif
-const struct eproto {
+static const struct eproto {

        const char *s;
        u_short p;
        const char *s;
        u_short p;

-} eproto_db[];
+} eproto_db[] = {
+       { "pup", ETHERTYPE_PUP },
+       { "xns", ETHERTYPE_NS },
+       { "ip", ETHERTYPE_IP },
+       { "ip6", ETHERTYPE_IPV6 },
+       { "arp", ETHERTYPE_ARP },
+       { "rarp", ETHERTYPE_REVARP },
+       { "sprite", ETHERTYPE_SPRITE },
+       { "mopdl", ETHERTYPE_MOPDL },
+       { "moprc", ETHERTYPE_MOPRC },
+       { "decnet", ETHERTYPE_DN },
+       { "lat", ETHERTYPE_LAT },
+       { "sca", ETHERTYPE_SCA },
+       { "lanbridge", ETHERTYPE_LANBRIDGE },
+       { "vexp", ETHERTYPE_VEXP },
+       { "vprod", ETHERTYPE_VPROD },
+       { "atalk", ETHERTYPE_ATALK },
+       { "atalkarp", ETHERTYPE_AARP },
+       { "loopback", ETHERTYPE_LOOPBACK },
+       { "decdts", ETHERTYPE_DECDTS },
+       { "decdns", ETHERTYPE_DECDNS },
+       { (char *)0, 0 }
+};

 
 static void
 
 static void

-init_eprotoarray(void)
+init_eprotoarray(netdissect_options *ndo)

 {
 {

-       register int i;
-       register struct hnamemem *table;
+       int i;
+       struct hnamemem *table;

 
        for (i = 0; eproto_db[i].s; i++) {
                int j = htons(eproto_db[i].p) & (HASHNAMESIZE-1);
 
        for (i = 0; eproto_db[i].s; i++) {
                int j = htons(eproto_db[i].p) & (HASHNAMESIZE-1);


@@ -722,11 +857,11 @@ init_eprotoarray(void)
                        table = table->nxt;
                table->name = eproto_db[i].s;
                table->addr = htons(eproto_db[i].p);
                        table = table->nxt;
                table->name = eproto_db[i].s;
                table->addr = htons(eproto_db[i].p);

-               table->nxt = newhnamemem();
+               table->nxt = newhnamemem(ndo);

        }
 }
 
        }
 }
 

-static struct protoidlist {
+static const struct protoidlist {

        const u_char protoid[5];
        const char *name;
 } protoidlist[] = {
        const u_char protoid[5];
        const char *name;
 } protoidlist[] = {


@@ -743,11 +878,11 @@ static struct protoidlist {
  * types.
  */
 static void
  * types.
  */
 static void

-init_protoidarray(void)
+init_protoidarray(netdissect_options *ndo)

 {
 {

-       register int i;
-       register struct protoidmem *tp;
-       struct protoidlist *pl;
+       int i;
+       struct protoidmem *tp;
+       const struct protoidlist *pl;

        u_char protoid[5];
 
        protoid[0] = 0;
        u_char protoid[5];
 
        protoid[0] = 0;


@@ -757,12 +892,15 @@ init_protoidarray(void)
                u_short etype = htons(eproto_db[i].p);
 
                memcpy((char *)&protoid[3], (char *)&etype, 2);
                u_short etype = htons(eproto_db[i].p);
 
                memcpy((char *)&protoid[3], (char *)&etype, 2);

-               tp = lookup_protoid(protoid);
+               tp = lookup_protoid(ndo, protoid);

                tp->p_name = strdup(eproto_db[i].s);
                tp->p_name = strdup(eproto_db[i].s);

+               if (tp->p_name == NULL)
+                       (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                               "init_protoidarray: strdup(eproto_db[i].s)");

        }
        /* Hardwire some SNAP proto ID names */
        for (pl = protoidlist; pl->name != NULL; ++pl) {
        }
        /* Hardwire some SNAP proto ID names */
        for (pl = protoidlist; pl->name != NULL; ++pl) {

-               tp = lookup_protoid(pl->protoid);
+               tp = lookup_protoid(ndo, pl->protoid);

                /* Don't override existing name */
                if (tp->p_name != NULL)
                        continue;
                /* Don't override existing name */
                if (tp->p_name != NULL)
                        continue;


@@ -771,7 +909,7 @@ init_protoidarray(void)
        }
 }
 
        }
 }
 

-static struct etherlist {
+static const struct etherlist {

        const u_char addr[6];
        const char *name;
 } etherlist[] = {
        const u_char addr[6];
        const char *name;
 } etherlist[] = {


@@ -794,22 +932,25 @@ static struct etherlist {
  * translation, so we just pcap_next_etherent as a convenience.
  */
 static void
  * translation, so we just pcap_next_etherent as a convenience.
  */
 static void

-init_etherarray(void)
+init_etherarray(netdissect_options *ndo)

 {
 {

-       register struct etherlist *el;
-       register struct enamemem *tp;
+       const struct etherlist *el;
+       struct enamemem *tp;

 #ifdef USE_ETHER_NTOHOST
        char name[256];
 #else
 #ifdef USE_ETHER_NTOHOST
        char name[256];
 #else

-       register struct pcap_etherent *ep;
-       register FILE *fp;
+       struct pcap_etherent *ep;
+       FILE *fp;

 
        /* Suck in entire ethers file */
        fp = fopen(PCAP_ETHERS_FILE, "r");
        if (fp != NULL) {
                while ((ep = pcap_next_etherent(fp)) != NULL) {
 
        /* Suck in entire ethers file */
        fp = fopen(PCAP_ETHERS_FILE, "r");
        if (fp != NULL) {
                while ((ep = pcap_next_etherent(fp)) != NULL) {

-                       tp = lookup_emem(ep->addr);
+                       tp = lookup_emem(ndo, ep->addr);

                        tp->e_name = strdup(ep->name);
                        tp->e_name = strdup(ep->name);

+                       if (tp->e_name == NULL)
+                               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                       "init_etherarray: strdup(ep->addr)");

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


@@ -817,15 +958,20 @@ init_etherarray(void)
 
        /* Hardwire some ethernet names */
        for (el = etherlist; el->name != NULL; ++el) {
 
        /* Hardwire some ethernet names */
        for (el = etherlist; el->name != NULL; ++el) {

-               tp = lookup_emem(el->addr);
+               tp = lookup_emem(ndo, el->addr);

                /* Don't override existing name */
                if (tp->e_name != NULL)
                        continue;
 
 #ifdef USE_ETHER_NTOHOST
                /* Don't override existing name */
                if (tp->e_name != NULL)
                        continue;
 
 #ifdef USE_ETHER_NTOHOST

-                /* Use yp/nis version of name if available */
-                if (ether_ntohost(name, (const struct ether_addr *)el->addr) == 0) {
-                        tp->e_name = strdup(name);
+               /*
+                * Use YP/NIS version of name if available.
+                */
+               if (ether_ntohost(name, (const struct ether_addr *)el->addr) == 0) {
+                       tp->e_name = strdup(name);
+                       if (tp->e_name == NULL)
+                               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                       "init_etherarray: strdup(name)");

                        continue;
                }
 #endif
                        continue;
                }
 #endif


@@ -833,41 +979,10 @@ init_etherarray(void)
        }
 }
 
        }
 }
 

-static struct tok llcsap_db[] = {
-       { LLCSAP_NULL,          "null" },
-       { LLCSAP_8021B_I,       "802.1b-gsap" },
-       { LLCSAP_8021B_G,       "802.1b-isap" },
-       { LLCSAP_IP,            "ip-sap" },
-       { LLCSAP_PROWAYNM,      "proway-nm" },
-       { LLCSAP_8021D,         "802.1d" },
-       { LLCSAP_RS511,         "eia-rs511" },
-       { LLCSAP_ISO8208,       "x.25/llc2" },
-       { LLCSAP_PROWAY,        "proway" },
-       { LLCSAP_SNAP,          "snap" },
-       { LLCSAP_IPX,           "IPX" },
-       { LLCSAP_NETBEUI,       "netbeui" },
-       { LLCSAP_ISONS,         "iso-clns" },
-       { LLCSAP_GLOBAL,        "global" },
-       { 0,                    NULL }
-};
-
-static void
-init_llcsaparray(void)
-{
-       register int i;
-       register struct hnamemem *table;
-
-       for (i = 0; llcsap_db[i].s != NULL; i++) {
-               table = &llcsaptable[llcsap_db[i].v];
-               while (table->name)
-                       table = table->nxt;
-               table->name = llcsap_db[i].s;
-               table->addr = llcsap_db[i].v;
-               table->nxt = newhnamemem();
-       }
-}
-
-static struct tok ipxsap_db[] = {
+static const struct ipxsap_ent {
+       uint16_t        v;
+       const char      *s;
+} ipxsap_db[] = {

        { 0x0000, "Unknown" },
        { 0x0001, "User" },
        { 0x0002, "User Group" },
        { 0x0000, "Unknown" },
        { 0x0001, "User" },
        { 0x0002, "User Group" },


@@ -1085,74 +1200,73 @@ static struct tok ipxsap_db[] = {
 };
 
 static void
 };
 
 static void

-init_ipxsaparray(void)
+init_ipxsaparray(netdissect_options *ndo)

 {
 {

-       register int i;
-       register struct hnamemem *table;
+       int i;
+       struct hnamemem *table;

 
        for (i = 0; ipxsap_db[i].s != NULL; i++) {
 
        for (i = 0; ipxsap_db[i].s != NULL; i++) {

-               int j = htons(ipxsap_db[i].v) & (HASHNAMESIZE-1);
+               u_int j = htons(ipxsap_db[i].v) & (HASHNAMESIZE-1);

                table = &ipxsaptable[j];
                while (table->name)
                        table = table->nxt;
                table->name = ipxsap_db[i].s;
                table->addr = htons(ipxsap_db[i].v);
                table = &ipxsaptable[j];
                while (table->name)
                        table = table->nxt;
                table->name = ipxsap_db[i].s;
                table->addr = htons(ipxsap_db[i].v);

-               table->nxt = newhnamemem();
+               table->nxt = newhnamemem(ndo);

        }
 }
 
 /*
  * Initialize the address to name translation machinery.  We map all
        }
 }
 
 /*
  * Initialize the address to name translation machinery.  We map all

- * non-local IP addresses to numeric addresses if fflag is true (i.e.,
- * to prevent blocking on the nameserver).  localnet is the IP address
+ * non-local IP addresses to numeric addresses if ndo->ndo_fflag is true
+ * (i.e., to prevent blocking on the nameserver).  localnet is the IP address

  * of the local network.  mask is its subnet mask.
  */
 void
  * of the local network.  mask is its subnet mask.
  */
 void

-init_addrtoname(u_int32_t localnet, u_int32_t mask)
+init_addrtoname(netdissect_options *ndo, uint32_t localnet, uint32_t mask)

 {
 {

-       if (fflag) {
+       if (ndo->ndo_fflag) {

                f_localnet = localnet;
                f_netmask = mask;
        }
                f_localnet = localnet;
                f_netmask = mask;
        }

-       if (nflag)
+       if (ndo->ndo_nflag)

                /*
                 * Simplest way to suppress names.
                 */
                return;
 
                /*
                 * Simplest way to suppress names.
                 */
                return;
 

-       init_etherarray();
-       init_servarray();
-       init_eprotoarray();
-       init_llcsaparray();
-       init_protoidarray();
-       init_ipxsaparray();
+       init_etherarray(ndo);
+       init_servarray(ndo);
+       init_eprotoarray(ndo);
+       init_protoidarray(ndo);
+       init_ipxsaparray(ndo);

 }
 
 const char *
 }
 
 const char *

-dnaddr_string(u_short dnaddr)
+dnaddr_string(netdissect_options *ndo, u_short dnaddr)

 {
 {

-       register struct hnamemem *tp;
+       struct hnamemem *tp;

 
 

-       for (tp = &dnaddrtable[dnaddr & (HASHNAMESIZE-1)]; tp->nxt != 0;
+       for (tp = &dnaddrtable[dnaddr & (HASHNAMESIZE-1)]; tp->nxt != NULL;

             tp = tp->nxt)
                if (tp->addr == dnaddr)
                        return (tp->name);
 
        tp->addr = dnaddr;
             tp = tp->nxt)
                if (tp->addr == dnaddr)
                        return (tp->name);
 
        tp->addr = dnaddr;

-       tp->nxt = newhnamemem();
-       if (nflag)
-               tp->name = dnnum_string(dnaddr);
+       tp->nxt = newhnamemem(ndo);
+       if (ndo->ndo_nflag)
+               tp->name = dnnum_string(ndo, dnaddr);

        else
        else

-               tp->name = dnname_string(dnaddr);
+               tp->name = dnname_string(ndo, dnaddr);

 
        return(tp->name);
 }
 
 /* Return a zero'ed hnamemem struct and cuts down on calloc() overhead */
 struct hnamemem *
 
        return(tp->name);
 }
 
 /* Return a zero'ed hnamemem struct and cuts down on calloc() overhead */
 struct hnamemem *

-newhnamemem(void)
+newhnamemem(netdissect_options *ndo)

 {
 {

-       register struct hnamemem *p;
+       struct hnamemem *p;

        static struct hnamemem *ptr = NULL;
        static u_int num = 0;
 
        static struct hnamemem *ptr = NULL;
        static u_int num = 0;
 


@@ -1160,19 +1274,19 @@ newhnamemem(void)
                num = 64;
                ptr = (struct hnamemem *)calloc(num, sizeof (*ptr));
                if (ptr == NULL)
                num = 64;
                ptr = (struct hnamemem *)calloc(num, sizeof (*ptr));
                if (ptr == NULL)

-                       error("newhnamemem: calloc");
+                       (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                         "newhnamemem: calloc");

        }
        --num;
        p = ptr++;
        return (p);
 }
 
        }
        --num;
        p = ptr++;
        return (p);
 }
 

-#ifdef INET6

 /* Return a zero'ed h6namemem struct and cuts down on calloc() overhead */
 struct h6namemem *
 /* Return a zero'ed h6namemem struct and cuts down on calloc() overhead */
 struct h6namemem *

-newh6namemem(void)
+newh6namemem(netdissect_options *ndo)

 {
 {

-       register struct h6namemem *p;
+       struct h6namemem *p;

        static struct h6namemem *ptr = NULL;
        static u_int num = 0;
 
        static struct h6namemem *ptr = NULL;
        static u_int num = 0;
 


@@ -1180,10 +1294,22 @@ newh6namemem(void)
                num = 64;
                ptr = (struct h6namemem *)calloc(num, sizeof (*ptr));
                if (ptr == NULL)
                num = 64;
                ptr = (struct h6namemem *)calloc(num, sizeof (*ptr));
                if (ptr == NULL)

-                       error("newh6namemem: calloc");
+                       (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                         "newh6namemem: calloc");

        }
        --num;
        p = ptr++;
        return (p);
 }
        }
        --num;
        p = ptr++;
        return (p);
 }

-#endif /* INET6 */
+
+/* Represent TCI part of the 802.1Q 4-octet tag as text. */
+const char *
+ieee8021q_tci_string(const uint16_t tci)
+{
+       static char buf[128];
+       nd_snprintf(buf, sizeof(buf), "vlan %u, p %u%s",
+                tci & 0xfff,
+                tci >> 13,
+                (tci & 0x1000) ? ", DEI" : "");
+       return buf;
+}