CI: Add warning exemptions for Sun C (suncc-5.15) on Solaris 10

[tcpdump] / addrtoname.c

diff --git a/addrtoname.c b/addrtoname.c
index 1c80c39f0e7891f9244c3266da54787aff606c20..43bfc47d82a28be0c4bbbe565949f88addfdfbe5 100644 (file)
--- a/addrtoname.c
+++ b/addrtoname.c
@@ -22,9 +22,7 @@
  *  and address to string conversion routines
  */
 
  *  and address to string conversion routines
  */
 

-#ifdef HAVE_CONFIG_H

 #include <config.h>
 #include <config.h>

-#endif

 
 #ifdef HAVE_CASPER
 #include <libcasper.h>
 
 #ifdef HAVE_CASPER
 #include <libcasper.h>


@@ -33,76 +31,62 @@
 
 #include "netdissect-stdinc.h"
 
 
 #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.
-       */
+#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
       #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 */
+    #else /* HAVE_STRUCT_ETHER_ADDR */

        struct ether_addr {
        struct ether_addr {

-               unsigned char ether_addr_octet[6];
+               /* Beware FreeBSD calls this "octet". */
+               unsigned char ether_addr_octet[MAC48_LEN];

        };
        };

-      #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 */
+    #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 */

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


@@ -157,14 +141,15 @@ win32_gethostbyaddr(const char *addr, int len, int type)
        static struct hostent host;
        static char hostbuf[NI_MAXHOST];
        char hname[NI_MAXHOST];
        static struct hostent host;
        static char hostbuf[NI_MAXHOST];
        char hname[NI_MAXHOST];

-       struct sockaddr_in6 addr6;

 
        host.h_name = hostbuf;
        switch (type) {
        case AF_INET:
                return gethostbyaddr(addr, len, type);
                break;
 
        host.h_name = hostbuf;
        switch (type) {
        case AF_INET:
                return gethostbyaddr(addr, len, type);
                break;

-       case AF_INET6:
+#ifdef AF_INET6
+       case AF_INET6: {
+               struct sockaddr_in6 addr6;

                memset(&addr6, 0, sizeof(addr6));
                addr6.sin6_family = AF_INET6;
                memcpy(&addr6.sin6_addr, addr, len);
                memset(&addr6, 0, sizeof(addr6));
                addr6.sin6_family = AF_INET6;
                memcpy(&addr6.sin6_addr, addr, len);


@@ -176,6 +161,8 @@ win32_gethostbyaddr(const char *addr, int len, int type)
                        return &host;
                }
                break;
                        return &host;
                }
                break;

+       }
+#endif /* AF_INET6 */

        default:
                return NULL;
        }
        default:
                return NULL;
        }


@@ -184,7 +171,7 @@ win32_gethostbyaddr(const char *addr, int len, int type)
 #endif /* _WIN32 */
 
 struct h6namemem {
 #endif /* _WIN32 */
 
 struct h6namemem {

-       struct in6_addr addr;
+       nd_ipv6 addr;

        char *name;
        struct h6namemem *nxt;
 };
        char *name;
        struct h6namemem *nxt;
 };


@@ -235,7 +222,7 @@ intoa(uint32_t addr)
        int n;
        static char buf[sizeof(".xxx.xxx.xxx.xxx")];
 
        int n;
        static char buf[sizeof(".xxx.xxx.xxx.xxx")];
 

-       NTOHL(addr);
+       addr = ntohl(addr);

        cp = buf + sizeof(buf);
        *--cp = '\0';
 
        cp = buf + sizeof(buf);
        *--cp = '\0';
 


@@ -260,15 +247,14 @@ intoa(uint32_t addr)
 static uint32_t f_netmask;
 static uint32_t f_localnet;
 #ifdef HAVE_CASPER
 static uint32_t f_netmask;
 static uint32_t f_localnet;
 #ifdef HAVE_CASPER

-extern cap_channel_t *capdns;
+cap_channel_t *capdns;

 #endif
 
 /*
  * Return a name for the IP address pointed to by ap.  This address
  * is assumed to be in network byte order.
  *
 #endif
 
 /*
  * Return a name for the IP address pointed to by ap.  This address
  * is assumed to be in network byte order.
  *

- * 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, so you

  * *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
  * *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


@@ -304,6 +290,7 @@ ipaddr_string(netdissect_options *ndo, const u_char *ap)
         *      (2) Address is foreign and -f was given. (If -f was not
         *          given, f_netmask and f_localnet are 0 and the test
         *          evaluates to true)
         *      (2) Address is foreign and -f was given. (If -f was not
         *          given, f_netmask and f_localnet are 0 and the test
         *          evaluates to true)

+        * Both addr and f_netmask and f_localnet are in network byte order.

         */
        if (!ndo->ndo_nflag &&
            (addr & f_netmask) == f_localnet) {
         */
        if (!ndo->ndo_nflag &&
            (addr & f_netmask) == f_localnet) {


@@ -320,7 +307,7 @@ ipaddr_string(netdissect_options *ndo, const u_char *ap)
                        p->name = strdup(hp->h_name);
                        if (p->name == NULL)
                                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                        p->name = strdup(hp->h_name);
                        if (p->name == NULL)
                                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                       "ipaddr_string: strdup(hp->h_name)");
+                                       "%s: strdup(hp->h_name)", __func__);

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


@@ -333,7 +320,7 @@ ipaddr_string(netdissect_options *ndo, const u_char *ap)
        p->name = strdup(intoa(addr));
        if (p->name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
        p->name = strdup(intoa(addr));
        if (p->name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                 "ipaddr_string: strdup(intoa(addr))");
+                                 "%s: strdup(intoa(addr))", __func__);

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


@@ -346,7 +333,7 @@ ip6addr_string(netdissect_options *ndo, const u_char *ap)
 {
        struct hostent *hp;
        union {
 {
        struct hostent *hp;
        union {

-               struct in6_addr addr;
+               nd_ipv6 addr;

                struct for_hash_addr {
                        char fill[14];
                        uint16_t d;
                struct for_hash_addr {
                        char fill[14];
                        uint16_t d;


@@ -362,12 +349,13 @@ ip6addr_string(netdissect_options *ndo, const u_char *ap)
                if (memcmp(&p->addr, &addr, sizeof(addr)) == 0)
                        return (p->name);
        }
                if (memcmp(&p->addr, &addr, sizeof(addr)) == 0)
                        return (p->name);
        }

-       p->addr = addr.addr;
+       memcpy(p->addr, addr.addr, sizeof(nd_ipv6));

        p->nxt = newh6namemem(ndo);
 
        /*
         * Do not print names if -n was given.
         */
        p->nxt = newh6namemem(ndo);
 
        /*
         * Do not print names if -n was given.
         */

+#ifdef AF_INET6

        if (!ndo->ndo_nflag) {
 #ifdef HAVE_CASPER
                if (capdns != NULL) {
        if (!ndo->ndo_nflag) {
 #ifdef HAVE_CASPER
                if (capdns != NULL) {


@@ -383,7 +371,7 @@ ip6addr_string(netdissect_options *ndo, const u_char *ap)
                        p->name = strdup(hp->h_name);
                        if (p->name == NULL)
                                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                        p->name = strdup(hp->h_name);
                        if (p->name == NULL)
                                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                       "ip6addr_string: strdup(hp->h_name)");
+                                       "%s: strdup(hp->h_name)", __func__);

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


@@ -393,11 +381,12 @@ ip6addr_string(netdissect_options *ndo, const u_char *ap)
                        return (p->name);
                }
        }
                        return (p->name);
                }
        }

+#endif /* AF_INET6 */

        cp = addrtostr6(ap, ntop_buf, sizeof(ntop_buf));
        p->name = strdup(cp);
        if (p->name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
        cp = addrtostr6(ap, ntop_buf, sizeof(ntop_buf));
        p->name = strdup(cp);
        if (p->name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                 "ip6addr_string: strdup(cp)");
+                                 "%s: strdup(cp)", __func__);

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


@@ -406,6 +395,38 @@ static const char hex[16] = {
        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
 };
 
        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
 };
 

+/*
+ * Convert an octet to two hex digits.
+ *
+ * Coverity appears either:
+ *
+ *    not to believe the C standard when it asserts that a uint8_t is
+ *    exactly 8 bits in size;
+ *
+ *    not to believe that an unsigned type of exactly 8 bits has a value
+ *    in the range of 0 to 255;
+ *
+ *    not to believe that, for a range of unsigned values, if you shift
+ *    one of those values right by 4 bits, the maximum result value is
+ *    the maximum value shifted right by 4 bits, with no stray 1's shifted
+ *    in;
+ *
+ *    not to believe that 255 >> 4 is 15;
+ *
+ * so it gets upset that we're taking a "tainted" unsigned value, shifting
+ * it right 4 bits, and using it as an index into a 16-element array.
+ *
+ * So we do a stupid pointless masking of the result of the shift with
+ * 0xf, to hammer the point home to Coverity.
+ */
+static inline char *
+octet_to_hex(char *cp, uint8_t octet)
+{
+       *cp++ = hex[(octet >> 4) & 0xf];
+       *cp++ = hex[(octet >> 0) & 0xf];
+       return (cp);
+}
+

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


@@ -431,7 +452,7 @@ lookup_emem(netdissect_options *ndo, const u_char *ep)
        tp->e_addr2 = (u_short)k;
        tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
        if (tp->e_nxt == NULL)
        tp->e_addr2 = (u_short)k;
        tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
        if (tp->e_nxt == NULL)

-               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_emem: calloc");
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "%s: calloc", __func__);

 
        return tp;
 }
 
        return tp;
 }


@@ -477,14 +498,14 @@ lookup_bytestring(netdissect_options *ndo, const u_char *bs,
        tp->bs_bytes = (u_char *) calloc(1, nlen);
        if (tp->bs_bytes == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
        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");
+                                 "%s: calloc", __func__);

 
        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,
 
        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");
+                                 "%s: calloc", __func__);

 
        return tp;
 }
 
        return tp;
 }


@@ -504,8 +525,7 @@ lookup_nsap(netdissect_options *ndo, const u_char *nsap,
                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];

-       }
-       else
+       } else

                i = j = k = 0;
 
        tp = &nsaptable[(i ^ j) & (HASHNAMESIZE-1)];
                i = j = k = 0;
 
        tp = &nsaptable[(i ^ j) & (HASHNAMESIZE-1)];


@@ -524,12 +544,12 @@ lookup_nsap(netdissect_options *ndo, const u_char *nsap,
        tp->e_addr2 = (u_short)k;
        tp->e_nsap = (u_char *)malloc(nsap_length + 1);
        if (tp->e_nsap == NULL)
        tp->e_addr2 = (u_short)k;
        tp->e_nsap = (u_char *)malloc(nsap_length + 1);
        if (tp->e_nsap == NULL)

-               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_nsap: malloc");
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "%s: malloc", __func__);

        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_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)

-               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_nsap: calloc");
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "%s: calloc", __func__);

 
        return tp;
 }
 
        return tp;
 }


@@ -557,13 +577,13 @@ lookup_protoid(netdissect_options *ndo, const u_char *pi)
        tp->p_proto = (u_short)j;
        tp->p_nxt = (struct protoidmem *)calloc(1, sizeof(*tp));
        if (tp->p_nxt == NULL)
        tp->p_proto = (u_short)j;
        tp->p_nxt = (struct protoidmem *)calloc(1, sizeof(*tp));
        if (tp->p_nxt == NULL)

-               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "lookup_protoid: calloc");
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC, "%s: calloc", __func__);

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

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

 {
        int i;
        char *cp;
 {
        int i;
        char *cp;


@@ -577,40 +597,54 @@ etheraddr_string(netdissect_options *ndo, const uint8_t *ep)
 #ifdef USE_ETHER_NTOHOST
        if (!ndo->ndo_nflag) {
                char buf2[BUFSIZE];
 #ifdef USE_ETHER_NTOHOST
        if (!ndo->ndo_nflag) {
                char buf2[BUFSIZE];

+               /*
+                * This is a non-const copy of ep for ether_ntohost(), which
+                * has its second argument non-const in OpenBSD. Also saves a
+                * type cast.
+                */
+               struct ether_addr ea;

 
 

-               if (ether_ntohost(buf2, (const struct ether_addr *)ep) == 0) {
+               memcpy (&ea, ep, MAC48_LEN);
+               if (ether_ntohost(buf2, &ea) == 0) {

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

-                                       "etheraddr_string: strdup(buf2)");
+                                       "%s: strdup(buf2)", __func__);

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

-       *cp++ = hex[*ep >> 4 ];
-       *cp++ = hex[*ep++ & 0xf];
+       cp = octet_to_hex(cp, *ep++);

        for (i = 5; --i >= 0;) {
                *cp++ = ':';
        for (i = 5; --i >= 0;) {
                *cp++ = ':';

-               *cp++ = hex[*ep >> 4 ];
-               *cp++ = hex[*ep++ & 0xf];
+               cp = octet_to_hex(cp, *ep++);

        }
 
        if (!ndo->ndo_nflag) {
        }
 
        if (!ndo->ndo_nflag) {

-               nd_snprintf(cp, BUFSIZE - (2 + 5*3), " (oui %s)",
+               snprintf(cp, BUFSIZE - (2 + 5*3), " (oui %s)",

                    tok2str(oui_values, "Unknown", oui));
        } else
                *cp = '\0';
        tp->e_name = strdup(buf);
        if (tp->e_name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                    tok2str(oui_values, "Unknown", oui));
        } else
                *cp = '\0';
        tp->e_name = strdup(buf);
        if (tp->e_name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                 "etheraddr_string: strdup(buf)");
+                                 "%s: strdup(buf)", __func__);

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

-le64addr_string(netdissect_options *ndo, const uint8_t *ep)
+eui64_string(netdissect_options *ndo, const uint8_t *ep)
+{
+       return (linkaddr_string(ndo, ep, LINKADDR_EUI64, EUI64_LEN));
+}
+
+/*
+ * EUI-64 with the rightmost octet first.
+ */
+const char *
+eui64le_string(netdissect_options *ndo, const uint8_t *ep)

 {
        const unsigned int len = 8;
        u_int i;
 {
        const unsigned int len = 8;
        u_int i;


@@ -624,8 +658,7 @@ le64addr_string(netdissect_options *ndo, const uint8_t *ep)
 
        cp = buf;
        for (i = len; i > 0 ; --i) {
 
        cp = buf;
        for (i = len; i > 0 ; --i) {

-               *cp++ = hex[*(ep + i - 1) >> 4];
-               *cp++ = hex[*(ep + i - 1) & 0xf];
+               cp = octet_to_hex(cp, *(ep + i - 1));

                *cp++ = ':';
        }
        cp --;
                *cp++ = ':';
        }
        cp --;


@@ -635,7 +668,7 @@ le64addr_string(netdissect_options *ndo, const uint8_t *ep)
        tp->bs_name = strdup(buf);
        if (tp->bs_name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
        tp->bs_name = strdup(buf);
        if (tp->bs_name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                 "le64addr_string: strdup(buf)");
+                                 "%s: strdup(buf)", __func__);

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


@@ -651,8 +684,8 @@ linkaddr_string(netdissect_options *ndo, const uint8_t *ep,
        if (len == 0)
                return ("<empty>");
 
        if (len == 0)
                return ("<empty>");
 

-       if (type == LINKADDR_ETHER && len == MAC_ADDR_LEN)
-               return (etheraddr_string(ndo, ep));
+       if (type == LINKADDR_MAC48 && len == MAC48_LEN)
+               return (mac48_string(ndo, ep));

 
        if (type == LINKADDR_FRELAY)
                return (q922_string(ndo, ep, len));
 
        if (type == LINKADDR_FRELAY)
                return (q922_string(ndo, ep, len));


@@ -664,13 +697,11 @@ linkaddr_string(netdissect_options *ndo, const uint8_t *ep,
        tp->bs_name = cp = (char *)malloc(len*3);
        if (tp->bs_name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
        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];
+                                 "%s: malloc", __func__);
+       cp = octet_to_hex(cp, *ep++);

        for (i = len-1; i > 0 ; --i) {
                *cp++ = ':';
        for (i = len-1; i > 0 ; --i) {
                *cp++ = ':';

-               *cp++ = hex[*ep >> 4];
-               *cp++ = hex[*ep++ & 0xf];
+               cp = octet_to_hex(cp, *ep++);

        }
        *cp = '\0';
        return (tp->bs_name);
        }
        *cp = '\0';
        return (tp->bs_name);


@@ -695,11 +726,10 @@ isonsap_string(netdissect_options *ndo, const uint8_t *nsap,
        tp->e_name = cp = (char *)malloc(sizeof("xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xx"));
        if (cp == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
        tp->e_name = cp = (char *)malloc(sizeof("xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xx"));
        if (cp == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                 "isonsap_string: malloc");
+                                 "%s: malloc", __func__);

 
        for (nsap_idx = 0; nsap_idx < nsap_length; nsap_idx++) {
 
        for (nsap_idx = 0; nsap_idx < nsap_length; nsap_idx++) {

-               *cp++ = hex[*nsap >> 4];
-               *cp++ = hex[*nsap++ & 0xf];
+               cp = octet_to_hex(cp, *nsap++);

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


@@ -723,11 +753,11 @@ tcpport_string(netdissect_options *ndo, u_short port)
        tp->addr = i;
        tp->nxt = newhnamemem(ndo);
 
        tp->addr = i;
        tp->nxt = newhnamemem(ndo);
 

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

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

-                                 "tcpport_string: strdup(buf)");
+                                 "%s: strdup(buf)", __func__);

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


@@ -745,11 +775,11 @@ udpport_string(netdissect_options *ndo, u_short port)
        tp->addr = i;
        tp->nxt = newhnamemem(ndo);
 
        tp->addr = i;
        tp->nxt = newhnamemem(ndo);
 

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

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

-                                 "udpport_string: strdup(buf)");
+                                 "%s: strdup(buf)", __func__);

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


@@ -769,7 +799,7 @@ ipxsap_string(netdissect_options *ndo, u_short port)
        tp->nxt = newhnamemem(ndo);
 
        cp = buf;
        tp->nxt = newhnamemem(ndo);
 
        cp = buf;

-       NTOHS(port);
+       port = ntohs(port);

        *cp++ = hex[port >> 12 & 0xf];
        *cp++ = hex[port >> 8 & 0xf];
        *cp++ = hex[port >> 4 & 0xf];
        *cp++ = hex[port >> 12 & 0xf];
        *cp++ = hex[port >> 8 & 0xf];
        *cp++ = hex[port >> 4 & 0xf];


@@ -778,7 +808,7 @@ ipxsap_string(netdissect_options *ndo, u_short port)
        tp->name = strdup(buf);
        if (tp->name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
        tp->name = strdup(buf);
        if (tp->name == NULL)
                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                 "ipxsap_string: strdup(buf)");
+                                 "%s: strdup(buf)", __func__);

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


@@ -803,13 +833,13 @@ init_servarray(netdissect_options *ndo)
                while (table->name)
                        table = table->nxt;
                if (ndo->ndo_nflag) {
                while (table->name)
                        table = table->nxt;
                if (ndo->ndo_nflag) {

-                       (void)nd_snprintf(buf, sizeof(buf), "%d", port);
+                       (void)snprintf(buf, sizeof(buf), "%d", port);

                        table->name = strdup(buf);
                } else
                        table->name = strdup(sv->s_name);
                if (table->name == NULL)
                        (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                        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");
+                                         "%s: strdup", __func__);

 
                table->addr = port;
                table->nxt = newhnamemem(ndo);
 
                table->addr = port;
                table->nxt = newhnamemem(ndo);


@@ -821,26 +851,18 @@ static const struct eproto {
        const char *s;
        u_short p;
 } eproto_db[] = {
        const char *s;
        u_short p;
 } eproto_db[] = {

-       { "pup", ETHERTYPE_PUP },
-       { "xns", ETHERTYPE_NS },
+       { "aarp", ETHERTYPE_AARP },
+       { "arp", ETHERTYPE_ARP },
+       { "atalk", ETHERTYPE_ATALK },
+       { "decnet", ETHERTYPE_DN },

        { "ip", ETHERTYPE_IP },
        { "ip6", ETHERTYPE_IPV6 },
        { "ip", ETHERTYPE_IP },
        { "ip6", ETHERTYPE_IPV6 },

-       { "arp", ETHERTYPE_ARP },
-       { "rarp", ETHERTYPE_REVARP },
-       { "sprite", ETHERTYPE_SPRITE },
+       { "lat", ETHERTYPE_LAT },
+       { "loopback", ETHERTYPE_LOOPBACK },

        { "mopdl", ETHERTYPE_MOPDL },
        { "moprc", ETHERTYPE_MOPRC },
        { "mopdl", ETHERTYPE_MOPDL },
        { "moprc", ETHERTYPE_MOPRC },

-       { "decnet", ETHERTYPE_DN },
-       { "lat", ETHERTYPE_LAT },
+       { "rarp", ETHERTYPE_REVARP },

        { "sca", ETHERTYPE_SCA },
        { "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 }
 };
 
        { (char *)0, 0 }
 };
 


@@ -896,7 +918,7 @@ init_protoidarray(netdissect_options *ndo)
                tp->p_name = strdup(eproto_db[i].s);
                if (tp->p_name == NULL)
                        (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                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)");
+                               "%s: strdup(eproto_db[i].s)", __func__);

        }
        /* 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) {


@@ -910,7 +932,7 @@ init_protoidarray(netdissect_options *ndo)
 }
 
 static const struct etherlist {
 }
 
 static const struct etherlist {

-       const u_char addr[6];
+       const nd_mac48 addr;

        const char *name;
 } etherlist[] = {
        {{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, "Broadcast" },
        const char *name;
 } etherlist[] = {
        {{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, "Broadcast" },


@@ -921,7 +943,7 @@ static const struct etherlist {
  * Initialize the ethers hash table.  We take two different approaches
  * depending on whether or not the system provides the ethers name
  * service.  If it does, we just wire in a few names at startup,
  * Initialize the ethers hash table.  We take two different approaches
  * depending on whether or not the system provides the ethers name
  * service.  If it does, we just wire in a few names at startup,

- * and etheraddr_string() fills in the table on demand.  If it doesn't,
+ * and mac48_string() fills in the table on demand.  If it doesn't,

  * then we suck in the entire /etc/ethers file at startup.  The idea
  * is that parsing the local file will be fast, but spinning through
  * all the ethers entries via NIS & next_etherent might be very slow.
  * then we suck in the entire /etc/ethers file at startup.  The idea
  * is that parsing the local file will be fast, but spinning through
  * all the ethers entries via NIS & next_etherent might be very slow.


@@ -950,7 +972,7 @@ init_etherarray(netdissect_options *ndo)
                        tp->e_name = strdup(ep->name);
                        if (tp->e_name == NULL)
                                (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                        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)");
+                                       "%s: strdup(ep->addr)", __func__);

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


@@ -967,11 +989,14 @@ init_etherarray(netdissect_options *ndo)
                /*
                 * Use YP/NIS version of name if available.
                 */
                /*
                 * Use YP/NIS version of name if available.
                 */

-               if (ether_ntohost(name, (const struct ether_addr *)el->addr) == 0) {
+               /* Same workaround as in mac48_string(). */
+               struct ether_addr ea;
+               memcpy (&ea, el->addr, MAC48_LEN);
+               if (ether_ntohost(name, &ea) == 0) {

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

-                                       "init_etherarray: strdup(name)");
+                                       "%s: strdup(name)", __func__);

                        continue;
                }
 #endif
                        continue;
                }
 #endif


@@ -1098,7 +1123,7 @@ static const struct ipxsap_ent {
        { 0x030a, "GalacticommWorldgroupServer" },
        { 0x030c, "IntelNetport2/HP JetDirect/HP Quicksilver" },
        { 0x0320, "AttachmateGateway" },
        { 0x030a, "GalacticommWorldgroupServer" },
        { 0x030c, "IntelNetport2/HP JetDirect/HP Quicksilver" },
        { 0x0320, "AttachmateGateway" },

-       { 0x0327, "MicrosoftDiagnostiocs" },
+       { 0x0327, "MicrosoftDiagnostics" },

        { 0x0328, "WATCOM SQL Server" },
        { 0x0335, "MultiTechSystems MultisynchCommServer" },
        { 0x0343, "Xylogics RemoteAccessServer/LANModem" },
        { 0x0328, "WATCOM SQL Server" },
        { 0x0335, "MultiTechSystems MultisynchCommServer" },
        { 0x0343, "Xylogics RemoteAccessServer/LANModem" },


@@ -1220,7 +1245,7 @@ init_ipxsaparray(netdissect_options *ndo)
  * Initialize the address to name translation machinery.  We map all
  * 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
  * Initialize the address to name translation machinery.  We map all
  * 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.
+ * of the local network, mask is its subnet mask, both in network byte order.

  */
 void
 init_addrtoname(netdissect_options *ndo, uint32_t localnet, uint32_t mask)
  */
 void
 init_addrtoname(netdissect_options *ndo, uint32_t localnet, uint32_t mask)


@@ -1254,10 +1279,7 @@ dnaddr_string(netdissect_options *ndo, u_short dnaddr)
 
        tp->addr = dnaddr;
        tp->nxt = newhnamemem(ndo);
 
        tp->addr = dnaddr;
        tp->nxt = newhnamemem(ndo);

-       if (ndo->ndo_nflag)
-               tp->name = dnnum_string(ndo, dnaddr);
-       else
-               tp->name = dnname_string(ndo, dnaddr);
+       tp->name = dnnum_string(ndo, dnaddr);

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


@@ -1270,12 +1292,12 @@ newhnamemem(netdissect_options *ndo)
        static struct hnamemem *ptr = NULL;
        static u_int num = 0;
 
        static struct hnamemem *ptr = NULL;
        static u_int num = 0;
 

-       if (num  <= 0) {
+       if (num  == 0) {

                num = 64;
                ptr = (struct hnamemem *)calloc(num, sizeof (*ptr));
                if (ptr == NULL)
                        (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                num = 64;
                ptr = (struct hnamemem *)calloc(num, sizeof (*ptr));
                if (ptr == NULL)
                        (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                         "newhnamemem: calloc");
+                                         "%s: calloc", __func__);

        }
        --num;
        p = ptr++;
        }
        --num;
        p = ptr++;


@@ -1290,12 +1312,12 @@ newh6namemem(netdissect_options *ndo)
        static struct h6namemem *ptr = NULL;
        static u_int num = 0;
 
        static struct h6namemem *ptr = NULL;
        static u_int num = 0;
 

-       if (num  <= 0) {
+       if (num  == 0) {

                num = 64;
                ptr = (struct h6namemem *)calloc(num, sizeof (*ptr));
                if (ptr == NULL)
                        (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
                num = 64;
                ptr = (struct h6namemem *)calloc(num, sizeof (*ptr));
                if (ptr == NULL)
                        (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,

-                                         "newh6namemem: calloc");
+                                         "%s: calloc", __func__);

        }
        --num;
        p = ptr++;
        }
        --num;
        p = ptr++;


@@ -1307,7 +1329,7 @@ const char *
 ieee8021q_tci_string(const uint16_t tci)
 {
        static char buf[128];
 ieee8021q_tci_string(const uint16_t tci)
 {
        static char buf[128];

-       nd_snprintf(buf, sizeof(buf), "vlan %u, p %u%s",
+       snprintf(buf, sizeof(buf), "vlan %u, p %u%s",

                 tci & 0xfff,
                 tci >> 13,
                 (tci & 0x1000) ? ", DEI" : "");
                 tci & 0xfff,
                 tci >> 13,
                 (tci & 0x1000) ? ", DEI" : "");