/builds/wireshark/wireshark/epan/addr

Bug Summary

File:	builds/wireshark/wireshark/epan/addr_resolv.c
Warning:	line 3333, column 42 An undefined value may be read from 'errno'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name addr_resolv.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-21/lib/clang/21 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -isystem /builds/wireshark/wireshark/epan -isystem /builds/wireshark/wireshark/build/epan -isystem /usr/include/mit-krb5 -isystem /usr/include/libxml2 -isystem /usr/include/lua5.4 -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_BUILD_DLL -D WS_DEBUG -D WS_DEBUG_UTF_8 -D epan_EXPORTS -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/wiretap -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-nonliteral -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/wireshark/wireshark/sbout/2026-01-25-100340-3605-1 -x c /builds/wireshark/wireshark/epan/addr_resolv.c
1/* addr_resolv.c
* Routines for network object lookup
*
* Laurent Deniel <[email protected]>
*
* Add option to resolv VLAN ID to describing name
* Uli Heilmeier, March 2016
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <[email protected]>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/

16#include "config.h"

18#include <stdio.h>
19#include <stdlib.h>
20#include <string.h>
21#include <errno(*__errno_location ()).h>

23#include <wsutil/strtoi.h>
24#include <wsutil/ws_assert.h>

26#include "enterprises.h"
27#include "manuf.h"

29/*
* Win32 doesn't have SIGALRM (and it's the OS where name lookup calls
* are most likely to take a long time, given the way address-to-name
* lookups are done over NBNS).
*
* macOS does have SIGALRM, but if you longjmp() out of a name resolution
* call in a signal handler, you might crash, because the state of the
* resolution code that sends messages to lookupd might be inconsistent
* if you jump out of it in middle of a call.
*
* There's no guarantee that longjmp()ing out of name resolution calls
* will work on *any* platform; OpenBSD got rid of the alarm/longjmp
* code in tcpdump, to avoid those sorts of problems, and that was
* picked up by tcpdump.org tcpdump.
*
* So, for now, we do not use alarm() and SIGALRM to time out host name
* lookups.  If we get a lot of complaints about lookups taking a long time,
* we can reconsider that decision.  (Note that tcpdump originally added
* such a timeout mechanism that for the benefit of systems using NIS to
* look up host names; that might now be fixed in NIS implementations, for
* those sites still using NIS rather than DNS for that....  tcpdump no
* longer does that, for the same reasons that we don't.)
*
* If we're using an asynchronous DNS resolver, that shouldn't be an issue.
* If we're using a synchronous name lookup mechanism (which we'd do mainly
* to support resolving addresses and host names using more mechanisms than
* just DNS, such as NIS, NBNS, or Mr. Hosts File), we could do that in
* a separate thread, making it, in effect, asynchronous.
*/

59#ifdef HAVE_NETINET_IN_H1
60# include <netinet/in.h>
61#endif

63#ifdef HAVE_NETDB_H1
64#include <netdb.h>
65#endif

67#ifdef HAVE_SYS_SOCKET_H1
68#include <sys/socket.h>     /* needed to define AF_ values on UNIX */
69#endif

71#ifdef _WIN32
72#include <winsock2.h>       /* needed to define AF_ values on Windows */
73#include <ws2tcpip.h>
74#endif

76#ifdef _WIN32
77# define socklen_t unsigned int
78#endif
79#include <ares.h>
80#include <ares_version.h>

82#include <glib.h>

84#include <epan/packet.h>
85#include "addr_resolv.h"
86#include "wsutil/filesystem.h"

88#include <wsutil/report_message.h>
89#include <wsutil/file_util.h>
90#include <wsutil/pint.h>
91#include <wsutil/inet_cidr.h>

93#include <epan/strutil.h>
94#include <epan/to_str.h>
95#include <epan/maxmind_db.h>
96#include <epan/prefs.h>
97#include <epan/uat.h>
98#include "services.h"

100#define ENAME_HOSTS"hosts"     "hosts"
101#define ENAME_SUBNETS"subnets"   "subnets"
102#define ENAME_ETHERS"ethers"    "ethers"
103#define ENAME_IPXNETS"ipxnets"   "ipxnets"
104#define ENAME_MANUF"manuf"     "manuf"
105#define ENAME_WKA"wka"       "wka"
106#define ENAME_SERVICES"services"  "services"
107#define ENAME_VLANS"vlans"     "vlans"
108#define ENAME_SS7PCS"ss7pcs"    "ss7pcs"
109#define ENAME_ENTERPRISES"enterprises" "enterprises"
110#define ENAME_TACS"tacs"      "tacs"

112#define HASHETHSIZE2048      2048
113#define HASHHOSTSIZE2048     2048
114#define HASHIPXNETSIZE256    256
115#define SUBNETLENGTHSIZE32   32  /*1-32 inc.*/

117/* hash table used for IPv4 lookup */

119#define HASH_IPV4_ADDRESS(addr)((((((guint32) ( (((guint32) (addr) & (guint32) 0x000000ffU
) << 24) | (((guint32) (addr) & (guint32) 0x0000ff00U
) << 8) | (((guint32) (addr) & (guint32) 0x00ff0000U
) >> 8) | (((guint32) (addr) & (guint32) 0xff000000U
) >> 24)))))) & (2048 - 1)) (g_htonl(addr)(((((guint32) ( (((guint32) (addr) & (guint32) 0x000000ffU
) << 24) | (((guint32) (addr) & (guint32) 0x0000ff00U
) << 8) | (((guint32) (addr) & (guint32) 0x00ff0000U
) >> 8) | (((guint32) (addr) & (guint32) 0xff000000U
) >> 24)))))) & (HASHHOSTSIZE2048 - 1))


122typedef struct sub_net_hashipv4 {
  unsigned          addr;
  /* XXX: No longer needed?*/
  uint8_t           flags;          /* B0 dummy_entry, B1 resolve, B2 If the address is used in the trace */
  struct sub_net_hashipv4   *next;
  char              name[MAXNAMELEN64];
128} sub_net_hashipv4_t;

130/* Array of entries of subnets of different lengths */
131typedef struct {
  size_t       mask_length;      /*1-32*/
  uint32_t     mask;             /* e.g. 255.255.255.*/
  sub_net_hashipv4_t** subnet_addresses; /* Hash table of subnet addresses */
135} subnet_length_entry_t;


138/* hash table used for IPX network lookup */

140/* XXX - check goodness of hash function */

142#define HASH_IPX_NET(net)((net) & (256 - 1))   ((net) & (HASHIPXNETSIZE256 - 1))

144typedef struct hashipxnet {
  unsigned            addr;
  struct hashipxnet  *next;
  char                name[MAXNAMELEN64];
148} hashipxnet_t;

150typedef struct hashvlan {
  unsigned            id;
152/*    struct hashvlan     *next; */
  char                name[MAXVLANNAMELEN128];
154} hashvlan_t;

156typedef struct ss7pc {
  uint32_t            id; /* 1st byte NI, 3 following bytes: Point Code */
  char                pc_addr[MAXNAMELEN64];
  char                name[MAXNAMELEN64];
160} hashss7pc_t;

162/* hash tables used for ethernet and manufacturer lookup */
163struct hashether {
  uint8_t           flags;  /* (See above) */
  uint8_t           addr[6];
  char              hexaddr[6*3];
  char              resolved_name[MAXNAMELEN64];
168};

170struct hasheui64 {
  uint8_t           flags;  /* (See above) */
  uint8_t           addr[EUI64_ADDR_LEN8];
  char              hexaddr[EUI64_ADDR_LEN8*3];
  char              resolved_name[MAXNAMELEN64];
175};

177struct hashwka {
  uint8_t           flags;  /* (See above) */
  char*             name;
180};

182struct hashmanuf {
  uint8_t           flags;  /* (See above) */
  uint8_t           addr[3];
  char              hexaddr[3*3];
  char              resolved_name[MAXNAMELEN64];
  char              resolved_longname[MAXNAMELEN64];
188};

190/* internal type used when reading ethers file (or wka, manuf) */
191typedef struct _ether
192{
  uint8_t           addr[8];
  char              name[MAXNAMELEN64];
  char              longname[MAXNAMELEN64];
196} ether_t;

198/* internal ipxnet type */
199typedef struct _ipxnet
200{
  unsigned          addr;
  char              name[MAXNAMELEN64];
203} ipxnet_t;

205/* internal vlan type */
206typedef struct _vlan
207{
  unsigned          id;
  char              name[MAXVLANNAMELEN128];
210} vlan_t;

212static wmem_allocator_t *addr_resolv_scope;

214// Maps unsigned -> hashipxnet_t*
215static wmem_map_t *ipxnet_hash_table;
216static wmem_map_t *ipv4_hash_table;
217static wmem_map_t *ipv6_hash_table;
218// Maps unsigned -> hashvlan_t*
219static wmem_map_t *vlan_hash_table;
220static wmem_map_t *ss7pc_hash_table;
221static wmem_map_t *tac_hash_table;

223// Maps IP address -> manually set hostname.
224static wmem_map_t *manually_resolved_ipv4_list;
225static wmem_map_t *manually_resolved_ipv6_list;

227static addrinfo_lists_t addrinfo_lists;

229struct cb_serv_data {
  char        *service;
  port_type    proto;
232};

234// Maps unsigned -> hashmanuf_t*
235// XXX: Note that hashmanuf_t* only accommodates 24-bit OUIs.
236// We might want to store vendor names from MA-M and MA-S to
237// present in the Resolved Addresses dialog.
238static wmem_map_t *manuf_hashtable;
239// Maps address -> hashwka_t*
240static wmem_map_t *wka_hashtable;
241// Maps address -> hashether_t*
242static wmem_map_t *eth_hashtable;
243// Maps address -> hasheui64_t*
244static wmem_map_t *eui64_hashtable;
245// Maps unsigned -> serv_port_t*
246static wmem_map_t *serv_port_hashtable;
247static wmem_map_t *serv_port_custom_hashtable;

249// Maps enterprise-id -> enterprise-desc (only used for user additions)
250static GHashTable *enterprises_hashtable;

252static subnet_length_entry_t subnet_length_entries[SUBNETLENGTHSIZE32]; /* Ordered array of entries */
253static bool_Bool have_subnet_entry;

255static bool_Bool new_resolved_objects;

257static GPtrArray* extra_hosts_files;

259static hashether_t *add_eth_name(const uint8_t *addr, const char *name, bool_Bool static_entry);
260static hasheui64_t *add_eui64_name(const uint8_t *addr, const char *name, bool_Bool static_entry);
261static void add_serv_port_cb(const uint32_t port, void *ptr);

263/* http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx#existing
* One-at-a-Time hash
*/
266unsigned
267ipv6_oat_hash(const void *key)
268{
  int len = 16;
  const unsigned char *p = (const unsigned char *)key;
  unsigned h = 0;
  int i;

  for ( i = 0; i < len; i++ ) {
      h += p[i];
      h += ( h << 10 );
      h ^= ( h >> 6 );
  }

  h += ( h << 3 );
  h ^= ( h >> 11 );
  h += ( h << 15 );

  return h;
285}

287unsigned
288ws_ipv6_hash(const void* key)
289{
290#ifdef HAVE_XXHASH1
  return wmem_strong_hash(key, 16);
292#else
  return ipv6_oat_hash(key);
294#endif
295}

297gboolean
298ipv6_equal(const void *v1, const void *v2)
299{

  if (memcmp(v1, v2, sizeof (ws_in6_addr)) == 0) {
      return true1;
  }

  return false0;
306}

308/*
* Flag controlling what names to resolve.
*/
311e_addr_resolve gbl_resolv_flags = {
  true1,   /* mac_name */
  false0,  /* network_name */
  false0,  /* transport_name */
  true1,   /* dns_pkt_addr_resolution */
  false0,  /* handshake_sni_addr_resolution */
  true1,   /* use_external_net_name_resolver */
  false0,  /* vlan_name */
  false0,  /* ss7 point code names */
  true1,   /* maxmind_geoip */
  false0,  /* tac_name */
322};

324/* XXX - ares_init_options(3) says:
* "The recommended concurrent query limit is about 32k queries"
*/
327static unsigned name_resolve_concurrency = 500;
328static bool_Bool resolve_synchronously;

330/*
*  Global variables (can be changed in GUI sections)
*  XXX - they could be changed in GUI code, but there's currently no
*  GUI code to change them.
*/

336char *g_ethers_path;     /* global ethers file     */
337char *g_pethers_path;     /* personal ethers file   */
338char *g_wka_path;     /* global well-known-addresses file */
339char *g_manuf_path;     /* global manuf file      */
340char *g_pmanuf_path;     /* personal manuf file      */
341char *g_ipxnets_path;     /* global ipxnets file    */
342char *g_pipxnets_path;     /* personal ipxnets file  */
343char *g_services_path;     /* global services file   */
344char *g_pservices_path;     /* personal services file */
345char *g_pvlan_path;     /* personal vlans file    */
346char *g_ss7pcs_path;     /* personal ss7pcs file   */
347char *g_enterprises_path;   /* global enterprises file   */
348char *g_penterprises_path;  /* personal enterprises file */
                                  /* first resolving call   */

351/*
* Submitted asynchronous queries trigger a callback (c_ares_ghba_cb()).
* Queries are added to c_ares_queue_head. During processing, queries are
* popped off the front of c_ares_queue_head and submitted using
* ares_gethostbyaddr().
* The callback processes the response, then frees the request.
*/
358typedef struct _async_dns_queue_msg
359{
  union {
      uint32_t          ip4;
      ws_in6_addr ip6;
  } addr;
  int                 family;
365} async_dns_queue_msg_t;

367typedef struct _async_hostent {
  int addr_size;
  int   copied;
  void *addrp;
371} async_hostent_t;

373static void
374c_ares_ghba_cb(void *arg, int status, int timeouts _U___attribute__((unused)), struct hostent *he);

376/*
* Submitted synchronous queries trigger a callback (c_ares_ghba_sync_cb()).
* The callback processes the response, sets completed to true if
* completed is non-NULL, then frees the request.
*/
381typedef struct _sync_dns_data
382{
  union {
      uint32_t     ip4;
      ws_in6_addr  ip6;
  } addr;
  int              family;
  bool_Bool            *completed;
389} sync_dns_data_t;

391static ares_channel ghba_chan; /* ares_gethostbyaddr -- Usually non-interactive, no timeout */
392static ares_channel ghbn_chan; /* ares_gethostbyname -- Usually interactive, timeout */

394static  bool_Bool        async_dns_initialized;
395static  unsigned    async_dns_in_flight;
396static  wmem_list_t *async_dns_queue_head;
397static  GMutex      async_dns_queue_mtx;

399//UAT for providing a list of DNS servers to C-ARES for name resolution
400bool_Bool use_custom_dns_server_list;
401struct dns_server_data {
  char *ipaddr;
  uint32_t udp_port;
  uint32_t tcp_port;
405};

407UAT_CSTRING_CB_DEF(dnsserverlist_uats, ipaddr, struct dns_server_data)static void dnsserverlist_uats_ipaddr_set_cb(void* rec, const
 char* buf, unsigned len, const void* u1 __attribute__((unused
)), const void* u2 __attribute__((unused))) { char* new_buf =
 g_strndup(buf,len); g_free((((struct dns_server_data*)rec)->
ipaddr)); (((struct dns_server_data*)rec)->ipaddr) = new_buf
; } static void dnsserverlist_uats_ipaddr_tostr_cb(void* rec,
 char** out_ptr, unsigned* out_len, const void* u1 __attribute__
((unused)), const void* u2 __attribute__((unused))) { if (((struct
 dns_server_data*)rec)->ipaddr ) { *out_ptr = g_strdup_inline
 ((((struct dns_server_data*)rec)->ipaddr)); *out_len = (unsigned
)strlen((((struct dns_server_data*)rec)->ipaddr)); } else {
 *out_ptr = g_strdup_inline (""); *out_len = 0; } }
408UAT_DEC_CB_DEF(dnsserverlist_uats, tcp_port, struct dns_server_data)static void dnsserverlist_uats_tcp_port_set_cb(void* rec, const
 char* buf, unsigned len, const void* u1 __attribute__((unused
)), const void* u2 __attribute__((unused))) { char* tmp_str =
 g_strndup(buf,len); ws_strtou32(tmp_str, ((void*)0), &((
struct dns_server_data*)rec)->tcp_port); g_free(tmp_str); }
 static void dnsserverlist_uats_tcp_port_tostr_cb(void* rec, char
** out_ptr, unsigned* out_len, const void* u1 __attribute__((
unused)), const void* u2 __attribute__((unused))) { *out_ptr =
 wmem_strdup_printf(((void*)0), "%u",((struct dns_server_data
*)rec)->tcp_port); *out_len = (unsigned)strlen(*out_ptr); }
409UAT_DEC_CB_DEF(dnsserverlist_uats, udp_port, struct dns_server_data)static void dnsserverlist_uats_udp_port_set_cb(void* rec, const
 char* buf, unsigned len, const void* u1 __attribute__((unused
)), const void* u2 __attribute__((unused))) { char* tmp_str =
 g_strndup(buf,len); ws_strtou32(tmp_str, ((void*)0), &((
struct dns_server_data*)rec)->udp_port); g_free(tmp_str); }
 static void dnsserverlist_uats_udp_port_tostr_cb(void* rec, char
** out_ptr, unsigned* out_len, const void* u1 __attribute__((
unused)), const void* u2 __attribute__((unused))) { *out_ptr =
 wmem_strdup_printf(((void*)0), "%u",((struct dns_server_data
*)rec)->udp_port); *out_len = (unsigned)strlen(*out_ptr); }

411static uat_t *dnsserver_uat;
412static struct dns_server_data  *dnsserverlist_uats;
413static unsigned ndnsservers;

415static void
416dns_server_free_cb(void *data)
417{
  struct dns_server_data *h = (struct dns_server_data*)data;

  g_free(h->ipaddr);
421}

423static void*
424dns_server_copy_cb(void *dst_, const void *src_, size_t len _U___attribute__((unused)))
425{
  const struct dns_server_data *src = (const struct dns_server_data *)src_;
  struct dns_server_data       *dst = (struct dns_server_data *)dst_;

  dst->ipaddr = g_strdup(src->ipaddr)g_strdup_inline (src->ipaddr);
  dst->udp_port = src->udp_port;
  dst->tcp_port = src->tcp_port;

  return dst;
434}

436static bool_Bool
437dnsserver_uat_fld_ip_chk_cb(void* r _U___attribute__((unused)), const char* ipaddr, unsigned len _U___attribute__((unused)), const void* u1 _U___attribute__((unused)), const void* u2 _U___attribute__((unused)), char** err)
438{
  //Check for a valid IPv4 or IPv6 address.
  if (ipaddr && g_hostname_is_ip_address(ipaddr)) {
      *err = NULL((void*)0);
      return true1;
  }

  *err = ws_strdup_printf("No valid IP address given.")wmem_strdup_printf(((void*)0), "No valid IP address given.");
  return false0;
447}

449static bool_Bool
450dnsserver_uat_fld_port_chk_cb(void* r _U___attribute__((unused)), const char* p, unsigned len _U___attribute__((unused)), const void* u1 _U___attribute__((unused)), const void* u2 _U___attribute__((unused)), char** err)
451{
  if (!p || strlen(p) == 0u) {
      // This should be removed in favor of Decode As. Make it optional.
      *err = NULL((void*)0);
      return true1;
  }

  if (strcmp(p, "53") != 0){
      uint16_t port;
      if (!ws_strtou16(p, NULL((void*)0), &port)) {
          *err = g_strdup("Invalid port given.")g_strdup_inline ("Invalid port given.");
          return false0;
      }
  }

  *err = NULL((void*)0);
  return true1;
468}

470static void
471c_ares_ghba_sync_cb(void *arg, int status, int timeouts _U___attribute__((unused)), struct hostent *he) {
  sync_dns_data_t *sdd = (sync_dns_data_t *)arg;
  char **p;

  if (status == ARES_SUCCESS) {
      for (p = he->h_addr_list; *p != NULL((void*)0); p++) {
          switch(sdd->family) {
              case AF_INET2:
                  add_ipv4_name(sdd->addr.ip4, he->h_name, false0);
                  break;
              case AF_INET610:
                  add_ipv6_name(&sdd->addr.ip6, he->h_name, false0);
                  break;
              default:
                  /* Throw an exception? */
                  break;
          }
      }

  }

  /*
   * Let our caller know that this is complete.
   */
  *sdd->completed = true1;

  /*
   * Free the structure for this call.
   */
  g_free(sdd);
501}

503static void
504wait_for_sync_resolv(bool_Bool *completed) {
  int nfds;
  fd_set rfds, wfds;
  struct timeval tv;

  while (!*completed) {
      /*
       * Not yet resolved; wait for something to show up on the
       * address-to-name C-ARES channel.
       *
       * To quote the source code for ares_timeout() as of C-ARES
       * 1.12.0, "WARNING: Beware that this is linear in the number
       * of outstanding requests! You are probably far better off
       * just calling ares_process() once per second, rather than
       * calling ares_timeout() to figure out when to next call
       * ares_process().", although we should have only one request
       * outstanding.
       * As of C-ARES 1.20.0, the ares_timeout() function is now O(1),
       * but we don't require that minimum version.
       * https://github.com/c-ares/c-ares/commit/cf99c025cfb3e21295b59923876a31a68ea2cb4b
       *
       * And, yes, we have to reset it each time, as select(), in
       * some OSes modifies the timeout to reflect the time remaining
       * (e.g., Linux) and select() in other OSes doesn't (most if not
       * all other UN*Xes, Windows?), so we can't rely on *either*
       * behavior.
       */
      tv.tv_sec = 1;
      tv.tv_usec = 0;

      FD_ZERO(&rfds)do { unsigned int __i; fd_set *__arr = (&rfds); for (__i =
 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr
)->__fds_bits)[__i] = 0; } while (0);
      FD_ZERO(&wfds)do { unsigned int __i; fd_set *__arr = (&wfds); for (__i =
 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr
)->__fds_bits)[__i] = 0; } while (0);
      nfds = ares_fds(ghba_chan, &rfds, &wfds);
      if (nfds > 0) {
          if (select(nfds, &rfds, &wfds, NULL((void*)0), &tv) == -1) { /* call to select() failed */
              /* If it's interrupted by a signal, no need to put out a message */
              if (errno(*__errno_location ()) != EINTR4)
                  fprintf(stderrstderr, "Warning: call to select() failed, error is %s\n", g_strerror(errno(*__errno_location ())));
              return;
          }
          ares_process(ghba_chan, &rfds, &wfds);
      }
  }
547}

549static void
550process_async_dns_queue(void)
551{
  wmem_list_frame_t* head;
  async_dns_queue_msg_t *caqm;

  if (async_dns_queue_head == NULL((void*)0))
      return;

  if (!g_mutex_trylock(&async_dns_queue_mtx))
      return;

  head = wmem_list_head(async_dns_queue_head);

  while (head != NULL((void*)0) && async_dns_in_flight <= name_resolve_concurrency) {
      caqm = (async_dns_queue_msg_t *)wmem_list_frame_data(head);
      wmem_list_remove_frame(async_dns_queue_head, head);
      if (caqm->family == AF_INET2) {
          ares_gethostbyaddr(ghba_chan, &caqm->addr.ip4, sizeof(uint32_t), AF_INET2,
                  c_ares_ghba_cb, caqm);
          async_dns_in_flight++;
      } else if (caqm->family == AF_INET610) {
          ares_gethostbyaddr(ghba_chan, &caqm->addr.ip6, sizeof(ws_in6_addr),
                  AF_INET610, c_ares_ghba_cb, caqm);
          async_dns_in_flight++;
      }

      head = wmem_list_head(async_dns_queue_head);
  }

  g_mutex_unlock(&async_dns_queue_mtx);
580}

582static void
583wait_for_async_queue(void)
584{
  struct timeval tv = { 0, 0 };
  int nfds;
  fd_set rfds, wfds;

  new_resolved_objects = false0;

  if (!async_dns_initialized) {
      maxmind_db_lookup_process();
      return;
  }

  while (1) {
      /* We're switching to synchronous lookups, so process anything in
       * the asynchronous queue. There might be more in the queue than
       * name_resolve_concurrency allows, so check each cycle.
       */
      process_async_dns_queue();

      FD_ZERO(&rfds)do { unsigned int __i; fd_set *__arr = (&rfds); for (__i =
 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr
)->__fds_bits)[__i] = 0; } while (0);
      FD_ZERO(&wfds)do { unsigned int __i; fd_set *__arr = (&wfds); for (__i =
 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr
)->__fds_bits)[__i] = 0; } while (0);
      nfds = ares_fds(ghba_chan, &rfds, &wfds);
      if (nfds == 0) {
          /* No more requests waiting for reply; we're done here. */
          break;
      }

      /* See comment in wait_for_sync_resolv() about ares_timeout() being
       * O(N) in the number of outstanding requests until c-ares 1.20, and
       * why we might as well just set a 1 second to select().
       */
      tv.tv_sec = 1;
      tv.tv_usec = 0;

      if (select(nfds, &rfds, &wfds, NULL((void*)0), &tv) == -1) { /* call to select() failed */
          /* If it's interrupted by a signal, no need to put out a message */
          if (errno(*__errno_location ()) != EINTR4)
              fprintf(stderrstderr, "Warning: call to select() failed, error is %s\n", g_strerror(errno(*__errno_location ())));
          return;
      }
      ares_process(ghba_chan, &rfds, &wfds);
  }

  maxmind_db_lookup_process();
  return;
629}

631static void
632sync_lookup_ip4(const uint32_t addr)
633{
  bool_Bool completed = false0;
  sync_dns_data_t *sdd;

  if (!async_dns_initialized) {
      /*
       * c-ares not initialized.  Bail out.
       */
      return;
  }

  /*
   * Start the request.
   */
  sdd = g_new(sync_dns_data_t, 1)((sync_dns_data_t *) g_malloc_n ((1), sizeof (sync_dns_data_t
)));
  sdd->family = AF_INET2;
  sdd->addr.ip4 = addr;
  sdd->completed = &completed;
  ares_gethostbyaddr(ghba_chan, &addr, sizeof(uint32_t), AF_INET2,
                     c_ares_ghba_sync_cb, sdd);

  /*
   * Now wait for it to finish.
   */
  wait_for_sync_resolv(&completed);
658}

660static void
661sync_lookup_ip6(const ws_in6_addr *addrp)
662{
  bool_Bool completed = false0;
  sync_dns_data_t *sdd;

  if (!async_dns_initialized) {
      /*
       * c-ares not initialized.  Bail out.
       */
      return;
  }

  /*
   * Start the request.
   */
  sdd = g_new(sync_dns_data_t, 1)((sync_dns_data_t *) g_malloc_n ((1), sizeof (sync_dns_data_t
)));
  sdd->family = AF_INET610;
  memcpy(&sdd->addr.ip6, addrp, sizeof(sdd->addr.ip6));
  sdd->completed = &completed;
  ares_gethostbyaddr(ghba_chan, addrp, sizeof(ws_in6_addr), AF_INET610,
                     c_ares_ghba_sync_cb, sdd);

  /*
   * Now wait for it to finish.
   */
  wait_for_sync_resolv(&completed);
687}

689void
690set_resolution_synchrony(bool_Bool synchronous)
691{
  resolve_synchronously = synchronous;
  maxmind_db_set_synchrony(synchronous);

  if (synchronous) {
      wait_for_async_queue();
  }
698}

700static void
701c_ares_set_dns_servers(void)
702{
  if ((!async_dns_initialized) || (!use_custom_dns_server_list))
      return;

  if (ndnsservers == 0) {
      //clear the list of servers.  This may effectively disable name resolution
      ares_set_servers_ports(ghba_chan, NULL((void*)0));
      ares_set_servers_ports(ghbn_chan, NULL((void*)0));
  } else {
      struct ares_addr_port_node* servers = wmem_alloc_array(NULL, struct ares_addr_port_node, ndnsservers)((struct ares_addr_port_node*)wmem_alloc((((void*)0)), (((((ndnsservers
)) <= 0) || ((size_t)sizeof(struct ares_addr_port_node) >
 (9223372036854775807L / (size_t)((ndnsservers))))) ? 0 : (sizeof
(struct ares_addr_port_node) * ((ndnsservers))))));
      ws_in4_addr ipv4addr;
      ws_in6_addr ipv6addr;
      bool_Bool invalid_IP_found = false0;
      struct ares_addr_port_node* server;
      unsigned i;
      for (i = 0, server = servers; i < ndnsservers-1; i++, server++) {
          if (ws_inet_pton6(dnsserverlist_uats[i].ipaddr, &ipv6addr)) {
              server->family = AF_INET610;
              memcpy(&server->addr.addr6, &ipv6addr, 16);
          } else if (ws_inet_pton4(dnsserverlist_uats[i].ipaddr, &ipv4addr)) {
              server->family = AF_INET2;
              memcpy(&server->addr.addr4, &ipv4addr, 4);
          } else {
              //This shouldn't happen, but just in case...
              invalid_IP_found = true1;
              server->family = 0;
              memset(&server->addr.addr4, 0, 4);
              break;
          }

          server->udp_port = (int)dnsserverlist_uats[i].udp_port;
          server->tcp_port = (int)dnsserverlist_uats[i].tcp_port;

          server->next = (server+1);
      }
      if (!invalid_IP_found) {
          if (ws_inet_pton6(dnsserverlist_uats[i].ipaddr, &ipv6addr)) {
              server->family = AF_INET610;
              memcpy(&server->addr.addr6, &ipv6addr, 16);
          }
          else if (ws_inet_pton4(dnsserverlist_uats[i].ipaddr, &ipv4addr)) {
              server->family = AF_INET2;
              memcpy(&server->addr.addr4, &ipv4addr, 4);
          } else {
              //This shouldn't happen, but just in case...
              server->family = 0;
              memset(&server->addr.addr4, 0, 4);
          }
      }
      server->udp_port = (int)dnsserverlist_uats[i].udp_port;
      server->tcp_port = (int)dnsserverlist_uats[i].tcp_port;

      server->next = NULL((void*)0);

      ares_set_servers_ports(ghba_chan, servers);
      ares_set_servers_ports(ghbn_chan, servers);
      wmem_free(NULL((void*)0), servers);
  }
760}

762typedef struct {
  uint32_t     mask;
  size_t       mask_length;
  const char* name; /* Shallow copy */
766} subnet_entry_t;

768/* Maximum supported line length of hosts, services, manuf, etc. */
769#define MAX_LINELEN1024     1024

771/** Read a line without trailing (CR)LF. Returns -1 on failure.  */
772static int
773fgetline(char *buf, int size, FILE *fp)
774{
  if (fgets(buf, size, fp)) {
      int len = (int)strcspn(buf, "\r\n");
      buf[len] = '\0';
      return len;
  }
  return -1;

782} /* fgetline */


785/*
*  Local function definitions
*/
788static subnet_entry_t subnet_lookup(const uint32_t addr);
789static void subnet_entry_set(uint32_t subnet_addr, const uint8_t mask_length, const char* name);

791static unsigned serv_port_custom_hash(const void *k)
792{
  const serv_port_key_t *key = (const serv_port_key_t*)k;
  return key->port + (key->type << 16);
795}

797static gboolean serv_port_custom_equal(const void *k1, const void *k2)
798{
  const serv_port_key_t *key1 = (const serv_port_key_t*)k1;
  const serv_port_key_t *key2 = (const serv_port_key_t*)k2;

  return (key1->port == key2->port) && (key1->type == key2->type);
803}

805static void
806add_custom_service_name(port_type proto, const unsigned port, const char *service_name)
807{
  char *name;
  serv_port_key_t *key, *orig_key;

  key = wmem_new(addr_resolv_scope, serv_port_key_t)((serv_port_key_t*)wmem_alloc((addr_resolv_scope), sizeof(serv_port_key_t
)));
  key->port = (uint16_t)port;
  key->type = proto;

  if (wmem_map_lookup_extended(serv_port_custom_hashtable, key, (const void**)&orig_key, (void**)&name)) {
      wmem_free(addr_resolv_scope, orig_key);
      wmem_free(addr_resolv_scope, name);
  }

  name = wmem_strdup(addr_resolv_scope, service_name);
  wmem_map_insert(serv_port_custom_hashtable, key, name);

  // A new custom entry is not a new resolved object.
  // new_resolved_objects = true;
825}

827static void
828add_service_name(port_type proto, const unsigned port, const char *service_name)
829{
  serv_port_key_t *key = wmem_new(addr_resolv_scope, serv_port_key_t)((serv_port_key_t*)wmem_alloc((addr_resolv_scope), sizeof(serv_port_key_t
)));
  key->port = (uint16_t)port;
  key->type = proto;

  wmem_map_insert(serv_port_hashtable, key, (void*)service_name);

  new_resolved_objects = true1;
837}

839static void
840parse_service_line (char *line)
841{
  char *cp;
  char *service;
  char *port;
  port_type proto;
  struct cb_serv_data cb_data;
  range_t *port_rng = NULL((void*)0);

  if ((cp = strchr(line, '#')))
      *cp = '\0';

  if ((cp = strtok(line, " \t")) == NULL((void*)0))
      return;

  service = cp;

  if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0))
      return;

  port = cp;

  if (strtok(cp, "/") == NULL((void*)0))
      return;

  if (range_convert_str(NULL((void*)0), &port_rng, port, UINT16_MAX(65535)) != CVT_NO_ERROR) {
      wmem_free (NULL((void*)0), port_rng);
      return;
  }

  while ((cp = strtok(NULL((void*)0), "/")) != NULL((void*)0)) {
      if (strcmp(cp, "tcp") == 0) {
          proto = PT_TCP;
      }
      else if (strcmp(cp, "udp") == 0) {
          proto = PT_UDP;
      }
      else if (strcmp(cp, "sctp") == 0) {
          proto = PT_SCTP;
      }
      else if (strcmp(cp, "dccp") == 0) {
          proto = PT_DCCP;
      }
      else {
          break;
      }
      cb_data.service = service;
      cb_data.proto = proto;
      range_foreach(port_rng, add_serv_port_cb, &cb_data);
  }

  wmem_free (NULL((void*)0), port_rng);
892} /* parse_service_line */


895static void
896add_serv_port_cb(const uint32_t port, void *ptr)
897{
  struct cb_serv_data *cb_data = (struct cb_serv_data *)ptr;

  if ( port ) {
      add_custom_service_name(cb_data->proto, port, cb_data->service);
  }
903}


906static bool_Bool
907parse_services_file(const char * path)
908{
  FILE *serv_p;
  char    buf[MAX_LINELEN1024];

  /* services hash table initialization */
  serv_p = ws_fopenfopen(path, "r");

  if (serv_p == NULL((void*)0))
      return false0;

  while (fgetline(buf, sizeof(buf), serv_p) >= 0) {
      parse_service_line(buf);
  }

  fclose(serv_p);
  return true1;
924}

926/* -----------------
* unsigned integer to ascii
*/
929static char *
930wmem_utoa(wmem_allocator_t *allocator, unsigned port)
931{
  char *bp = (char *)wmem_alloc(allocator, MAXNAMELEN64);

  /* XXX, uint32_to_str() ? */
  uint32_to_str_buf(port, bp, MAXNAMELEN64);
  return bp;
937}

939static const char *
940_serv_name_lookup(port_type proto, unsigned port)
941{
  const char* name = NULL((void*)0);
  ws_services_proto_t p;
  ws_services_entry_t const *serv;

  const serv_port_key_t custom_key = { (uint16_t)port, proto };
  /* Look in the cache. Use an extended lookup so we can distinguish a port
   * we already tried but had no name from one we haven't tried. */
  if (!wmem_map_lookup_extended(serv_port_hashtable, &custom_key, NULL((void*)0), (void **)&name)) {
      /* Try the user custom table */
      name = wmem_map_lookup(serv_port_custom_hashtable, &custom_key);

      if (name == NULL((void*)0)) {
          /* now look in the global tables */
          bool_Bool valid_proto = true1;
          switch(proto) {
              case PT_TCP: p = ws_tcp; break;
              case PT_UDP: p = ws_udp; break;
              case PT_SCTP: p = ws_sctp; break;
              case PT_DCCP: p = ws_dccp; break;
              default: valid_proto = false0;
          }
          if (valid_proto) {
              serv = global_services_lookup(port, p);
              if (serv) {
                  name = serv->name;
              }
          }
      }

      /* Cache result (even if NULL, so we can know we have no result.) */
      add_service_name(proto, port, name);
  }

  return name;
976}

978const char *
979try_serv_name_lookup(port_type proto, unsigned port)
980{
  return (proto == PT_NONE) ? NULL((void*)0) : _serv_name_lookup(proto, port);
982}

984const char *
985serv_name_lookup(port_type proto, unsigned port)
986{
  const char *name;

  /* first look for the name */
  name = _serv_name_lookup(proto, port);
  if (name != NULL((void*)0))
      return name;

  /* No resolved name. Do we have a cached numeric string? */
  const serv_port_key_t key = { (uint16_t)port, PT_NONE };
  name = (const char*)wmem_map_lookup(serv_port_hashtable, &key);
  /* No name; create the numeric string. */
  if (name == NULL((void*)0)) {
      name = wmem_strdup_printf(addr_resolv_scope, "%u", port);
      add_service_name(PT_NONE, port, name);
  }

  return name;
1004}

1006static void
1007initialize_services(const char* app_env_var_prefix)
1008{
  ws_assert(serv_port_hashtable == NULL)do { if ((1) && !(serv_port_hashtable == ((void*)0)))
 ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/addr_resolv.c",
 1009, __func__, "assertion failed: %s", "serv_port_hashtable == ((void*)0)"
); } while (0);
  serv_port_hashtable = wmem_map_new(addr_resolv_scope, serv_port_custom_hash, serv_port_custom_equal);
  ws_assert(serv_port_custom_hashtable == NULL)do { if ((1) && !(serv_port_custom_hashtable == ((void
*)0))) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/addr_resolv.c"
, 1011, __func__, "assertion failed: %s", "serv_port_custom_hashtable == ((void*)0)"
); } while (0);
  serv_port_custom_hashtable = wmem_map_new(addr_resolv_scope, serv_port_custom_hash, serv_port_custom_equal);

  /* Compute the pathname of the global services file. */
  if (g_services_path == NULL((void*)0)) {
      g_services_path = get_datafile_path(ENAME_SERVICES"services", app_env_var_prefix);
  }
  parse_services_file(g_services_path);

  /* Compute the pathname of the personal services file */
  if (g_pservices_path == NULL((void*)0)) {
      /* Check profile directory before personal configuration */
      g_pservices_path = get_persconffile_path(ENAME_SERVICES"services", true1, app_env_var_prefix);
      if (!parse_services_file(g_pservices_path)) {
          g_free(g_pservices_path);
          g_pservices_path = get_persconffile_path(ENAME_SERVICES"services", false0, app_env_var_prefix);
          parse_services_file(g_pservices_path);
      }
  }
1030}

1032static void
1033service_name_lookup_cleanup(void)
1034{
  serv_port_hashtable = NULL((void*)0);
  serv_port_custom_hashtable = NULL((void*)0);
  g_free(g_services_path);
  g_services_path = NULL((void*)0);
  g_free(g_pservices_path);
  g_pservices_path = NULL((void*)0);
1041}

1043static void
1044parse_enterprises_line (char *line)
1045{
  char *tok, *dec_str, *org_str;
  uint32_t dec;
  bool_Bool had_comment = false0;

  /* Stop the line at any comment found */
  if ((tok = strchr(line, '#'))) {
      *tok = '\0';
      had_comment = true1;
  }
  /* Get enterprise number */
  dec_str = strtok(line, " \t");
  if (!dec_str)
      return;
  /* Get enterprise name */
  org_str = strtok(NULL((void*)0), ""); /* everything else */
  if (org_str && had_comment) {
      /* Only need to strip after (between name and where comment was) */
      org_str = g_strchomp(org_str);
  }
  if (!org_str)
      return;

  /* Add entry using number as key */
  if (!ws_strtou32(dec_str, NULL((void*)0), &dec))
      return;
  g_hash_table_insert(enterprises_hashtable, GUINT_TO_POINTER(dec)((gpointer) (gulong) (dec)), g_strdup(org_str)g_strdup_inline (org_str));
1072}


1075static bool_Bool
1076parse_enterprises_file(const char * path)
1077{
  FILE *fp;
  char    buf[MAX_LINELEN1024];

  fp = ws_fopenfopen(path, "r");
  if (fp == NULL((void*)0))
      return false0;

  while (fgetline(buf, sizeof(buf), fp) >= 0) {
      parse_enterprises_line(buf);
  }

  fclose(fp);
  return true1;
1091}

1093static void
1094initialize_enterprises(const char* app_env_var_prefix)
1095{
  ws_assert(enterprises_hashtable == NULL)do { if ((1) && !(enterprises_hashtable == ((void*)0)
)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/addr_resolv.c"
, 1096, __func__, "assertion failed: %s", "enterprises_hashtable == ((void*)0)"
); } while (0);
  enterprises_hashtable = g_hash_table_new_full(NULL((void*)0), NULL((void*)0), NULL((void*)0), g_free);

  if (g_enterprises_path == NULL((void*)0)) {
      g_enterprises_path = get_datafile_path(ENAME_ENTERPRISES"enterprises", app_env_var_prefix);
  }
  parse_enterprises_file(g_enterprises_path);

  /* Populate entries from profile or personal */
  if (g_penterprises_path == NULL((void*)0)) {
      /* Check profile directory before personal configuration */
      g_penterprises_path = get_persconffile_path(ENAME_ENTERPRISES"enterprises", true1, app_env_var_prefix);
      if (!file_exists(g_penterprises_path)) {
          g_free(g_penterprises_path);
          g_penterprises_path = get_persconffile_path(ENAME_ENTERPRISES"enterprises", false0, app_env_var_prefix);
      }
  }
  /* Parse personal file (if present) */
  parse_enterprises_file(g_penterprises_path);
1115}

1117const char *
1118try_enterprises_lookup(uint32_t value)
1119{
  /* Trying extra entries first. N.B. This does allow entries to be overwritten and found.. */
  const char *name = (const char *)g_hash_table_lookup(enterprises_hashtable, GUINT_TO_POINTER(value)((gpointer) (gulong) (value)));
  if (name) {
      return name;
  }
  else {
      return global_enterprises_lookup(value);
  }
1128}

1130const char *
1131enterprises_lookup(uint32_t value, const char *unknown_str)
1132{
  const char *s;

  s = try_enterprises_lookup(value);
  if (s != NULL((void*)0))
      return s;
  if (unknown_str != NULL((void*)0))
      return unknown_str;
  return "<Unknown>";
1141}

1143void
1144enterprises_base_custom(char *buf, uint32_t value)
1145{
  const char *s;

  if ((s = try_enterprises_lookup(value)) == NULL((void*)0))
      s = ITEM_LABEL_UNKNOWN_STR"Unknown";
  snprintf(buf, ITEM_LABEL_LENGTH240, "%s (%u)", s, value);
1151}

1153static void
1154enterprises_cleanup(void)
1155{
  ws_assert(enterprises_hashtable)do { if ((1) && !(enterprises_hashtable)) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 1156, __func__, "assertion failed: %s"
, "enterprises_hashtable"); } while (0);
  g_hash_table_destroy(enterprises_hashtable);
  enterprises_hashtable = NULL((void*)0);
  g_free(g_enterprises_path);
  g_enterprises_path = NULL((void*)0);
  g_free(g_penterprises_path);
  g_penterprises_path = NULL((void*)0);
1163}

1165/* Fill in an IP4 structure with info from subnets file or just with the
* string form of the address.
*/
1168bool_Bool
1169fill_dummy_ip4(const unsigned addr, hashipv4_t* volatile tp)
1170{
  subnet_entry_t subnet_entry;

  /* return value : true if addr matches any subnet */
  bool_Bool cidr_covered = false0;

  /* Overwrite if we get async DNS reply */

  /* Do we have a subnet for this address? */
  subnet_entry = subnet_lookup(addr);
  if (0 != subnet_entry.mask) {
      /* Print name, then '.' then IP address after subnet mask */
      uint32_t host_addr;
      char buffer[WS_INET_ADDRSTRLEN16];
      char* paddr;
      size_t i;

      host_addr = addr & (~subnet_entry.mask);
      ip_addr_to_str_buf(&host_addr, buffer, WS_INET_ADDRSTRLEN16);
      paddr = buffer;

      /* Skip to first octet that is not totally masked
       * If length of mask is 32, we chomp the whole address.
       * If the address string starts '.' (should not happen?),
       * we skip that '.'.
       */
      i = subnet_entry.mask_length / 8;
      while(*(paddr) != '\0' && i > 0) {
          if (*(++paddr) == '.') {
              --i;
          }
      }

      /* There are more efficient ways to do this, but this is safe if we
       * trust snprintf and MAXDNSNAMELEN
       */
      snprintf(tp->name, MAXDNSNAMELEN256, "%s%s", subnet_entry.name, paddr);

      /* Evaluate the subnet in CIDR notation
       * Reuse buffers built above
       */
      uint32_t subnet_addr;
      subnet_addr = addr & subnet_entry.mask;

      char buffer_subnet[WS_INET_ADDRSTRLEN16];
      ip_addr_to_str_buf(&subnet_addr, buffer_subnet, WS_INET_ADDRSTRLEN16);

      char buffer_cidr[WS_INET_CIDRADDRSTRLEN19];
      snprintf(buffer_cidr, WS_INET_CIDRADDRSTRLEN19, "%s%s%u", buffer_subnet, "/", (unsigned)subnet_entry.mask_length);

      snprintf(tp->cidr_addr, WS_INET_CIDRADDRSTRLEN19, "%s%s%u", buffer_subnet, "/", (unsigned)subnet_entry.mask_length);
      cidr_covered = true1;
  } else {
      /* XXX: This means we end up printing "1.2.3.4 (1.2.3.4)" in many cases */
      ip_addr_to_str_buf(&addr, tp->name, MAXDNSNAMELEN256);

      /* IP does not belong to any known subnet, just indicate this IP without "/.32" */
      ip_addr_to_str_buf(&addr, tp->cidr_addr, MAXDNSNAMELEN256);
  }
  return cidr_covered;
1230}


1233/* Fill in an IP6 structure with the string form of the address.
*/
1235static void
1236fill_dummy_ip6(hashipv6_t* volatile tp)
1237{
  /* Overwrite if we get async DNS reply */
  (void) g_strlcpy(tp->name, tp->ip6, MAXDNSNAMELEN256);
1240}

1242static void
1243c_ares_ghba_cb(void *arg, int status, int timeouts _U___attribute__((unused)), struct hostent *he) {
  async_dns_queue_msg_t *caqm = (async_dns_queue_msg_t *)arg;
  char **p;

  if (!caqm) return;
  /* XXX, what to do if async_dns_in_flight == 0? */
  async_dns_in_flight--;

  if (status == ARES_SUCCESS) {
      for (p = he->h_addr_list; *p != NULL((void*)0); p++) {
          switch(caqm->family) {
              case AF_INET2:
                  add_ipv4_name(caqm->addr.ip4, he->h_name, false0);
                  break;
              case AF_INET610:
                  add_ipv6_name(&caqm->addr.ip6, he->h_name, false0);
                  break;
              default:
                  /* Throw an exception? */
                  break;
          }
      }
  }
  wmem_free(addr_resolv_scope, caqm);
1267}

1269/* --------------- */
1270hashipv4_t *
1271new_ipv4(const unsigned addr)
1272{
  hashipv4_t *tp = wmem_new(addr_resolv_scope, hashipv4_t)((hashipv4_t*)wmem_alloc((addr_resolv_scope), sizeof(hashipv4_t
)));
  tp->addr = addr;
  tp->flags = 0;
  tp->name[0] = '\0';
  ip_addr_to_str_buf(&addr, tp->ip, sizeof(tp->ip));
  return tp;
1279}

1281static hashipv4_t *
1282host_lookup(const unsigned addr)
1283{
  hashipv4_t * volatile tp;

  tp = (hashipv4_t *)wmem_map_lookup(ipv4_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr)));
  if (tp == NULL((void*)0)) {
      /*
       * We don't already have an entry for this host name; create one,
       * and then try to resolve it.
       */
      tp = new_ipv4(addr);
      fill_dummy_ip4(addr, tp);
      wmem_map_insert(ipv4_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr)), tp);
  } else if (tp->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) {
      return tp;
  }

  /*
   * This hasn't been resolved yet, and we haven't tried to
   * resolve it already.
   */

  if (!gbl_resolv_flags.network_name)
      return tp;

  if (gbl_resolv_flags.use_external_net_name_resolver) {
      tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0);

      if (async_dns_initialized) {
          /* c-ares is initialized, so we can use it */
          if (resolve_synchronously || name_resolve_concurrency == 0) {
              /*
               * Either all names are to be resolved synchronously or
               * the concurrency level is 0; do the resolution
               * synchronously.
               */
              sync_lookup_ip4(addr);
          } else {
              /*
               * Names are to be resolved asynchronously, and we
               * allow at least one asynchronous request in flight;
               * post an asynchronous request.
               */
              async_dns_queue_msg_t *caqm;

              caqm = wmem_new(addr_resolv_scope, async_dns_queue_msg_t)((async_dns_queue_msg_t*)wmem_alloc((addr_resolv_scope), sizeof
(async_dns_queue_msg_t)));
              caqm->family = AF_INET2;
              caqm->addr.ip4 = addr;
              wmem_list_append(async_dns_queue_head, (void *) caqm);
          }
      }
  }

  return tp;

1337} /* host_lookup */

1339/* --------------- */
1340static hashipv6_t *
1341new_ipv6(const ws_in6_addr *addr)
1342{
  hashipv6_t *tp = wmem_new(addr_resolv_scope, hashipv6_t)((hashipv6_t*)wmem_alloc((addr_resolv_scope), sizeof(hashipv6_t
)));
  memcpy(tp->addr, addr->bytes, sizeof tp->addr);
  tp->flags = 0;
  tp->name[0] = '\0';
  ip6_to_str_buf(addr, tp->ip6, sizeof(tp->ip6));
  return tp;
1349}

1351/* ------------------------------------ */
1352static hashipv6_t *
1353host_lookup6(const ws_in6_addr *addr)
1354{
  hashipv6_t * volatile tp;

  tp = (hashipv6_t *)wmem_map_lookup(ipv6_hash_table, addr);
  if (tp == NULL((void*)0)) {
      /*
       * We don't already have an entry for this host name; create one,
       * and then try to resolve it.
       */
      ws_in6_addr *addr_key;

      addr_key = wmem_new(addr_resolv_scope, ws_in6_addr)((ws_in6_addr*)wmem_alloc((addr_resolv_scope), sizeof(ws_in6_addr
)));
      tp = new_ipv6(addr);
      memcpy(addr_key, addr, 16);
      fill_dummy_ip6(tp);
      wmem_map_insert(ipv6_hash_table, addr_key, tp);
  } else if (tp->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) {
      return tp;
  }

  /*
   * This hasn't been resolved yet, and we haven't tried to
   * resolve it already.
   */

  if (!gbl_resolv_flags.network_name)
      return tp;

  if (gbl_resolv_flags.use_external_net_name_resolver) {
      tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0);

      if (async_dns_initialized) {
          /* c-ares is initialized, so we can use it */
          if (resolve_synchronously || name_resolve_concurrency == 0) {
              /*
               * Either all names are to be resolved synchronously or
               * the concurrency level is 0; do the resolution
               * synchronously.
               */
              sync_lookup_ip6(addr);
          } else {
              /*
               * Names are to be resolved asynchronously, and we
               * allow at least one asynchronous request in flight;
               * post an asynchronous request.
               */
              async_dns_queue_msg_t *caqm;

              caqm = wmem_new(addr_resolv_scope, async_dns_queue_msg_t)((async_dns_queue_msg_t*)wmem_alloc((addr_resolv_scope), sizeof
(async_dns_queue_msg_t)));
              caqm->family = AF_INET610;
              memcpy(&caqm->addr.ip6, addr, sizeof(caqm->addr.ip6));
              wmem_list_append(async_dns_queue_head, (void *) caqm);
          }
      }
  }

  return tp;

1412} /* host_lookup6 */

1414/*
* Ethernet / manufacturer resolution
*
* The following functions implement ethernet address resolution and
* ethers files parsing (see ethers(4)).
*
* The manuf file has the same format as ethers(4) except that names are
* truncated to MAXMANUFLEN-1 (8) characters and that an address contains
* only 3 bytes (instead of 6).
*
* Notes:
*
* I decide to not use the existing functions (see ethers(3) on some
* operating systems) for the following reasons:
* - performance gains (use of hash tables and some other enhancements),
* - use of two ethers files (system-wide and per user),
* - avoid the use of NIS maps,
* - lack of these functions on some systems.
*
* So the following functions do _not_ behave as the standard ones.
*
* -- Laurent.
*/

1438/*
* Converts Ethernet addresses of the form aa:bb:cc or aa:bb:cc:dd:ee:ff/28.
* '-' is also supported as a separator. The
* octets must be exactly two hexadecimal characters and the mask must be either
* 28 or 36. Pre-condition: cp MUST be at least 21 bytes.
*/
1444static bool_Bool
1445parse_ether_address_fast(const unsigned char *cp, ether_t *eth, unsigned int *mask,
      const bool_Bool accept_mask)
1447{
  /* XXX copied from strutil.c */
  /* a map from ASCII hex chars to their value */
  static const int8_t str_to_nibble[256] = {
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
       0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1,
      -1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
  };
  const uint8_t *str_to_nibble_usg = (const uint8_t *)str_to_nibble;

  unsigned char sep = cp[2];
  if ((sep != ':' && sep != '-') || cp[5] != sep) {
      /* Unexpected separators. */
      return false0;
  }

  /* N.B. store octet values in an int to detect invalid (-1) entries */
  int num0 = (str_to_nibble_usg[cp[0]] << 4) | (int8_t)str_to_nibble_usg[cp[1]];
  int num1 = (str_to_nibble_usg[cp[3]] << 4) | (int8_t)str_to_nibble_usg[cp[4]];
  int num2 = (str_to_nibble_usg[cp[6]] << 4) | (int8_t)str_to_nibble_usg[cp[7]];

  if ((num0 | num1 | num2) & 0x100) {
      /* Not hexadecimal numbers. */
      return false0;
  }

  eth->addr[0] = (uint8_t)num0;
  eth->addr[1] = (uint8_t)num1;
  eth->addr[2] = (uint8_t)num2;

  if (cp[8] == '\0' && accept_mask) {
      /* Indicate that this is a manufacturer ID (0 is not allowed as a mask). */
      *mask = 0;
      return true1;
  } else if (cp[8] != sep || !accept_mask) {
      /* Format not handled by this fast path. */
      return false0;
  }

  /* N.B. store octet values in an int to detect invalid (-1) entries */
  int num3 = (str_to_nibble_usg[cp[9]]  << 4) | (int8_t)str_to_nibble_usg[cp[10]];
  int num4 = (str_to_nibble_usg[cp[12]] << 4) | (int8_t)str_to_nibble_usg[cp[13]];
  int num5 = (str_to_nibble_usg[cp[15]] << 4) | (int8_t)str_to_nibble_usg[cp[16]];

  if (((num3 | num4 | num5) & 0x100) || cp[11] != sep || cp[14] != sep)  {
      /* Not hexadecimal numbers or invalid separators. */
      return false0;
  }

  eth->addr[3] = (uint8_t)num3;
  eth->addr[4] = (uint8_t)num4;
  eth->addr[5] = (uint8_t)num5;
  if (cp[17] == '\0') {
      /* We got 6 bytes, so this is a MAC address (48 is not allowed as a mask). */
      *mask = 48;
      return true1;
  } else if (cp[17] != '/' || cp[20] != '\0') {
      /* Format not handled by this fast path. */
      return false0;
  }

  int m1 = cp[18];
  int m2 = cp[19];
  if (m1 == '3' && m2 == '6') {   /* Mask /36 */
      eth->addr[4] &= 0xf0;
      eth->addr[5] = 0;
      *mask = 36;
      return true1;
  }
  if (m1 == '2' && m2 == '8') {   /* Mask /28 */
      eth->addr[3] &= 0xf0;
      eth->addr[4] = 0;
      eth->addr[5] = 0;
      *mask = 28;
      return true1;
  }
  /* Unsupported mask */
  return false0;
1538}

1540/*
* If "accept_mask" is false, cp must point to an address that consists
* of exactly 6 (EUI-48) or 8 (EUI-64) bytes.
* If "accept_mask" is true, parse an up-to-6-byte sequence with an optional
* mask.
*/
1546static bool_Bool
1547parse_ether_address(const char *cp, ether_t *eth, unsigned int *mask,
      const bool_Bool accept_mask)
1549{
  int i;
  unsigned long num;
  char *p;
  char sep = '\0';

  for (i = 0; i < EUI64_ADDR_LEN8; i++) {
      /* Get a hex number, 1 or 2 digits, no sign characters allowed. */
      if (!g_ascii_isxdigit(*cp)((g_ascii_table[(guchar) (*cp)] & G_ASCII_XDIGIT) != 0))
          return false0;
      num = strtoul(cp, &p, 16);
      if (p == cp)
          return false0; /* failed */
      if (num > 0xFF)
          return false0; /* not a valid octet */
      eth->addr[i] = (uint8_t) num;
      cp = p;     /* skip past the number */

      /* OK, what character terminated the octet? */
      if (*cp == '/') {
          /* "/" - this has a mask. */
          if (!accept_mask) {
              /* Entries with masks are not allowed in this file. */
              return false0;
          }
          cp++; /* skip past the '/' to get to the mask */
          if (!g_ascii_isdigit(*cp)((g_ascii_table[(guchar) (*cp)] & G_ASCII_DIGIT) != 0))
              return false0;   /* no sign allowed */
          num = strtoul(cp, &p, 10);
          if (p == cp)
              return false0;   /* failed */
          cp = p;   /* skip past the number */
          if (*cp != '\0' && !g_ascii_isspace(*cp)((g_ascii_table[(guchar) (*cp)] & G_ASCII_SPACE) != 0))
              return false0;   /* bogus terminator */
          if (num == 0 || num >= 48)
              return false0;   /* bogus mask */
          /* Mask out the bits not covered by the mask */
          *mask = (int)num;
          for (i = 0; num >= 8; i++, num -= 8)
              ;   /* skip octets entirely covered by the mask */
          /* Mask out the first masked octet */
          eth->addr[i] &= (0xFF << (8 - num));
          i++;
          /* Mask out completely-masked-out octets */
          for (; i < 6; i++)
              eth->addr[i] = 0;
          return true1;
      }
      if (*cp == '\0') {
          /* We're at the end of the address, and there's no mask. */
          if (i == 2) {
              /* We got 3 bytes, so this is a manufacturer ID. */
              if (!accept_mask) {
                  /* Manufacturer IDs are not allowed in this file */
                  return false0;
              }
              /* Indicate that this is a manufacturer ID (0 is not allowed
                 as a mask). */
              *mask = 0;
              return true1;
          }

          if (i == 5) {
              /* We got 6 bytes, so this is a MAC address (48 is not allowed as a mask). */
              if (mask) {
                  *mask = 48;
              }
              return true1;
          }

          if (i == 7) {
              /* We got 8 bytes, so this is a EUI-64 address (64 is not allowed as a mask). */
              if (mask) {
                  *mask = 64;
              }
              return true1;
          }

          /* We didn't get 3 or 6 or 8 bytes, and there's no mask; this is
             illegal. */
          return false0;
      } else {
          if (sep == '\0') {
              /* We don't know the separator used in this number; it can either
                 be ':', '-', or '.'. */
              if (*cp != ':' && *cp != '-' && *cp != '.')
                  return false0;
              sep = *cp;  /* subsequent separators must be the same */
          } else {
              /* It has to be the same as the first separator */
              if (*cp != sep)
                  return false0;
          }
      }
      cp++;
  }

  return true1;
1647}

1649static int
1650parse_ether_line(char *line, ether_t *eth, unsigned int *mask,
      const bool_Bool accept_mask)
1652{
  /*
   *  See the ethers(4) or ethers(5) man page for ethers file format
   *  (not available on all systems).
   *  We allow both ethernet address separators (':' and '-'),
   *  as well as Wireshark's '.' separator.
   */

  char *cp;

  line = g_strstrip(line)g_strchomp (g_strchug (line));
  if (line[0] == '\0' || line[0] == '#')
      return -1;

  if ((cp = strchr(line, '#'))) {
      *cp = '\0';
      g_strchomp(line);
  }

  if ((cp = strtok(line, " \t")) == NULL((void*)0))
      return -1;

  /* First try to match the common format for the large ethers file. */
  if (!parse_ether_address_fast((const uint8_t*)cp, eth, mask, accept_mask)) {
      /* Fallback for the well-known addresses (wka) file. */
      if (!parse_ether_address(cp, eth, mask, accept_mask))
          return -1;
  }

  if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0))
      return -1;

  (void) g_strlcpy(eth->name, cp, MAXNAMELEN64);

  if ((cp = strtok(NULL((void*)0), "\t")) != NULL((void*)0))
  {
      (void) g_strlcpy(eth->longname, cp, MAXNAMELEN64);
  } else {
      /* Make the long name the short name */
      (void) g_strlcpy(eth->longname, eth->name, MAXNAMELEN64);
  }

  return 0;

1696} /* parse_ether_line */

1698static FILE *eth_p;

1700static void
1701set_ethent(char *path)
1702{
  if (eth_p)
      rewind(eth_p);
  else
      eth_p = ws_fopenfopen(path, "r");
1707}

1709static void
1710end_ethent(void)
1711{
  if (eth_p) {
      fclose(eth_p);
      eth_p = NULL((void*)0);
  }
1716}

1718static ether_t *
1719get_ethent(unsigned int *mask, const bool_Bool accept_mask)
1720{

  static ether_t eth;
  char    buf[MAX_LINELEN1024];

  if (eth_p == NULL((void*)0))
      return NULL((void*)0);

  while (fgetline(buf, sizeof(buf), eth_p) >= 0) {
      if (parse_ether_line(buf, &eth, mask, accept_mask) == 0) {
          return &eth;
      }
  }

  return NULL((void*)0);

1736} /* get_ethent */

1738static hashmanuf_t *
1739manuf_hash_new_entry(const uint8_t *addr, const char* name, const char* longname)
1740{
  unsigned manuf_key;
  hashmanuf_t *manuf_value;
  char *endp;

  /* manuf needs only the 3 most significant octets of the ethernet address */
  manuf_key = (addr[0] << 16) + (addr[1] << 8) + addr[2];
  manuf_value = wmem_new(addr_resolv_scope, hashmanuf_t)((hashmanuf_t*)wmem_alloc((addr_resolv_scope), sizeof(hashmanuf_t
)));

  memcpy(manuf_value->addr, addr, 3);
  if (name != NULL((void*)0)) {
      (void) g_strlcpy(manuf_value->resolved_name, name, MAXNAMELEN64);
      manuf_value->flags = NAME_RESOLVED(1U<<1);
      if (longname != NULL((void*)0)) {
          (void) g_strlcpy(manuf_value->resolved_longname, longname, MAXNAMELEN64);
      }
      else {
          (void) g_strlcpy(manuf_value->resolved_longname, name, MAXNAMELEN64);
      }
  }
  else {
      manuf_value->flags = 0;
      manuf_value->resolved_name[0] = '\0';
      manuf_value->resolved_longname[0] = '\0';
  }
  /* Values returned by bytes_to_hexstr_punct() are *not* null-terminated */
  endp = bytes_to_hexstr_punct(manuf_value->hexaddr, addr, sizeof(manuf_value->addr), ':');
  *endp = '\0';

  wmem_map_insert(manuf_hashtable, GUINT_TO_POINTER(manuf_key)((gpointer) (gulong) (manuf_key)), manuf_value);
  return manuf_value;
1771}

1773static hashwka_t*
1774wka_hash_new_entry(const uint8_t *addr, char* name)
1775{
  uint8_t *wka_key;
  hashwka_t *wka_value;

  wka_key = (uint8_t *)wmem_alloc(addr_resolv_scope, 6);
  memcpy(wka_key, addr, 6);

  wka_value = (hashwka_t*)wmem_new(addr_resolv_scope, hashwka_t)((hashwka_t*)wmem_alloc((addr_resolv_scope), sizeof(hashwka_t
)));
  wka_value->flags = NAME_RESOLVED(1U<<1);
  wka_value->name = wmem_strdup(addr_resolv_scope, name);

  wmem_map_insert(wka_hashtable, wka_key, wka_value);
  return wka_value;
1788}

1790static void
1791add_manuf_name(const uint8_t *addr, unsigned int mask, char *name, char *longname)
1792{
  switch (mask)
  {
  case 0:
      {
      /* This is a manufacturer ID; add it to the manufacturer ID hash table */
      hashmanuf_t *entry = manuf_hash_new_entry(addr, name, longname);
      entry->flags |= STATIC_HOSTNAME(1U<<3);
      break;
      }
  case 48:
      {
      /* This is a well-known MAC address; add it to the Ethernet hash table */
      add_eth_name(addr, name, true1);
      break;
      }
  default:
      {
      /* This is a range of well-known addresses; add it to the well-known-address table */
      hashwka_t *entry = wka_hash_new_entry(addr, name);
      entry->flags |= STATIC_HOSTNAME(1U<<3);
      break;
      }
  }
1816} /* add_manuf_name */

1818/* XXX: manuf_name_lookup returns a hashmanuf_t*, which cannot hold a 28 or
* 36 bit MA-M or MA-S. So it returns those as unresolved. For EUI-48 and
* EUI-64, MA-M and MA-S should be checked for separately in the global
* tables.
*
* XXX - size_t is used only in a ws_return_val_if() that checks
* whether the argument has at least 3 bytes; that's done only if
* assertions are enabled, so it's used only if assertions are
* enabled.  This means that, if assertions aren't enabled, a
* warning that the argument is unused will be issued by at least
* some compilers, so we mark it as unused.  Should we do that
* check unconditionally, and just emit a warning if assertions
* are enabled?
*/
1832static hashmanuf_t *
1833manuf_name_lookup(const uint8_t *addr, size_t size _U___attribute__((unused)))
1834{
  uint32_t      manuf_key;
  uint8_t      oct;
  hashmanuf_t  *manuf_value;

  ws_return_val_if(size < 3, NULL)do { if (1 && (size < 3)) { ws_log_full("InvalidArg"
, LOG_LEVEL_WARNING, "epan/addr_resolv.c", 1839, __func__, "invalid argument: %s"
, "size < 3"); return (((void*)0)); } } while (0);

  /* manuf needs only the 3 most significant octets of the ethernet address */
  manuf_key = addr[0];
  manuf_key = manuf_key<<8;
  oct = addr[1];
  manuf_key = manuf_key | oct;
  manuf_key = manuf_key<<8;
  oct = addr[2];
  manuf_key = manuf_key | oct;


  /* first try to find a "perfect match" */
  manuf_value = (hashmanuf_t*)wmem_map_lookup(manuf_hashtable, GUINT_TO_POINTER(manuf_key)((gpointer) (gulong) (manuf_key)));
  if (manuf_value != NULL((void*)0)) {
      manuf_value->flags |= TRIED_RESOLVE_ADDRESS(1U<<0);
      return manuf_value;
  }

  /* Mask out the broadcast/multicast flag but not the locally
   * administered flag as locally administered means: not assigned
   * by the IEEE but the local administrator instead.
   * 0x01 multicast / broadcast bit
   * 0x02 locally administered bit */
  if ((manuf_key & 0x00010000) != 0) {
      manuf_key &= 0x00FEFFFF;
      manuf_value = (hashmanuf_t*)wmem_map_lookup(manuf_hashtable, GUINT_TO_POINTER(manuf_key)((gpointer) (gulong) (manuf_key)));
      if (manuf_value != NULL((void*)0)) {
          manuf_value->flags |= TRIED_RESOLVE_ADDRESS(1U<<0);
          return manuf_value;
      }
  }

  /* Try the global manuf tables. */
  const char *short_name, *long_name;
  /* We can't insert a 28 or 36 bit entry into the used hash table. */
  short_name = ws_manuf_lookup_oui24(addr, &long_name);
  if (short_name != NULL((void*)0)) {
      /* Found it */
      manuf_value = manuf_hash_new_entry(addr, short_name, long_name);
  } else {
      /* Add the address as a hex string */
      manuf_value = manuf_hash_new_entry(addr, NULL((void*)0), NULL((void*)0));
  }

  manuf_value->flags |= TRIED_RESOLVE_ADDRESS(1U<<0);
  return manuf_value;

1887} /* manuf_name_lookup */

1889static char *
1890wka_name_lookup(const uint8_t *addr, const unsigned int mask)
1891{
  uint8_t    masked_addr[6];
  unsigned   num;
  int        i;
  hashwka_t *value;

  if (wka_hashtable == NULL((void*)0)) {
      return NULL((void*)0);
  }
  /* Get the part of the address covered by the mask. */
  for (i = 0, num = mask; num >= 8; i++, num -= 8)
      masked_addr[i] = addr[i];   /* copy octets entirely covered by the mask */
  /* Mask out the first masked octet */
  masked_addr[i] = addr[i] & (0xFF << (8 - num));
  i++;
  /* Zero out completely-masked-out octets */
  for (; i < 6; i++)
      masked_addr[i] = 0;

  value = (hashwka_t*)wmem_map_lookup(wka_hashtable, masked_addr);

  if (value) {
      value->flags |= TRIED_RESOLVE_ADDRESS(1U<<0);
      return value->name;
  }

  return NULL((void*)0);

1919} /* wka_name_lookup */

1921unsigned get_hash_ether_status(hashether_t* ether)
1922{
  return ether->flags;
1924}

1926bool_Bool get_hash_ether_used(hashether_t* ether)
1927{
  return ((ether->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) == TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)));
1929}

1931char* get_hash_ether_hexaddr(hashether_t* ether)
1932{
  return ether->hexaddr;
1934}

1936char* get_hash_ether_resolved_name(hashether_t* ether)
1937{
  return ether->resolved_name;
1939}

1941bool_Bool get_hash_wka_used(hashwka_t* wka)
1942{
  return ((wka->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) == TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)));
1944}

1946char* get_hash_wka_resolved_name(hashwka_t* wka)
1947{
  return wka->name;
1949}

1951static unsigned
1952eth_addr_hash(const void *key)
1953{
  return wmem_strong_hash((const uint8_t *)key, 6);
1955}

1957static gboolean
1958eth_addr_cmp(const void *a, const void *b)
1959{
  return (memcmp(a, b, 6) == 0);
1961}

1963static unsigned
1964eui64_addr_hash(const void *key)
1965{
  return wmem_strong_hash((const uint8_t *)key, EUI64_ADDR_LEN8);
1967}

1969static gboolean
1970eui64_addr_cmp(const void *a, const void *b)
1971{
  return (memcmp(a, b, EUI64_ADDR_LEN8) == 0);
1973}

1975static void
1976initialize_ethers(const char* app_env_var_prefix)
1977{
  ether_t *eth;
  unsigned mask = 0;

  /* hash table initialization */
  ws_assert(wka_hashtable == NULL)do { if ((1) && !(wka_hashtable == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 1982, __func__, "assertion failed: %s"
, "wka_hashtable == ((void*)0)"); } while (0);
  wka_hashtable   = wmem_map_new(addr_resolv_scope, eth_addr_hash, eth_addr_cmp);
  ws_assert(manuf_hashtable == NULL)do { if ((1) && !(manuf_hashtable == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 1984, __func__, "assertion failed: %s"
, "manuf_hashtable == ((void*)0)"); } while (0);
  manuf_hashtable = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal);
  ws_assert(eth_hashtable == NULL)do { if ((1) && !(eth_hashtable == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 1986, __func__, "assertion failed: %s"
, "eth_hashtable == ((void*)0)"); } while (0);
  eth_hashtable   = wmem_map_new(addr_resolv_scope, eth_addr_hash, eth_addr_cmp);
  ws_assert(eui64_hashtable == NULL)do { if ((1) && !(eui64_hashtable == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 1988, __func__, "assertion failed: %s"
, "eui64_hashtable == ((void*)0)"); } while (0);
  eui64_hashtable = wmem_map_new(addr_resolv_scope, eui64_addr_hash, eui64_addr_cmp);

  /* Compute the pathname of the ethers file. */
  if (g_ethers_path == NULL((void*)0)) {
      g_ethers_path = g_build_filename(get_systemfile_dir(app_env_var_prefix), ENAME_ETHERS"ethers", NULL((void*)0));
  }

  /* Compute the pathname of the personal ethers file. */
  if (g_pethers_path == NULL((void*)0)) {
      /* Check profile directory before personal configuration */
      g_pethers_path = get_persconffile_path(ENAME_ETHERS"ethers", true1, app_env_var_prefix);
      if (!file_exists(g_pethers_path)) {
          g_free(g_pethers_path);
          g_pethers_path = get_persconffile_path(ENAME_ETHERS"ethers", false0, app_env_var_prefix);
      }
  }

  /* Compute the pathname of the global manuf file */
  if (g_manuf_path == NULL((void*)0))
      g_manuf_path = get_datafile_path(ENAME_MANUF"manuf", app_env_var_prefix);
  /* Read it and initialize the hash table */
  if (file_exists(g_manuf_path)) {
      set_ethent(g_manuf_path);
      while ((eth = get_ethent(&mask, true1))) {
          add_manuf_name(eth->addr, mask, eth->name, eth->longname);
      }
      end_ethent();
  }

  /* Compute the pathname of the personal manuf file */
  if (g_pmanuf_path == NULL((void*)0)) {
      /* Check profile directory before personal configuration */
      g_pmanuf_path = get_persconffile_path(ENAME_MANUF"manuf", true1, app_env_var_prefix);
      if (!file_exists(g_pmanuf_path)) {
          g_free(g_pmanuf_path);
          g_pmanuf_path = get_persconffile_path(ENAME_MANUF"manuf", false0, app_env_var_prefix);
      }
  }
  /* Read it and initialize the hash table */
  if (file_exists(g_pmanuf_path)) {
      set_ethent(g_pmanuf_path);
      while ((eth = get_ethent(&mask, true1))) {
          add_manuf_name(eth->addr, mask, eth->name, eth->longname);
      }
      end_ethent();
  }

  /* Compute the pathname of the wka file */
  if (g_wka_path == NULL((void*)0))
      g_wka_path = get_datafile_path(ENAME_WKA"wka", app_env_var_prefix);

  /* Read it and initialize the hash table */
  set_ethent(g_wka_path);
  while ((eth = get_ethent(&mask, true1))) {
      add_manuf_name(eth->addr, mask, eth->name, eth->longname);
  }
  end_ethent();

  /* Look at the ethers files last. These are set as static names,
   * so they override earlier entries, and the ones we read last
   * take precedence. Order of precedence is personal ethers file,
   * global ethers file, wka file, personal manuf file, global manuf
   * file, and then non-static sources like ARP Eth -> IP hostname
   * discovery (if enabled), NRB entries (if wiretap adds support for
   * EUI-48 in NRBs), etc.
   * XXX: What _is_ the proper order of precedence, and should it
   * be configurable? (cf. #18075) */
  set_ethent(g_ethers_path);
  while ((eth = get_ethent(&mask, false0))) {
      if (mask == 48) {
          add_eth_name(eth->addr, eth->name, true1);
      } else if (mask == 64) {
          add_eui64_name(eth->addr, eth->name, true1);
      }
  }
  end_ethent();

  if (file_exists(g_pethers_path)) {
      set_ethent(g_pethers_path);
      while ((eth = get_ethent(&mask, false0))) {
          if (mask == 48) {
              add_eth_name(eth->addr, eth->name, true1);
          } else if (mask == 64) {
              add_eui64_name(eth->addr, eth->name, true1);
          }
      }
      end_ethent();
  }

2078} /* initialize_ethers */

2080static void
2081ethers_cleanup(void)
2082{
  wka_hashtable = NULL((void*)0);
  manuf_hashtable = NULL((void*)0);
  eth_hashtable = NULL((void*)0);
  eui64_hashtable = NULL((void*)0);
  g_free(g_ethers_path);
  g_ethers_path = NULL((void*)0);
  g_free(g_pethers_path);
  g_pethers_path = NULL((void*)0);
  g_free(g_manuf_path);
  g_manuf_path = NULL((void*)0);
  g_free(g_pmanuf_path);
  g_pmanuf_path = NULL((void*)0);
  g_free(g_wka_path);
  g_wka_path = NULL((void*)0);
2097}

2099static void
2100eth_resolved_name_fill(hashether_t *tp, const char *name, unsigned mask, const uint8_t *addr)
2101{
  switch (mask) {
      case 24:
          snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x",
                  name, addr[3], addr[4], addr[5]);
          break;
      case 28:
          snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%01x:%02x:%02x",
                  name, addr[3] & 0x0F, addr[4], addr[5]);
          break;
      case 36:
          snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%01x:%02x",
                  name, addr[4] & 0x0F, addr[5]);
          break;
      default: // Future-proof generic algorithm
      {
          unsigned bytes = mask / 8;
          unsigned bitmask = mask % 8;

          int pos = snprintf(tp->resolved_name, MAXNAMELEN64, "%s", name);
          if (pos >= MAXNAMELEN64) return;

          if (bytes < 6) {
              pos += snprintf(tp->resolved_name + pos, MAXNAMELEN64 - pos,
                  bitmask >= 4 ? "_%01x" : "_%02x",
                  addr[bytes] & (0xFF >> bitmask));
              bytes++;
          }

          while (bytes < 6) {
              if (pos >= MAXNAMELEN64) return;
              pos += snprintf(tp->resolved_name + pos, MAXNAMELEN64 - pos, ":%02x",
                  addr[bytes]);
              bytes++;
          }
      }
  }
2138}

2140/* Resolve ethernet address */
2141static hashether_t *
2142eth_addr_resolve(hashether_t *tp) {
  hashmanuf_t *manuf_value;
  const uint8_t *addr = tp->addr;
  size_t addr_size = sizeof(tp->addr);

  if (!(tp->flags & NAME_RESOLVED(1U<<1))) {
      unsigned      mask;
      char         *name;
      address       ether_addr;

      /* Unknown name.  Try looking for it in the well-known-address
         tables for well-known address ranges smaller than 2^24. */
      mask = 7;
      do {
          /* Only the topmost 5 bytes participate fully */
          if ((name = wka_name_lookup(addr, mask+40)) != NULL((void*)0)) {
              snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x",
                      name, addr[5] & (0xFF >> mask));
              tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4);
              return tp;
          }
      } while (mask--);

      mask = 7;
      do {
          /* Only the topmost 4 bytes participate fully */
          if ((name = wka_name_lookup(addr, mask+32)) != NULL((void*)0)) {
              snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x",
                      name, addr[4] & (0xFF >> mask), addr[5]);
              tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4);
              return tp;
          }
      } while (mask--);

      mask = 7;
      do {
          /* Only the topmost 3 bytes participate fully */
          if ((name = wka_name_lookup(addr, mask+24)) != NULL((void*)0)) {
              snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x",
                      name, addr[3] & (0xFF >> mask), addr[4], addr[5]);
              tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4);
              return tp;
          }
      } while (mask--);

      /* Now try looking in the manufacturer table. */
      manuf_value = manuf_name_lookup(addr, addr_size);
      if ((manuf_value != NULL((void*)0)) && ((manuf_value->flags & NAME_RESOLVED(1U<<1)) == NAME_RESOLVED(1U<<1))) {
          snprintf(tp->resolved_name, MAXNAMELEN64, "%.*s_%02x:%02x:%02x",
                  MAXNAMELEN64 - 10, manuf_value->resolved_name, addr[3], addr[4], addr[5]);
          tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4);
          return tp;
      }

      /* Now try looking for it in the well-known-address
         tables for well-known address ranges larger than 2^24. */
      mask = 7;
      do {
          /* Only the topmost 2 bytes participate fully */
          if ((name = wka_name_lookup(addr, mask+16)) != NULL((void*)0)) {
              snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x:%02x",
                      name, addr[2] & (0xFF >> mask), addr[3], addr[4],
                      addr[5]);
              tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4);
              return tp;
          }
      } while (mask--);

      mask = 7;
      do {
          /* Only the topmost byte participates fully */
          if ((name = wka_name_lookup(addr, mask+8)) != NULL((void*)0)) {
              snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x:%02x:%02x",
                      name, addr[1] & (0xFF >> mask), addr[2], addr[3],
                      addr[4], addr[5]);
              tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4);
              return tp;
          }
      } while (mask--);

      mask = 7;
      do {
          /* Not even the topmost byte participates fully */
          if ((name = wka_name_lookup(addr, mask)) != NULL((void*)0)) {
              snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x:%02x:%02x:%02x",
                      name, addr[0] & (0xFF >> mask), addr[1], addr[2],
                      addr[3], addr[4], addr[5]);
              tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4);
              return tp;
          }
      } while (--mask); /* Work down to the last bit */

      /* Now try looking in the global manuf data for a MA-M or MA-S
       * match. We do this last so that the other files override this
       * result.
       */
      const char *short_name, *long_name;
      short_name = ws_manuf_lookup(addr, &long_name, &mask);
      if (short_name != NULL((void*)0)) {
          if (mask == 24) {
              /* This shouldn't happen as it should be handled above,
               * but it doesn't hurt.
               */
              manuf_hash_new_entry(addr, short_name, long_name);
          }
          eth_resolved_name_fill(tp, short_name, mask, addr);
          tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4);
          return tp;
      }
      /* No match whatsoever. */
      set_address(&ether_addr, AT_ETHER, 6, addr);
      address_to_str_buf(&ether_addr, tp->resolved_name, MAXNAMELEN64);
      return tp;
  }
  return tp;
2257} /* eth_addr_resolve */

2259static hashether_t *
2260eth_hash_new_entry(const uint8_t *addr, const bool_Bool resolve)
2261{
  hashether_t *tp;
  char *endp;

  tp = wmem_new(addr_resolv_scope, hashether_t)((hashether_t*)wmem_alloc((addr_resolv_scope), sizeof(hashether_t
)));
  memcpy(tp->addr, addr, sizeof(tp->addr));
  tp->flags = 0;
  /* Values returned by bytes_to_hexstr_punct() are *not* null-terminated */
  endp = bytes_to_hexstr_punct(tp->hexaddr, addr, sizeof(tp->addr), ':');
  *endp = '\0';
  tp->resolved_name[0] = '\0';

  if (resolve)
      eth_addr_resolve(tp);

  wmem_map_insert(eth_hashtable, tp->addr, tp);

  return tp;
2279} /* eth_hash_new_entry */

2281static hashether_t *
2282add_eth_name(const uint8_t *addr, const char *name, bool_Bool static_entry)
2283{
  hashether_t *tp;

  tp = (hashether_t *)wmem_map_lookup(eth_hashtable, addr);

  if (tp == NULL((void*)0)) {
      tp = eth_hash_new_entry(addr, false0);
  }

  if (strcmp(tp->resolved_name, name) != 0 && (static_entry || !(tp->flags & STATIC_HOSTNAME(1U<<3)))) {
      (void) g_strlcpy(tp->resolved_name, name, MAXNAMELEN64);
      tp->flags |= NAME_RESOLVED(1U<<1);
      if (static_entry) {
          tp->flags |= STATIC_HOSTNAME(1U<<3);
      }
      new_resolved_objects = true1;
  }

  return tp;
2302} /* add_eth_name */

2304static hashether_t *
2305eth_name_lookup(const uint8_t *addr, const bool_Bool resolve)
2306{
  hashether_t  *tp;

  tp = (hashether_t *)wmem_map_lookup(eth_hashtable, addr);

  if (tp == NULL((void*)0)) {
      tp = eth_hash_new_entry(addr, resolve);
  } else {
      if (resolve && !(tp->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)))) {
          eth_addr_resolve(tp); /* Found but needs to be resolved */
      }
  }
  if (resolve) {
      tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0);
  }

  return tp;

2324} /* eth_name_lookup */

2326static void
2327eui64_resolved_name_fill(hasheui64_t *tp, const char *name, unsigned mask, const uint8_t *addr)
2328{
  switch (mask) {
      case 24:
          snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x:%02x:%02x",
                  name, addr[3], addr[4], addr[5], addr[6], addr[7]);
          break;
      case 28:
          snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%01x:%02x:%02x:%02x:%02x",
                  name, addr[3] & 0x0F, addr[4], addr[5], addr[6], addr[7]);
          break;
      case 36:
          snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%01x:%02x:%02x:%02x",
                  name, addr[4] & 0x0F, addr[5], addr[6], addr[7]);
          break;
      default: // Future-proof generic algorithm
      {
          unsigned bytes = mask / 8;
          unsigned bitmask = mask % 8;

          int pos = snprintf(tp->resolved_name, MAXNAMELEN64, "%s", name);
          if (pos >= MAXNAMELEN64) return;

          if (bytes < EUI64_ADDR_LEN8) {
              pos += snprintf(tp->resolved_name + pos, MAXNAMELEN64 - pos,
                  bitmask >= 4 ? "_%01x" : "_%02x",
                  addr[bytes] & (0xFF >> bitmask));
              bytes++;
          }

          while (bytes < EUI64_ADDR_LEN8) {
              if (pos >= MAXNAMELEN64) return;
              pos += snprintf(tp->resolved_name + pos, MAXNAMELEN64 - pos, ":%02x",
                  addr[bytes]);
              bytes++;
          }
      }
  }
2365}

2367/* Resolve EUI-64 address */
2368static hasheui64_t *
2369eui64_addr_resolve(hasheui64_t *tp)
2370{
  hashmanuf_t *manuf_value;
  const uint8_t *addr = tp->addr;
  size_t addr_size = sizeof(tp->addr);

  if (!(tp->flags & NAME_RESOLVED(1U<<1))) {
      unsigned      mask;
      address       eui64_addr;
      /* manuf_name_lookup returns a hashmanuf_t* that covers an entire /24,
       * so we can't properly use it for MA-M and MA-S. We do want to check
       * it first so it also covers the user-defined tables.
       */
      manuf_value = manuf_name_lookup(addr, addr_size);
      if ((manuf_value != NULL((void*)0)) && ((manuf_value->flags & NAME_RESOLVED(1U<<1)) == NAME_RESOLVED(1U<<1))) {
          snprintf(tp->resolved_name, MAXNAMELEN64, "%.*s_%02x:%02x:%02x:%02x:%02x",
                  MAXNAMELEN64 - 16, manuf_value->resolved_name, addr[3], addr[4], addr[5], addr[6], addr[7]);
          tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4);
          return tp;
      }

      /* Now try looking in the global manuf data for a MA-M or MA-S
       * match. We do this last so that the other files override this
       * result.
       */
      const char *short_name, *long_name;
      short_name = ws_manuf_lookup(addr, &long_name, &mask);
      if (short_name != NULL((void*)0)) {
          if (mask == 24) {
              /* This shouldn't happen as it should be handled above,
               * but it doesn't hurt.
               */
              manuf_hash_new_entry(addr, short_name, long_name);
          }
          eui64_resolved_name_fill(tp, short_name, mask, addr);
          tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4);
          return tp;
      }
      /* No match whatsoever. */
      set_address(&eui64_addr, AT_EUI64, 8, addr);
      address_to_str_buf(&eui64_addr, tp->resolved_name, MAXNAMELEN64);
      return tp;
  }

  return tp;
2414} /* eui64_addr_resolve */

2416static hasheui64_t *
2417eui64_hash_new_entry(const uint8_t *addr, const bool_Bool resolve)
2418{
  hasheui64_t *tp;
  char *endp;

  tp = wmem_new(addr_resolv_scope, hasheui64_t)((hasheui64_t*)wmem_alloc((addr_resolv_scope), sizeof(hasheui64_t
)));
  memcpy(tp->addr, addr, sizeof(tp->addr));
  tp->flags = 0;
  /* Values returned by bytes_to_hexstr_punct() are *not* null-terminated */
  endp = bytes_to_hexstr_punct(tp->hexaddr, addr, sizeof(tp->addr), ':');
  *endp = '\0';
  tp->resolved_name[0] = '\0';

  if (resolve)
      eui64_addr_resolve(tp);

  wmem_map_insert(eui64_hashtable, tp->addr, tp);

  return tp;
2436} /* eui64_hash_new_entry */

2438static hasheui64_t *
2439add_eui64_name(const uint8_t *addr, const char *name, bool_Bool static_entry)
2440{
  hasheui64_t *tp;

  tp = (hasheui64_t *)wmem_map_lookup(eui64_hashtable, addr);

  if (tp == NULL((void*)0)) {
      tp = eui64_hash_new_entry(addr, false0);
  }

  if (strcmp(tp->resolved_name, name) != 0 && (static_entry || !(tp->flags & STATIC_HOSTNAME(1U<<3)))) {
      (void) g_strlcpy(tp->resolved_name, name, MAXNAMELEN64);
      tp->flags |= NAME_RESOLVED(1U<<1);
      if (static_entry) {
          tp->flags |= STATIC_HOSTNAME(1U<<3);
      }
      new_resolved_objects = true1;
  }

  return tp;
2459} /* add_eui64_name */

2461static hasheui64_t *
2462eui64_name_lookup(const uint8_t *addr, const bool_Bool resolve)
2463{
  hasheui64_t  *tp;

  tp = (hasheui64_t *)wmem_map_lookup(eui64_hashtable, addr);

  if (tp == NULL((void*)0)) {
      tp = eui64_hash_new_entry(addr, resolve);
  } else {
      if (resolve && !(tp->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)))) {
          eui64_addr_resolve(tp); /* Found but needs to be resolved */
      }
  }
  if (resolve) {
      tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0);
  }

  return tp;

2481} /* eui64_name_lookup */

2483/* IPXNETS */
2484static int
2485parse_ipxnets_line(char *line, ipxnet_t *ipxnet)
2486{
  /*
   *  We allow three address separators (':', '-', and '.'),
   *  as well as no separators
   */

  char      *cp;
  uint32_t  a, a0, a1, a2, a3;
  bool_Bool      found_single_number = false0;

  if ((cp = strchr(line, '#')))
      *cp = '\0';

  if ((cp = strtok(line, " \t\n")) == NULL((void*)0))
      return -1;

  /* Either fill a0,a1,a2,a3 and found_single_number is false,
   * fill a and found_single_number is true,
   * or return -1
   */
  if (sscanf(cp, "%x:%x:%x:%x", &a0, &a1, &a2, &a3) != 4) {
      if (sscanf(cp, "%x-%x-%x-%x", &a0, &a1, &a2, &a3) != 4) {
          if (sscanf(cp, "%x.%x.%x.%x", &a0, &a1, &a2, &a3) != 4) {
              if (sscanf(cp, "%x", &a) == 1) {
                  found_single_number = true1;
              }
              else {
                  return -1;
              }
          }
      }
  }

  if ((cp = strtok(NULL((void*)0), " \t\n")) == NULL((void*)0))
      return -1;

  if (found_single_number) {
      ipxnet->addr = a;
  }
  else {
      ipxnet->addr = (a0 << 24) | (a1 << 16) | (a2 << 8) | a3;
  }

  (void) g_strlcpy(ipxnet->name, cp, MAXNAMELEN64);

  return 0;

2533} /* parse_ipxnets_line */

2535static FILE *ipxnet_p;

2537static void
2538set_ipxnetent(char *path)
2539{
  if (ipxnet_p)
      rewind(ipxnet_p);
  else
      ipxnet_p = ws_fopenfopen(path, "r");
2544}

2546static void
2547end_ipxnetent(void)
2548{
  if (ipxnet_p) {
      fclose(ipxnet_p);
      ipxnet_p = NULL((void*)0);
  }
2553}

2555static ipxnet_t *
2556get_ipxnetent(void)
2557{

  static ipxnet_t ipxnet;
  char    buf[MAX_LINELEN1024];

  if (ipxnet_p == NULL((void*)0))
      return NULL((void*)0);

  while (fgetline(buf, sizeof(buf), ipxnet_p) >= 0) {
      if (parse_ipxnets_line(buf, &ipxnet) == 0) {
          return &ipxnet;
      }
  }

  return NULL((void*)0);

2573} /* get_ipxnetent */

2575static ipxnet_t *
2576get_ipxnetbyaddr(uint32_t addr)
2577{
  ipxnet_t *ipxnet;

  set_ipxnetent(g_ipxnets_path);

  while (((ipxnet = get_ipxnetent()) != NULL((void*)0)) && (addr != ipxnet->addr) ) ;

  if (ipxnet == NULL((void*)0)) {
      end_ipxnetent();

      set_ipxnetent(g_pipxnets_path);

      while (((ipxnet = get_ipxnetent()) != NULL((void*)0)) && (addr != ipxnet->addr) )
          ;

      end_ipxnetent();
  }

  return ipxnet;

2597} /* get_ipxnetbyaddr */

2599static void
2600initialize_ipxnets(const char* app_env_var_prefix)
2601{
  /* Compute the pathname of the ipxnets file.
   *
   * XXX - is there a notion of an "ipxnets file" in any flavor of
   * UNIX, or with any add-on Netware package for UNIX?  If not,
   * should the UNIX version of the ipxnets file be in the datafile
   * directory as well?
   */
  if (g_ipxnets_path == NULL((void*)0)) {
      g_ipxnets_path = wmem_strdup_printf(addr_resolv_scope, "%s" G_DIR_SEPARATOR_S"/" "%s",
              get_systemfile_dir(app_env_var_prefix), ENAME_IPXNETS"ipxnets");
  }

  /* Set g_pipxnets_path here, but don't actually do anything
   * with it. It's used in get_ipxnetbyaddr().
   */
  if (g_pipxnets_path == NULL((void*)0)) {
      /* Check profile directory before personal configuration */
      g_pipxnets_path = get_persconffile_path(ENAME_IPXNETS"ipxnets", true1, app_env_var_prefix);
      if (!file_exists(g_pipxnets_path)) {
          g_free(g_pipxnets_path);
          g_pipxnets_path = get_persconffile_path(ENAME_IPXNETS"ipxnets", false0, app_env_var_prefix);
      }
  }

2626} /* initialize_ipxnets */

2628static void
2629ipx_name_lookup_cleanup(void)
2630{
  g_ipxnets_path = NULL((void*)0);
  g_free(g_pipxnets_path);
  g_pipxnets_path = NULL((void*)0);
2634}

2636static char *
2637ipxnet_name_lookup(wmem_allocator_t *allocator, const unsigned addr)
2638{
  hashipxnet_t *tp;
  ipxnet_t *ipxnet;

  tp = (hashipxnet_t *)wmem_map_lookup(ipxnet_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr)));
  if (tp == NULL((void*)0)) {
      tp = wmem_new(addr_resolv_scope, hashipxnet_t)((hashipxnet_t*)wmem_alloc((addr_resolv_scope), sizeof(hashipxnet_t
)));
      wmem_map_insert(ipxnet_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr)), tp);
  } else {
      return wmem_strdup(allocator, tp->name);
  }

  /* fill in a new entry */

  tp->addr = addr;

  if ( (ipxnet = get_ipxnetbyaddr(addr)) == NULL((void*)0)) {
      /* unknown name */
      snprintf(tp->name, MAXNAMELEN64, "%X", addr);

  } else {
      (void) g_strlcpy(tp->name, ipxnet->name, MAXNAMELEN64);
  }

  return wmem_strdup(allocator, tp->name);

2664} /* ipxnet_name_lookup */

2666/* VLANS */
2667static int
2668parse_vlan_line(char *line, vlan_t *vlan)
2669{
  char      *cp;
  uint16_t  id;

  if ((cp = strchr(line, '#')))
      *cp = '\0';

  if ((cp = strtok(line, " \t\n")) == NULL((void*)0))
      return -1;

  if (sscanf(cp, "%" SCNu16"hu", &id) == 1) {
      vlan->id = id;
  }
  else {
      return -1;
  }

  if ((cp = strtok(NULL((void*)0), "\t\n")) == NULL((void*)0))
      return -1;

  (void) g_strlcpy(vlan->name, cp, MAXVLANNAMELEN128);

  return 0;

2693} /* parse_vlan_line */

2695static FILE *vlan_p;

2697static void
2698set_vlanent(char *path)
2699{
  if (vlan_p)
      rewind(vlan_p);
  else
      vlan_p = ws_fopenfopen(path, "r");
2704}

2706static void
2707end_vlanent(void)
2708{
  if (vlan_p) {
      fclose(vlan_p);
      vlan_p = NULL((void*)0);
  }
2713}

2715static vlan_t *
2716get_vlanent(void)
2717{

  static vlan_t vlan;
  char    buf[MAX_LINELEN1024];

  if (vlan_p == NULL((void*)0))
      return NULL((void*)0);

  while (fgetline(buf, sizeof(buf), vlan_p) >= 0) {
      if (parse_vlan_line(buf, &vlan) == 0) {
          return &vlan;
      }
  }

  return NULL((void*)0);

2733} /* get_vlanent */

2735static vlan_t *
2736get_vlannamebyid(uint16_t id)
2737{
  vlan_t *vlan;

  set_vlanent(g_pvlan_path);

  while (((vlan = get_vlanent()) != NULL((void*)0)) && (id != vlan->id) ) ;

  if (vlan == NULL((void*)0)) {
      end_vlanent();

  }

  return vlan;

2751} /* get_vlannamebyid */

2753static void
2754initialize_vlans(const char* app_env_var_prefix)
2755{
  ws_assert(vlan_hash_table == NULL)do { if ((1) && !(vlan_hash_table == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 2756, __func__, "assertion failed: %s"
, "vlan_hash_table == ((void*)0)"); } while (0);
  vlan_hash_table = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal);

  /* Set g_pvlan_path here, but don't actually do anything
   * with it. It's used in get_vlannamebyid()
   */
  if (g_pvlan_path == NULL((void*)0)) {
      /* Check profile directory before personal configuration */
      g_pvlan_path = get_persconffile_path(ENAME_VLANS"vlans", true1, app_env_var_prefix);
      if (!file_exists(g_pvlan_path)) {
          g_free(g_pvlan_path);
          g_pvlan_path = get_persconffile_path(ENAME_VLANS"vlans", false0, app_env_var_prefix);
      }
  }
2770} /* initialize_vlans */

2772static void
2773vlan_name_lookup_cleanup(void)
2774{
  end_vlanent();
  vlan_hash_table = NULL((void*)0);
  g_free(g_pvlan_path);
  g_pvlan_path = NULL((void*)0);
2779}

2781static const char *
2782vlan_name_lookup(const unsigned id)
2783{
  hashvlan_t *tp;
  vlan_t *vlan;

  tp = (hashvlan_t *)wmem_map_lookup(vlan_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)));
  if (tp == NULL((void*)0)) {
      tp = wmem_new(addr_resolv_scope, hashvlan_t)((hashvlan_t*)wmem_alloc((addr_resolv_scope), sizeof(hashvlan_t
)));
      wmem_map_insert(vlan_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)), tp);
  } else {
      return tp->name;
  }

  /* fill in a new entry */

  tp->id = id;

  if ( (vlan = get_vlannamebyid(id)) == NULL((void*)0)) {
      /* unknown name */
      snprintf(tp->name, MAXVLANNAMELEN128, "<%u>", id);

  } else {
      (void) g_strlcpy(tp->name, vlan->name, MAXVLANNAMELEN128);
  }

  return tp->name;

2809} /* vlan_name_lookup */
2810/* VLAN END */

2812static bool_Bool
2813read_hosts_file (const char *hostspath, bool_Bool store_entries)
2814{
  FILE *hf;
  char line[MAX_LINELEN1024];
  char *cp;
  union {
      uint32_t ip4_addr;
      ws_in6_addr ip6_addr;
  } host_addr;
  bool_Bool is_ipv6, entry_found = false0;

  /*
   *  See the hosts(4) or hosts(5) man page for hosts file format
   *  (not available on all systems).
   */
  if ((hf = ws_fopenfopen(hostspath, "r")) == NULL((void*)0))
      return false0;

  while (fgetline(line, sizeof(line), hf) >= 0) {
      if ((cp = strchr(line, '#')))
          *cp = '\0';

      if ((cp = strtok(line, " \t")) == NULL((void*)0))
          continue; /* no tokens in the line */

      if (ws_inet_pton6(cp, &host_addr.ip6_addr)) {
          /* Valid IPv6 */
          is_ipv6 = true1;
      } else if (ws_inet_pton4(cp, &host_addr.ip4_addr)) {
          /* Valid IPv4 */
          is_ipv6 = false0;
      } else {
          continue;
      }

      if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0))
          continue; /* no host name */

      entry_found = true1;
      if (store_entries) {
          if (is_ipv6) {
              add_ipv6_name(&host_addr.ip6_addr, cp, true1);
          } else {
              add_ipv4_name(host_addr.ip4_addr, cp, true1);
          }
      }
  }

  fclose(hf);
  return entry_found ? true1 : false0;
2863} /* read_hosts_file */

2865bool_Bool
2866add_hosts_file (const char *hosts_file)
2867{
  bool_Bool found = false0;
  unsigned i;

  if (!hosts_file)
      return false0;

  if (!extra_hosts_files)
      extra_hosts_files = g_ptr_array_new();

  for (i = 0; i < extra_hosts_files->len; i++) {
      if (strcmp(hosts_file, (const char *) g_ptr_array_index(extra_hosts_files, i)((extra_hosts_files)->pdata)[i]) == 0)
          found = true1;
  }

  if (!found) {
      g_ptr_array_add(extra_hosts_files, wmem_strdup(wmem_epan_scope(), hosts_file));
      return read_hosts_file (hosts_file, false0);
  }
  return true1;
2887}

2889bool_Bool
2890add_ip_name_from_string (const char *addr, const char *name)
2891{
  union {
      uint32_t ip4_addr;
      ws_in6_addr ip6_addr;
  } host_addr;
  bool_Bool is_ipv6;
  resolved_name_t *resolved_entry;

  if (ws_inet_pton6(addr, &host_addr.ip6_addr)) {
      is_ipv6 = true1;
  } else if (ws_inet_pton4(addr, &host_addr.ip4_addr)) {
      is_ipv6 = false0;
  } else {
      return false0;
  }

  if (is_ipv6) {
      resolved_entry = (resolved_name_t*)wmem_map_lookup(manually_resolved_ipv6_list, &host_addr.ip6_addr);
      if (resolved_entry)
      {
          // If we found a previous matching key (IP address), then just update the value (custom hostname);
          (void) g_strlcpy(resolved_entry->name, name, MAXDNSNAMELEN256);
      }
      else
      {
          // Add a new mapping entry, if this IP address isn't already in the list.
          ws_in6_addr* addr_key = wmem_new(wmem_epan_scope(), ws_in6_addr)((ws_in6_addr*)wmem_alloc((wmem_epan_scope()), sizeof(ws_in6_addr
)));
          memcpy(addr_key, &host_addr.ip6_addr, sizeof(ws_in6_addr));

          resolved_entry = wmem_new(wmem_epan_scope(), resolved_name_t)((resolved_name_t*)wmem_alloc((wmem_epan_scope()), sizeof(resolved_name_t
)));
          (void) g_strlcpy(resolved_entry->name, name, MAXDNSNAMELEN256);

          wmem_map_insert(manually_resolved_ipv6_list, addr_key, resolved_entry);
      }
  } else {
      resolved_entry = (resolved_name_t*)wmem_map_lookup(manually_resolved_ipv4_list, GUINT_TO_POINTER(host_addr.ip4_addr)((gpointer) (gulong) (host_addr.ip4_addr)));
      if (resolved_entry)
      {
          // If we found a previous matching key (IP address), then just update the value (custom hostname);
          (void) g_strlcpy(resolved_entry->name, name, MAXDNSNAMELEN256);
      }
      else
      {
          // Add a new mapping entry, if this IP address isn't already in the list.
          resolved_entry = wmem_new(wmem_epan_scope(), resolved_name_t)((resolved_name_t*)wmem_alloc((wmem_epan_scope()), sizeof(resolved_name_t
)));
          (void) g_strlcpy(resolved_entry->name, name, MAXDNSNAMELEN256);

          wmem_map_insert(manually_resolved_ipv4_list, GUINT_TO_POINTER(host_addr.ip4_addr)((gpointer) (gulong) (host_addr.ip4_addr)), resolved_entry);
      }
  }

  return true1;
2943} /* add_ip_name_from_string */

2945extern resolved_name_t* get_edited_resolved_name(const char* addr)
2946{
  uint32_t ip4_addr;
  ws_in6_addr ip6_addr;
  resolved_name_t* resolved_entry = NULL((void*)0);

  if (ws_inet_pton6(addr, &ip6_addr)) {
      resolved_entry = (resolved_name_t*)wmem_map_lookup(manually_resolved_ipv6_list, &ip6_addr);
  }
  else if (ws_inet_pton4(addr, &ip4_addr)) {
      resolved_entry = (resolved_name_t*)wmem_map_lookup(manually_resolved_ipv4_list, GUINT_TO_POINTER(ip4_addr)((gpointer) (gulong) (ip4_addr)));
  }

  return resolved_entry;
2959}

2961/*
* Add the resolved addresses that are in use to the list used to create the pcapng NRB
*/
2964static void
2965ipv4_hash_table_resolved_to_list(void *key _U___attribute__((unused)), void *value, void *user_data)
2966{
  addrinfo_lists_t *lists = (addrinfo_lists_t *)user_data;
  hashipv4_t *ipv4_hash_table_entry = (hashipv4_t *)value;

  if ((ipv4_hash_table_entry->flags & USED_AND_RESOLVED_MASK((1U<<1) | (1U<<2))) == USED_AND_RESOLVED_MASK((1U<<1) | (1U<<2))) {
      lists->ipv4_addr_list = g_list_prepend(lists->ipv4_addr_list, ipv4_hash_table_entry);
  }
2973}

2975/*
* Add the resolved addresses that are in use to the list used to create the pcapng NRB
*/
2978static void
2979ipv6_hash_table_resolved_to_list(void *key _U___attribute__((unused)), void *value, void *user_data)
2980{
  addrinfo_lists_t *lists = (addrinfo_lists_t *)user_data;
  hashipv6_t *ipv6_hash_table_entry = (hashipv6_t *)value;

  if ((ipv6_hash_table_entry->flags & USED_AND_RESOLVED_MASK((1U<<1) | (1U<<2))) == USED_AND_RESOLVED_MASK((1U<<1) | (1U<<2))) {
      lists->ipv6_addr_list = g_list_prepend(lists->ipv6_addr_list, ipv6_hash_table_entry);
  }
2987}

2989addrinfo_lists_t *
2990get_addrinfo_list(void)
2991{
  if (ipv4_hash_table) {
      wmem_map_foreach(ipv4_hash_table, ipv4_hash_table_resolved_to_list, &addrinfo_lists);
  }

  if (ipv6_hash_table) {
      wmem_map_foreach(ipv6_hash_table, ipv6_hash_table_resolved_to_list, &addrinfo_lists);
  }

  return &addrinfo_lists;
3001}

3003/* Read in a list of subnet definition - name pairs.
* <line> = <comment> | <entry> | <whitespace>
* <comment> = <whitespace>#<any>
* <entry> = <subnet_definition> <whitespace> <subnet_name> [<comment>|<whitespace><any>]
* <subnet_definition> = <ipv4_address> / <subnet_mask_length>
* <ipv4_address> is a full address; it will be masked to get the subnet-ID.
* <subnet_mask_length> is a decimal 1-31
* <subnet_name> is a string containing no whitespace.
* <whitespace> = (space | tab)+
* Any malformed entries are ignored.
* Any trailing data after the subnet_name is ignored.
*
* XXX Support IPv6
*/
3017static bool_Bool
3018read_subnets_file (const char *subnetspath)
3019{
  FILE *hf;
  char line[MAX_LINELEN1024];
  char *cp, *cp2;
  uint32_t host_addr; /* IPv4 ONLY */
  uint8_t mask_length;

  if ((hf = ws_fopenfopen(subnetspath, "r")) == NULL((void*)0))
      return false0;

  while (fgetline(line, sizeof(line), hf) >= 0) {
      if ((cp = strchr(line, '#')))
          *cp = '\0';

      if ((cp = strtok(line, " \t")) == NULL((void*)0))
          continue; /* no tokens in the line */


      /* Expected format is <IP4 address>/<subnet length> */
      cp2 = strchr(cp, '/');
      if (NULL((void*)0) == cp2) {
          /* No length */
          continue;
      }
      *cp2 = '\0'; /* Cut token */
      ++cp2    ;

      /* Check if this is a valid IPv4 address */
      if (!str_to_ip(cp, &host_addr)) {
          continue; /* no */
      }

      if (!ws_strtou8(cp2, NULL((void*)0), &mask_length) || mask_length == 0 || mask_length > 32) {
          continue; /* invalid mask length */
      }

      if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0))
          continue; /* no subnet name */

      subnet_entry_set(host_addr, mask_length, cp);
  }

  fclose(hf);
  return true1;
3063} /* read_subnets_file */

3065static subnet_entry_t
3066subnet_lookup(const uint32_t addr)
3067{
  subnet_entry_t subnet_entry;
  uint32_t i;

  /* Search mask lengths linearly, longest first */

  i = SUBNETLENGTHSIZE32;
  while(have_subnet_entry && i > 0) {
      uint32_t masked_addr;
      subnet_length_entry_t* length_entry;

      /* Note that we run from 31 (length 32)  to 0 (length 1)  */
      --i;
      ws_assert(i < SUBNETLENGTHSIZE)do { if ((1) && !(i < 32)) ws_log_fatal_full("", LOG_LEVEL_ERROR
, "epan/addr_resolv.c", 3080, __func__, "assertion failed: %s"
, "i < 32"); } while (0);


      length_entry = &subnet_length_entries[i];

      if (NULL((void*)0) != length_entry->subnet_addresses) {
          sub_net_hashipv4_t * tp;
          uint32_t hash_idx;

          masked_addr = addr & length_entry->mask;
          hash_idx = HASH_IPV4_ADDRESS(masked_addr)((((((guint32) ( (((guint32) (masked_addr) & (guint32) 0x000000ffU
) << 24) | (((guint32) (masked_addr) & (guint32) 0x0000ff00U
) << 8) | (((guint32) (masked_addr) & (guint32) 0x00ff0000U
) >> 8) | (((guint32) (masked_addr) & (guint32) 0xff000000U
) >> 24)))))) & (2048 - 1));

          tp = length_entry->subnet_addresses[hash_idx];
          while(tp != NULL((void*)0) && tp->addr != masked_addr) {
              tp = tp->next;
          }

          if (NULL((void*)0) != tp) {
              subnet_entry.mask = length_entry->mask;
              subnet_entry.mask_length = i + 1; /* Length is offset + 1 */
              subnet_entry.name = tp->name;
              return subnet_entry;
          }
      }
  }

  subnet_entry.mask = 0;
  subnet_entry.mask_length = 0;
  subnet_entry.name = NULL((void*)0);

  return subnet_entry;
3111}

3113/* Add a subnet-definition - name pair to the set.
* The definition is taken by masking the address passed in with the mask of the
* given length.
*/
3117static void
3118subnet_entry_set(uint32_t subnet_addr, const uint8_t mask_length, const char* name)
3119{
  subnet_length_entry_t* entry;
  sub_net_hashipv4_t * tp;
  size_t hash_idx;

  ws_assert(mask_length > 0 && mask_length <= 32)do { if ((1) && !(mask_length > 0 && mask_length
 <= 32)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/addr_resolv.c"
, 3124, __func__, "assertion failed: %s", "mask_length > 0 && mask_length <= 32"
); } while (0);

  entry = &subnet_length_entries[mask_length - 1];

  subnet_addr &= entry->mask;

  hash_idx = HASH_IPV4_ADDRESS(subnet_addr)((((((guint32) ( (((guint32) (subnet_addr) & (guint32) 0x000000ffU
) << 24) | (((guint32) (subnet_addr) & (guint32) 0x0000ff00U
) << 8) | (((guint32) (subnet_addr) & (guint32) 0x00ff0000U
) >> 8) | (((guint32) (subnet_addr) & (guint32) 0xff000000U
) >> 24)))))) & (2048 - 1));

  if (NULL((void*)0) == entry->subnet_addresses) {
      entry->subnet_addresses = (sub_net_hashipv4_t**)wmem_alloc0(addr_resolv_scope, sizeof(sub_net_hashipv4_t*) * HASHHOSTSIZE2048);
  }

  if (NULL((void*)0) != (tp = entry->subnet_addresses[hash_idx])) {
      sub_net_hashipv4_t * new_tp;

      while (tp->next) {
          if (tp->addr == subnet_addr) {
              return; /* XXX provide warning that an address was repeated? */
          } else {
              tp = tp->next;
          }
      }

      new_tp = wmem_new(addr_resolv_scope, sub_net_hashipv4_t)((sub_net_hashipv4_t*)wmem_alloc((addr_resolv_scope), sizeof(
sub_net_hashipv4_t)));
      tp->next = new_tp;
      tp = new_tp;
  } else {
      tp = entry->subnet_addresses[hash_idx] = wmem_new(addr_resolv_scope, sub_net_hashipv4_t)((sub_net_hashipv4_t*)wmem_alloc((addr_resolv_scope), sizeof(
sub_net_hashipv4_t)));
  }

  tp->next = NULL((void*)0);
  tp->addr = subnet_addr;
  (void) g_strlcpy(tp->name, name, MAXNAMELEN64); /* This is longer than subnet names can actually be */
  have_subnet_entry = true1;
3158}

3160static void
3161subnet_name_lookup_init(const char* app_env_var_prefix)
3162{
  char* subnetspath;
  uint32_t i;

  for(i = 0; i < SUBNETLENGTHSIZE32; ++i) {
      uint32_t length = i + 1;

      subnet_length_entries[i].subnet_addresses  = NULL((void*)0);
      subnet_length_entries[i].mask_length  = length;
      subnet_length_entries[i].mask = g_htonl(ws_ipv4_get_subnet_mask(length))(((((guint32) ( (((guint32) (ws_ipv4_get_subnet_mask(length))
 & (guint32) 0x000000ffU) << 24) | (((guint32) (ws_ipv4_get_subnet_mask
(length)) & (guint32) 0x0000ff00U) << 8) | (((guint32
) (ws_ipv4_get_subnet_mask(length)) & (guint32) 0x00ff0000U
) >> 8) | (((guint32) (ws_ipv4_get_subnet_mask(length))
 & (guint32) 0xff000000U) >> 24))))));
  }

  /* Check profile directory before personal configuration */
  subnetspath = get_persconffile_path(ENAME_SUBNETS"subnets", true1, app_env_var_prefix);
  if (!read_subnets_file(subnetspath)) {
      if (errno(*__errno_location ()) != ENOENT2) {
          report_open_failure(subnetspath, errno(*__errno_location ()), false0);
      }

      g_free(subnetspath);
      subnetspath = get_persconffile_path(ENAME_SUBNETS"subnets", false0, app_env_var_prefix);
      if (!read_subnets_file(subnetspath) && errno(*__errno_location ()) != ENOENT2) {
          report_open_failure(subnetspath, errno(*__errno_location ()), false0);
      }
  }
  g_free(subnetspath);

  /*
   * Load the global subnets file, if we have one.
   */
  subnetspath = get_datafile_path(ENAME_SUBNETS"subnets", app_env_var_prefix);
  if (!read_subnets_file(subnetspath) && errno(*__errno_location ()) != ENOENT2) {
      report_open_failure(subnetspath, errno(*__errno_location ()), false0);
  }
  g_free(subnetspath);
3197}

3199/* SS7 PC Name Resolution Portion */
3200static hashss7pc_t *
3201new_ss7pc(const uint8_t ni, const uint32_t pc)
3202{
  hashss7pc_t *tp = wmem_new(addr_resolv_scope, hashss7pc_t)((hashss7pc_t*)wmem_alloc((addr_resolv_scope), sizeof(hashss7pc_t
)));
  tp->id = (ni<<24) + (pc&0xffffff);
  tp->pc_addr[0] = '\0';
  tp->name[0] = '\0';

  return tp;
3209}

3211static hashss7pc_t *
3212host_lookup_ss7pc(const uint8_t ni, const uint32_t pc)
3213{
  hashss7pc_t * volatile tp;
  uint32_t id;

  id = (ni<<24) + (pc&0xffffff);

  tp = (hashss7pc_t *)wmem_map_lookup(ss7pc_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)));
  if (tp == NULL((void*)0)) {
      tp = new_ss7pc(ni, pc);
      wmem_map_insert(ss7pc_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)), tp);
  }

  return tp;
3226}

3228void fill_unresolved_ss7pc(const char * pc_addr, const uint8_t ni, const uint32_t pc)
3229{
  hashss7pc_t *tp = host_lookup_ss7pc(ni, pc);

  (void) g_strlcpy(tp->pc_addr, pc_addr, MAXNAMELEN64);
3233}

3235const char *
3236get_hostname_ss7pc(const uint8_t ni, const uint32_t pc)
3237{
  hashss7pc_t *tp = host_lookup_ss7pc(ni, pc);

  /* never resolved yet*/
  if (tp->pc_addr[0] == '\0')
      return tp->pc_addr;

  /* Don't have name in file */
  if (tp->name[0] == '\0')
      return tp->pc_addr;

  if (!gbl_resolv_flags.ss7pc_name)
      return tp->pc_addr;

  return tp->name;
3252}

3254static void
3255add_ss7pc_name(const uint8_t ni, uint32_t pc, const char *name)
3256{
  hashss7pc_t *tp;
  uint32_t id;

  if (!name || name[0] == '\0')
      return;

  id = (ni<<24) + (pc&0xffffff);
  tp = (hashss7pc_t *)wmem_map_lookup(ss7pc_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)));
  if (!tp) {
      tp = new_ss7pc(ni, pc);
      wmem_map_insert(ss7pc_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)), tp);
  }

  if (g_ascii_strcasecmp(tp->name, name)) {
      (void) g_strlcpy(tp->name, name, MAXNAMELEN64);
  }
3273}

3275static bool_Bool
3276read_ss7pcs_file(const char *ss7pcspath)
3277{
  FILE *hf;
  char line[MAX_LINELEN1024];
  char *cp;
  uint8_t ni;
  uint32_t pc;
  bool_Bool entry_found = false0;

  /*
  *  File format is Network Indicator (decimal)<dash>Point Code (Decimal)<tab/space>Hostname
  */
  if ((hf = ws_fopenfopen(ss7pcspath, "r")) == NULL((void*)0))
34
←
Taking false branch→
      return false0;

  while (fgetline(line, sizeof(line), hf) >= 0) {
35
←
Loop condition is false. Execution continues on line 3316→
      if ((cp = strchr(line, '#')))
          *cp = '\0';

      if ((cp = strtok(line, "-")) == NULL((void*)0))
          continue; /*no ni-pc separator*/
      if (!ws_strtou8(cp, NULL((void*)0), &ni))
          continue;
      if (ni > 3)
           continue;

      if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0))
          continue; /* no tokens for pc and name */
      if (!ws_strtou32(cp, NULL((void*)0), &pc))
          continue;
      if (pc >> 24 > 0)
          continue;

      if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0))
          continue; /* no host name */

      entry_found = true1;
      add_ss7pc_name(ni, pc, cp);
  }

  fclose(hf);
36
←
Assuming that 'fclose' is successful; 'errno' becomes undefined after the call→
  return entry_found36.1
'entry_found' is false
 ? true1 : false0;
37
←
'?' condition is false→
3318}

3320static void
3321ss7pc_name_lookup_init(const char* app_env_var_prefix)
3322{
  char *ss7pcspath;

  ws_assert(ss7pc_hash_table == NULL)do { if ((1) && !(ss7pc_hash_table == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 3325, __func__, "assertion failed: %s"
, "ss7pc_hash_table == ((void*)0)"); } while (0);
30
←
Assuming 'ss7pc_hash_table' is equal to null→
31
←
Taking false branch→
32
←
Loop condition is false.  Exiting loop→

  ss7pc_hash_table = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal);

  /*
   * Load the user's ss7pcs file
   */
  ss7pcspath = get_persconffile_path(ENAME_SS7PCS"ss7pcs", true1, app_env_var_prefix);
  if (!read_ss7pcs_file(ss7pcspath) && errno(*__errno_location ()) != ENOENT2) {
33
←
Calling 'read_ss7pcs_file'→
38
←
Returning from 'read_ss7pcs_file'→
39
←
An undefined value may be read from 'errno'
      report_open_failure(ss7pcspath, errno(*__errno_location ()), false0);
  }
  g_free(ss7pcspath);
3337}

3339/* SS7PC Name Resolution End*/

3341/* TACS */
3342static bool_Bool
3343read_tacs_file(const char *tacspath)
3344{
  FILE *hf;
  char line[MAX_LINELEN1024];
  char *cp;
  uint16_t id;
  wmem_strbuf_t *tac_name = NULL((void*)0);

  /*
  *  File format is TAC(decimal)<tab/space>TACName (no spaces)
  */
  if ((hf = ws_fopenfopen(tacspath, "r")) == NULL((void*)0))
      return false0;

  while (fgetline(line, sizeof(line), hf) >= 0) {
      if ((cp = strchr(line, '#')))
          *cp = '\0';

      if ((cp = strtok(line, " \t")) == NULL((void*)0))
          continue;

      if (sscanf(cp, "%" SCNu16"hu", &id) != 1) {
          continue;
      }

      if ((cp = strtok(NULL((void*)0), " \t\n")) == NULL((void*)0))
          continue; /* no TAC name */

      if (!wmem_map_lookup(tac_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)))) {
          tac_name = wmem_strbuf_new(addr_resolv_scope, cp);
          wmem_map_insert(tac_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)), (void *)wmem_strbuf_get_str(tac_name));
      }
  }

  fclose(hf);
  return true1;
3379}

3381static void
3382initialize_tacs(const char* app_env_var_prefix)
3383{
  char *tacspath;
  ws_assert(tac_hash_table == NULL)do { if ((1) && !(tac_hash_table == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 3385, __func__, "assertion failed: %s"
, "tac_hash_table == ((void*)0)"); } while (0);
  tac_hash_table = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal);

  tacspath = get_persconffile_path(ENAME_TACS"tacs", true1, app_env_var_prefix);
  if (!read_tacs_file(tacspath) && errno(*__errno_location ()) != ENOENT2) {
      report_open_failure(tacspath, errno(*__errno_location ()), false0);
  }
  g_free(tacspath);
3393}

3395static void
3396tac_name_lookup_cleanup(void)
3397{
  tac_hash_table = NULL((void*)0);
3399}

3401const char *
3402tac_name_lookup(const unsigned id)
3403{
  return (const char *)wmem_map_lookup(tac_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)));
3405}
3406/* TAC END */

3408/*
*  External Functions
*/

3412void
3413addr_resolve_pref_init(module_t *nameres)
3414{
  prefs_register_bool_preference(nameres, "mac_name",
          "Resolve MAC addresses",
          "Resolve Ethernet MAC addresses to host names from the preferences"
          " or system's Ethers file, or to a manufacturer based name.",
          &gbl_resolv_flags.mac_name);

  prefs_register_bool_preference(nameres, "transport_name",
          "Resolve transport names",
          "Resolve TCP/UDP ports into service names",
          &gbl_resolv_flags.transport_name);

  prefs_register_bool_preference(nameres, "network_name",
          "Resolve network (IP) addresses",
          "Resolve IPv4, IPv6, and IPX addresses into host names."
          " The next set of check boxes determines how name resolution should be performed."
          " If no other options are checked name resolution is made from Wireshark's host file"
          " and capture file name resolution blocks.",
          &gbl_resolv_flags.network_name);

  prefs_register_bool_preference(nameres, "dns_pkt_addr_resolution",
          "Use captured DNS packet data for name resolution",
          "Use address/name pairs found in captured DNS packets for name resolution.",
          &gbl_resolv_flags.dns_pkt_addr_resolution);

  prefs_register_bool_preference(nameres, "handshake_sni_addr_resolution",
          "Use SNI information from captured handshake packets",
          "Use the Server Name Indication found in TLS handshakes for name resolution.",
          &gbl_resolv_flags.handshake_sni_addr_resolution);

  prefs_register_bool_preference(nameres, "use_external_name_resolver",
          "Use your system's DNS settings for name resolution",
          "Use your system's configured name resolver"
          " (usually DNS) to resolve network names."
          " Only applies when network name resolution"
          " is enabled.",
          &gbl_resolv_flags.use_external_net_name_resolver);

  prefs_register_bool_preference(nameres, "use_custom_dns_servers",
          "Use a custom list of DNS servers for name resolution",
          "Use a DNS Servers list to resolve network names if true.  If false, default information is used",
          &use_custom_dns_server_list);

  static uat_field_t dns_server_uats_flds[] = {
      UAT_FLD_CSTRING_OTHER(dnsserverlist_uats, ipaddr, "IP address", dnsserver_uat_fld_ip_chk_cb, "IPv4 or IPv6 address"){"ipaddr", "IP address", PT_TXTMOD_STRING,{ dnsserver_uat_fld_ip_chk_cb
 ,dnsserverlist_uats_ipaddr_set_cb,dnsserverlist_uats_ipaddr_tostr_cb
},{0,0,0},0,"IPv4 or IPv6 address",((void*)0)},
      UAT_FLD_CSTRING_OTHER(dnsserverlist_uats, tcp_port, "TCP Port", dnsserver_uat_fld_port_chk_cb, "Port Number (TCP)"){"tcp_port", "TCP Port", PT_TXTMOD_STRING,{ dnsserver_uat_fld_port_chk_cb
 ,dnsserverlist_uats_tcp_port_set_cb,dnsserverlist_uats_tcp_port_tostr_cb
},{0,0,0},0,"Port Number (TCP)",((void*)0)},
      UAT_FLD_CSTRING_OTHER(dnsserverlist_uats, udp_port, "UDP Port", dnsserver_uat_fld_port_chk_cb, "Port Number (UDP)"){"udp_port", "UDP Port", PT_TXTMOD_STRING,{ dnsserver_uat_fld_port_chk_cb
 ,dnsserverlist_uats_udp_port_set_cb,dnsserverlist_uats_udp_port_tostr_cb
},{0,0,0},0,"Port Number (UDP)",((void*)0)},
      UAT_END_FIELDS{((void*)0),((void*)0),PT_TXTMOD_NONE,{0,0,0},{0,0,0},0,0,((void
*)0)}
  };

  dnsserver_uat = uat_new("DNS Servers",
      sizeof(struct dns_server_data),
      "addr_resolve_dns_servers",        /* filename */
      true1,                       /* from_profile */
      &dnsserverlist_uats,        /* data_ptr */
      &ndnsservers,               /* numitems_ptr */
      UAT_AFFECTS_DISSECTION0x00000001,
      NULL((void*)0),
      dns_server_copy_cb,
      NULL((void*)0),
      dns_server_free_cb,
      c_ares_set_dns_servers,
      NULL((void*)0),
      dns_server_uats_flds);
  static const char *dnsserver_uat_defaults[] = { NULL((void*)0), "53", "53" };
  uat_set_default_values(dnsserver_uat, dnsserver_uat_defaults);
  prefs_register_uat_preference(nameres, "dns_servers",
      "DNS Servers",
      "A table of IPv4 and IPv6 addresses of DNS servers to be used to resolve IP names and addresses",
      dnsserver_uat);

  prefs_register_obsolete_preference(nameres, "concurrent_dns");

  prefs_register_uint_preference(nameres, "name_resolve_concurrency",
          "Maximum concurrent requests",
          "The maximum number of DNS requests that may"
          " be active at any time. A large value (many"
          " thousands) might overload the network or make"
          " your DNS server behave badly.",
          10,
          &name_resolve_concurrency);

  prefs_register_obsolete_preference(nameres, "hosts_file_handling");

  prefs_register_bool_preference(nameres, "vlan_name",
          "Resolve VLAN IDs",
          "Resolve VLAN IDs to network names from the preferences \"vlans\" file."
          " Format of the file is: \"ID<Tab>Name\"."
          " One line per VLAN, e.g.: 1 Management",
          &gbl_resolv_flags.vlan_name);

  prefs_register_bool_preference(nameres, "ss7_pc_name",
          "Resolve SS7 PCs",
          "Resolve SS7 Point Codes to node names from the profiles \"ss7pcs\" file."
          " Format of the file is: \"Network_Indicator<Dash>PC_Decimal<Tab>Name\"."
          " One line per Point Code, e.g.: 2-1234 MyPointCode1",
          &gbl_resolv_flags.ss7pc_name);

  prefs_register_bool_preference(nameres, "tac_name",
          "Resolve TAC",
          "Resolve TAC to area names from the preferences \"tac\" file."
          " Format of the file is: \"TAC(decimail)<Tab/space>Name\"."
          " One line per TAC, e.g.: 30123 City1",
          &gbl_resolv_flags.tac_name);

3519}

3521void addr_resolve_pref_apply(void)
3522{
  c_ares_set_dns_servers();
  maxmind_db_pref_apply();
3525}

3527void
3528disable_name_resolution(void) {
  gbl_resolv_flags.mac_name                           = false0;
  gbl_resolv_flags.network_name                       = false0;
  gbl_resolv_flags.transport_name                     = false0;
  gbl_resolv_flags.dns_pkt_addr_resolution            = false0;
  gbl_resolv_flags.handshake_sni_addr_resolution      = false0;
  gbl_resolv_flags.use_external_net_name_resolver     = false0;
  gbl_resolv_flags.vlan_name                          = false0;
  gbl_resolv_flags.ss7pc_name                         = false0;
  gbl_resolv_flags.maxmind_geoip                      = false0;
  gbl_resolv_flags.tac_name                           = false0;
3539}

3541bool_Bool
3542host_name_lookup_process(void) {
  struct timeval tv = { 0, 0 };
  int nfds;
  fd_set rfds, wfds;
  bool_Bool nro = new_resolved_objects;

  new_resolved_objects = false0;
  nro |= maxmind_db_lookup_process();

  if (!async_dns_initialized)
      /* c-ares not initialized. Bail out and cancel timers. */
      return nro;

  process_async_dns_queue();

  FD_ZERO(&rfds)do { unsigned int __i; fd_set *__arr = (&rfds); for (__i =
 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr
)->__fds_bits)[__i] = 0; } while (0);
  FD_ZERO(&wfds)do { unsigned int __i; fd_set *__arr = (&wfds); for (__i =
 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr
)->__fds_bits)[__i] = 0; } while (0);
  nfds = ares_fds(ghba_chan, &rfds, &wfds);
  if (nfds > 0) {
      if (select(nfds, &rfds, &wfds, NULL((void*)0), &tv) == -1) { /* call to select() failed */
          /* If it's interrupted by a signal, no need to put out a message */
          if (errno(*__errno_location ()) != EINTR4)
              fprintf(stderrstderr, "Warning: call to select() failed, error is %s\n", g_strerror(errno(*__errno_location ())));
          return nro;
      }
      ares_process(ghba_chan, &rfds, &wfds);
  }

  /* Any new entries? */
  return nro;
3572}

3574static void
3575_host_name_lookup_cleanup(void) {
  async_dns_queue_head = NULL((void*)0);

  if (async_dns_initialized) {
      ares_destroy(ghba_chan);
      ares_destroy(ghbn_chan);
  }
3582#ifdef CARES_HAVE_ARES_LIBRARY_INIT1
  ares_library_cleanup();
3584#endif
  async_dns_initialized = false0;
3586}

3588const char *
3589get_hostname(const unsigned addr)
3590{
  /* XXX why do we call this if we're not resolving? To create hash entries?
   * Why? So that we can return a const char*?
   *
   * Note the returned string is in addr_resolv_scope, which has a similar
   * life to the global file scope (slightly larger, in that the resolved
   * addresses need to be available during dissector registration, e.g.
   * for RADIUS and enterprises), so if not copied it is possible to use
   * it after freeing.
   *
   * Should this be deprecated in favor of get_hostname_wmem so that
   * host name lookups don't increase persistent memory usage even when
   * hostname lookups are disabled? (An alternative would be to return
   * NULL when lookups are disabled, but callers don't expect that.)
   */
  hashipv4_t *tp = host_lookup(addr);

  if (!gbl_resolv_flags.network_name)
      return tp->ip;

  tp->flags |= RESOLVED_ADDRESS_USED(1U<<2);

  return tp->name;
3613}

3615char *
3616get_hostname_wmem(wmem_allocator_t *allocator, const unsigned addr)
3617{
  if (!gbl_resolv_flags.network_name)
      return ip_addr_to_str(allocator, &addr);

  hashipv4_t *tp = host_lookup(addr);

  tp->flags |= RESOLVED_ADDRESS_USED(1U<<2);

  return wmem_strdup(allocator, tp->name);
3626}
3627/* -------------------------- */

3629const char *
3630get_hostname6(const ws_in6_addr *addr)
3631{
  /* XXX why do we call this if we're not resolving? To create hash entries?
   * Why? The same comments as get_hostname above apply.
   */
  hashipv6_t *tp = host_lookup6(addr);

  if (!gbl_resolv_flags.network_name)
      return tp->ip6;

  tp->flags |= RESOLVED_ADDRESS_USED(1U<<2);

  return tp->name;
3643}

3645char *
3646get_hostname6_wmem(wmem_allocator_t *allocator, const ws_in6_addr *addr)
3647{
  if (!gbl_resolv_flags.network_name)
      return ip6_to_str(allocator, addr);

  hashipv6_t *tp = host_lookup6(addr);

  tp->flags |= RESOLVED_ADDRESS_USED(1U<<2);

  return wmem_strdup(allocator, tp->name);
3656}
3657/* -------------------------- */
3658void
3659add_ipv4_name(const unsigned addr, const char *name, bool_Bool static_entry)
3660{
  hashipv4_t *tp;

  /*
   * Don't add zero-length names; apparently, some resolvers will return
   * them if they get them from DNS.
   */
  if (!name || name[0] == '\0')
      return;

  tp = (hashipv4_t *)wmem_map_lookup(ipv4_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr)));
  if (!tp) {
      tp = new_ipv4(addr);
      wmem_map_insert(ipv4_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr)), tp);
  }

  if (g_ascii_strcasecmp(tp->name, name) && (static_entry || !(tp->flags & STATIC_HOSTNAME(1U<<3)))) {
      (void) g_strlcpy(tp->name, name, MAXDNSNAMELEN256);
      new_resolved_objects = true1;
      if (static_entry)
          tp->flags |= STATIC_HOSTNAME(1U<<3);
  }
  tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0)|NAME_RESOLVED(1U<<1);
3683} /* add_ipv4_name */

3685/* -------------------------- */
3686void
3687add_ipv6_name(const ws_in6_addr *addrp, const char *name, const bool_Bool static_entry)
3688{
  hashipv6_t *tp;

  /*
   * Don't add zero-length names; apparently, some resolvers will return
   * them if they get them from DNS.
   */
  if (!name || name[0] == '\0')
      return;

  tp = (hashipv6_t *)wmem_map_lookup(ipv6_hash_table, addrp);
  if (!tp) {
      ws_in6_addr *addr_key;

      addr_key = wmem_new(addr_resolv_scope, ws_in6_addr)((ws_in6_addr*)wmem_alloc((addr_resolv_scope), sizeof(ws_in6_addr
)));
      tp = new_ipv6(addrp);
      memcpy(addr_key, addrp, 16);
      wmem_map_insert(ipv6_hash_table, addr_key, tp);
  }

  if (g_ascii_strcasecmp(tp->name, name) && (static_entry || !(tp->flags & STATIC_HOSTNAME(1U<<3)))) {
      (void) g_strlcpy(tp->name, name, MAXDNSNAMELEN256);
      new_resolved_objects = true1;
      if (static_entry)
          tp->flags |= STATIC_HOSTNAME(1U<<3);
  }
  tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0)|NAME_RESOLVED(1U<<1);
3715} /* add_ipv6_name */

3717static void
3718add_manually_resolved_ipv4(void *key, void *value, void *user_data _U___attribute__((unused)))
3719{
  resolved_name_t *resolved_ipv4_entry = (resolved_name_t*)value;
  add_ipv4_name(GPOINTER_TO_UINT(key)((guint) (gulong) (key)), resolved_ipv4_entry->name, true1);
3722}

3724static void
3725add_manually_resolved_ipv6(void *key, void *value, void *user_data _U___attribute__((unused)))
3726{
  resolved_name_t *resolved_ipv6_entry = (resolved_name_t*)value;
  add_ipv6_name((ws_in6_addr*)key, resolved_ipv6_entry->name, true1);
3729}

3731static void
3732add_manually_resolved(void)
3733{
  if (manually_resolved_ipv4_list) {
      wmem_map_foreach(manually_resolved_ipv4_list, add_manually_resolved_ipv4, NULL((void*)0));
  }

  if (manually_resolved_ipv6_list) {
      wmem_map_foreach(manually_resolved_ipv6_list, add_manually_resolved_ipv6, NULL((void*)0));
  }
3741}

3743static void
3744host_name_lookup_init(const char* app_env_var_prefix)
3745{
  char *hostspath;
  unsigned i;

  ws_assert(ipxnet_hash_table == NULL)do { if ((1) && !(ipxnet_hash_table == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 3749, __func__, "assertion failed: %s"
, "ipxnet_hash_table == ((void*)0)"); } while (0);
5
←
Assuming 'ipxnet_hash_table' is equal to null→
6
←
Taking false branch→
7
←
Loop condition is false.  Exiting loop→
  ipxnet_hash_table = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal);

  ws_assert(ipv4_hash_table == NULL)do { if ((1) && !(ipv4_hash_table == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 3752, __func__, "assertion failed: %s"
, "ipv4_hash_table == ((void*)0)"); } while (0);
8
←
Assuming 'ipv4_hash_table' is equal to null→
9
←
Taking false branch→
10
←
Loop condition is false.  Exiting loop→
  ipv4_hash_table = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal);

  ws_assert(ipv6_hash_table == NULL)do { if ((1) && !(ipv6_hash_table == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 3755, __func__, "assertion failed: %s"
, "ipv6_hash_table == ((void*)0)"); } while (0);
11
←
Assuming 'ipv6_hash_table' is equal to null→
12
←
Taking false branch→
13
←
Loop condition is false.  Exiting loop→
  ipv6_hash_table = wmem_map_new(addr_resolv_scope, ipv6_oat_hash, ipv6_equal);

  ws_assert(async_dns_queue_head == NULL)do { if ((1) && !(async_dns_queue_head == ((void*)0))
) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/addr_resolv.c"
, 3758, __func__, "assertion failed: %s", "async_dns_queue_head == ((void*)0)"
); } while (0);
14
←
Assuming 'async_dns_queue_head' is equal to null→
15
←
Taking false branch→
16
←
Loop condition is false.  Exiting loop→
  async_dns_queue_head = wmem_list_new(addr_resolv_scope);

  /*
   * The manually resolved lists are the only address resolution maps
   * that are not reset by addr_resolv_cleanup(), because they are
   * the only ones that do not have entries from personal configuration
   * files that can change when changing configurations. All their
   * entries must also be in epan scope.
   */
  if (manually_resolved_ipv4_list == NULL((void*)0))
17
←
Assuming 'manually_resolved_ipv4_list' is not equal to NULL→
18
←
Taking false branch→
      manually_resolved_ipv4_list = wmem_map_new(wmem_epan_scope(), g_direct_hash, g_direct_equal);

  if (manually_resolved_ipv6_list == NULL((void*)0))
19
←
Assuming 'manually_resolved_ipv6_list' is not equal to NULL→
20
←
Taking false branch→
      manually_resolved_ipv6_list = wmem_map_new(wmem_epan_scope(), ws_ipv6_hash, ipv6_equal);

  /*
   * Load the global hosts file, if we have one.
   */
  hostspath = get_datafile_path(ENAME_HOSTS"hosts", app_env_var_prefix);
  if (!read_hosts_file(hostspath, true1) && errno(*__errno_location ()) != ENOENT2) {
21
←
Assuming the condition is false→
22
←
Taking false branch→
      report_open_failure(hostspath, errno(*__errno_location ()), false0);
  }
  g_free(hostspath);
  /*
   * Load the user's hosts file no matter what, if they have one.
   */
  hostspath = get_persconffile_path(ENAME_HOSTS"hosts", true1, app_env_var_prefix);
  if (!read_hosts_file(hostspath, true1) && errno(*__errno_location ()) != ENOENT2) {
23
←
Assuming the condition is false→
24
←
Taking false branch→
      report_open_failure(hostspath, errno(*__errno_location ()), false0);
  }
  g_free(hostspath);
3790#ifdef CARES_HAVE_ARES_LIBRARY_INIT1
  if (ares_library_init(ARES_LIB_INIT_ALL((1 << 0))) == ARES_SUCCESS) {
25
←
Assuming the condition is false→
26
←
Taking false branch→
3792#endif
      /* XXX - Check which options we should set */
      if (ares_init_options(&ghba_chan, NULL((void*)0), 0) == ARES_SUCCESS && ares_init_options(&ghbn_chan, NULL((void*)0), 0) == ARES_SUCCESS) {
          async_dns_initialized = true1;
          c_ares_set_dns_servers();
      }
3798#ifdef CARES_HAVE_ARES_LIBRARY_INIT1
  }
3800#endif

  if (extra_hosts_files) {
27
←
Assuming 'extra_hosts_files' is null→
28
←
Taking false branch→
      for (i = 0; i < extra_hosts_files->len; i++) {
          read_hosts_file((const char *) g_ptr_array_index(extra_hosts_files, i)((extra_hosts_files)->pdata)[i], true1);
      }
  }

  subnet_name_lookup_init(app_env_var_prefix);

  add_manually_resolved();

  ss7pc_name_lookup_init(app_env_var_prefix);
29
←
Calling 'ss7pc_name_lookup_init'→
3813}

3815static void
3816host_name_lookup_cleanup(void)
3817{
  uint32_t i, j;
  sub_net_hashipv4_t *entry, *next_entry;

  _host_name_lookup_cleanup();

  ipxnet_hash_table = NULL((void*)0);
  ipv4_hash_table = NULL((void*)0);
  ipv6_hash_table = NULL((void*)0);
  ss7pc_hash_table = NULL((void*)0);

  for(i = 0; i < SUBNETLENGTHSIZE32; ++i) {
      if (subnet_length_entries[i].subnet_addresses != NULL((void*)0)) {
          for (j = 0; j < HASHHOSTSIZE2048; j++) {
              for (entry = subnet_length_entries[i].subnet_addresses[j];
                   entry != NULL((void*)0); entry = next_entry) {
                  next_entry = entry->next;
                  wmem_free(addr_resolv_scope, entry);
              }
          }
          wmem_free(addr_resolv_scope, subnet_length_entries[i].subnet_addresses);
          subnet_length_entries[i].subnet_addresses = NULL((void*)0);
      }
  }

  have_subnet_entry = false0;
  new_resolved_objects = false0;
3844}


3847void host_name_lookup_reset(const char* app_env_var_prefix)
3848{
  addr_resolv_cleanup();
  addr_resolv_init(app_env_var_prefix);
1
Calling 'addr_resolv_init'→
3851}

3853char *
3854udp_port_to_display(wmem_allocator_t *allocator, unsigned port)
3855{

  if (!gbl_resolv_flags.transport_name) {
      return wmem_utoa(allocator, port);
  }

  return wmem_strdup(allocator, serv_name_lookup(PT_UDP, port));

3863} /* udp_port_to_display */

3865char *
3866dccp_port_to_display(wmem_allocator_t *allocator, unsigned port)
3867{

  if (!gbl_resolv_flags.transport_name) {
      return wmem_utoa(allocator, port);
  }

  return wmem_strdup(allocator, serv_name_lookup(PT_DCCP, port));

3875} /* dccp_port_to_display */

3877char *
3878tcp_port_to_display(wmem_allocator_t *allocator, unsigned port)
3879{

  if (!gbl_resolv_flags.transport_name) {
      return wmem_utoa(allocator, port);
  }

  return wmem_strdup(allocator, serv_name_lookup(PT_TCP, port));

3887} /* tcp_port_to_display */

3889char *
3890sctp_port_to_display(wmem_allocator_t *allocator, unsigned port)
3891{

  if (!gbl_resolv_flags.transport_name) {
      return wmem_utoa(allocator, port);
  }

  return wmem_strdup(allocator, serv_name_lookup(PT_SCTP, port));

3899} /* sctp_port_to_display */

3901char *
3902port_with_resolution_to_str(wmem_allocator_t *scope, port_type proto, unsigned port)
3903{
  const char *port_str;

  if (!gbl_resolv_flags.transport_name || (proto == PT_NONE)) {
      /* No name resolution support, just return port string */
      return wmem_strdup_printf(scope, "%u", port);
  }
  port_str = serv_name_lookup(proto, port);
  ws_assert(port_str)do { if ((1) && !(port_str)) ws_log_fatal_full("", LOG_LEVEL_ERROR
, "epan/addr_resolv.c", 3911, __func__, "assertion failed: %s"
, "port_str"); } while (0);
  return wmem_strdup_printf(scope, "%s (%u)", port_str, port);
3913}

3915int
3916port_with_resolution_to_str_buf(char *buf, unsigned long buf_size, port_type proto, unsigned port)
3917{
  const char *port_str;

  if (!gbl_resolv_flags.transport_name || (proto == PT_NONE)) {
      /* No name resolution support, just return port string */
      return snprintf(buf, buf_size, "%u", port);
  }
  port_str = serv_name_lookup(proto, port);
  ws_assert(port_str)do { if ((1) && !(port_str)) ws_log_fatal_full("", LOG_LEVEL_ERROR
, "epan/addr_resolv.c", 3925, __func__, "assertion failed: %s"
, "port_str"); } while (0);
  return snprintf(buf, buf_size, "%s (%u)", port_str, port);
3927}

3929const char *
3930get_ether_name(const uint8_t *addr)
3931{
  hashether_t *tp;
  bool_Bool resolve = gbl_resolv_flags.mac_name;

  tp = eth_name_lookup(addr, resolve);

  return resolve ? tp->resolved_name : tp->hexaddr;

3939} /* get_ether_name */

3941const char *
3942tvb_get_ether_name(tvbuff_t *tvb, unsigned offset)
3943{
  return get_ether_name(tvb_get_ptr(tvb, offset, 6));
3945}

3947/* Look for a (non-dummy) ether name in the hash, and return it if found.
* If it's not found, simply return NULL.
*/
3950const char *
3951get_ether_name_if_known(const uint8_t *addr)
3952{
  hashether_t *tp;

  /* Initialize ether structs if we're the first
   * ether-related function called */
  if (!gbl_resolv_flags.mac_name)
      return NULL((void*)0);

  /* eth_name_lookup will create a (resolved) hash entry
   * if it doesn't exist, so it never returns NULL */
  tp = eth_name_lookup(addr, true1);

  if ((tp->flags & (NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4))) == NAME_RESOLVED(1U<<1)) {
      /* Name is from an exact match, not a prefix/OUI */
      return tp->resolved_name;
  }
  else {
      /* Name was created */
      return NULL((void*)0);
  }
3972}

3974void
3975add_ether_byip(const unsigned ip, const uint8_t *eth)
3976{
  hashipv4_t *tp;

  /* first check that IP address can be resolved */
  if (!gbl_resolv_flags.network_name)
      return;

  tp = host_lookup(ip);

  /*
   * Was this IP address resolved to a host name?
   */
  if (tp->flags & NAME_RESOLVED(1U<<1)) {
      /*
       * Yes, so add an entry in the ethers hashtable resolving
       * the MAC address to that name.
       */
      add_eth_name(eth, tp->name, false0);
  }

3996} /* add_ether_byip */

3998char *
3999get_ipxnet_name(wmem_allocator_t *allocator, const uint32_t addr)
4000{

  if (!gbl_resolv_flags.network_name) {
      return ipxnet_to_str_punct(allocator, addr, '\0');
  }

  return ipxnet_name_lookup(allocator, addr);

4008} /* get_ipxnet_name */

4010char *
4011get_vlan_name(wmem_allocator_t *allocator, const uint16_t id)
4012{

  if (!gbl_resolv_flags.vlan_name) {
      return NULL((void*)0);
  }

  return wmem_strdup(allocator, vlan_name_lookup(id));

4020} /* get_vlan_name */

4022const char *
4023get_manuf_name(const uint8_t *addr, size_t size)
4024{
  hashmanuf_t *manuf_value;

  ws_return_val_if(size < 3, NULL)do { if (1 && (size < 3)) { ws_log_full("InvalidArg"
, LOG_LEVEL_WARNING, "epan/addr_resolv.c", 4027, __func__, "invalid argument: %s"
, "size < 3"); return (((void*)0)); } } while (0);

  manuf_value = manuf_name_lookup(addr, size);
  if (gbl_resolv_flags.mac_name && ((manuf_value->flags & NAME_RESOLVED(1U<<1)) == NAME_RESOLVED(1U<<1)))
      return manuf_value->resolved_name;

  return manuf_value->hexaddr;

4035} /* get_manuf_name */

4037const char *
4038tvb_get_manuf_name(tvbuff_t *tvb, unsigned offset)
4039{
  uint8_t buf[3] = { 0 };
  tvb_memcpy(tvb, buf, offset, 3);
  return get_manuf_name(buf, sizeof(buf));
4043}

4045const char *
4046get_manuf_name_if_known(const uint8_t *addr, size_t size)
4047{
  hashmanuf_t *manuf_value;

  ws_return_val_if(size < 3, NULL)do { if (1 && (size < 3)) { ws_log_full("InvalidArg"
, LOG_LEVEL_WARNING, "epan/addr_resolv.c", 4050, __func__, "invalid argument: %s"
, "size < 3"); return (((void*)0)); } } while (0);

  manuf_value = manuf_name_lookup(addr, size);
  if (manuf_value != NULL((void*)0) && ((manuf_value->flags & NAME_RESOLVED(1U<<1)) == NAME_RESOLVED(1U<<1))) {
      return manuf_value->resolved_longname;
  }

  if (size >= 6) {
      /* Try the global manuf tables. */
      const char *short_name, *long_name;
      short_name = ws_manuf_lookup_str(addr, &long_name);
      if (short_name != NULL((void*)0)) {
          /* Found it */
          return long_name;
      }
  }

  return NULL((void*)0);

4069} /* get_manuf_name_if_known */

4071const char *
4072uint_get_manuf_name_if_known(const uint32_t manuf_key)
4073{
  uint8_t addr[6] = { 0 };
  addr[0] = (manuf_key >> 16) & 0xFF;
  addr[1] = (manuf_key >> 8) & 0xFF;
  addr[2] = manuf_key & 0xFF;

  return get_manuf_name_if_known(addr, sizeof(addr));
4080}

4082const char *
4083tvb_get_manuf_name_if_known(tvbuff_t *tvb, unsigned offset)
4084{
  uint8_t buf[3] = { 0 };
  tvb_memcpy(tvb, buf, offset, 3);
  return get_manuf_name_if_known(buf, sizeof(buf));
4088}

4090bool_Bool get_hash_manuf_used(hashmanuf_t* manuf)
4091{
  return ((manuf->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) == TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)));
4093}

4095char* get_hash_manuf_resolved_name(hashmanuf_t* manuf)
4096{
  return manuf->resolved_longname;
4098}

4100const char *
4101get_eui64_name(const uint8_t *addr)
4102{
  hasheui64_t *tp;
  bool_Bool resolve = gbl_resolv_flags.mac_name;

  tp = eui64_name_lookup(addr, resolve);

  return resolve ? tp->resolved_name : tp->hexaddr;

4110} /* get_eui64_name */

4112char *
4113eui64_to_display(wmem_allocator_t *allocator, const uint64_t addr_eui64)
4114{
  uint8_t addr[EUI64_ADDR_LEN8];

  phtonu64(addr, addr_eui64);

  const char *result = get_eui64_name(addr);

  return wmem_strdup(allocator, result);
4122} /* eui64_to_display */

4124#define GHI_TIMEOUT(250 * 1000) (250 * 1000)
4125static void
4126c_ares_ghi_cb(void *arg, int status, int timeouts _U___attribute__((unused)), struct hostent *hp) {
  /*
   * XXX - If we wanted to be really fancy we could cache results here and
   * look them up in get_host_ipaddr* below.
   *
   * XXX - This only gets the first host address if there's more than one.
   */
  async_hostent_t *ahp = (async_hostent_t *)arg;
  if (status == ARES_SUCCESS && hp && ahp && hp->h_length == ahp->addr_size) {
      memcpy(ahp->addrp, hp->h_addrh_addr_list[0], hp->h_length);
      ahp->copied = hp->h_length;
  }
4138}

4140/* Translate a string, assumed either to be a dotted-quad IPv4 address or
* a host name, to a numeric IPv4 address.  Return true if we succeed and
* set "*addrp" to that numeric IPv4 address; return false if we fail. */
4143bool_Bool
4144get_host_ipaddr(const char *host, uint32_t *addrp)
4145{
  struct timeval tv = { 0, GHI_TIMEOUT(250 * 1000) }, *tvp;
  int nfds;
  fd_set rfds, wfds;
  async_hostent_t ahe;

  /*
   * XXX - are there places where this is used to translate something
   * that's *only* supposed to be an IPv4 address, and where it
   * *shouldn't* translate host names?
   */
  if (!ws_inet_pton4(host, addrp)) {

      /* It's not a valid dotted-quad IP address; is it a valid
       * host name?
       */

      /* If we're not allowed to do name resolution, don't do name
       * resolution...
       * XXX - What if we're allowed to do name resolution, and the name
       * is in a DNS packet we've dissected or in a Name Resolution Block,
       * or a user-entered manual name resolution?
       */
      if (!gbl_resolv_flags.network_name ||
              !gbl_resolv_flags.use_external_net_name_resolver) {
          return false0;
      }

      if (!async_dns_initialized || name_resolve_concurrency < 1) {
          return false0;
      }
      ahe.addr_size = (int) sizeof (struct in_addr);
      ahe.copied = 0;
      ahe.addrp = addrp;
      ares_gethostbyname(ghbn_chan, host, AF_INET2, c_ares_ghi_cb, &ahe);
      FD_ZERO(&rfds)do { unsigned int __i; fd_set *__arr = (&rfds); for (__i =
 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr
)->__fds_bits)[__i] = 0; } while (0);
      FD_ZERO(&wfds)do { unsigned int __i; fd_set *__arr = (&wfds); for (__i =
 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr
)->__fds_bits)[__i] = 0; } while (0);
      nfds = ares_fds(ghbn_chan, &rfds, &wfds);
      if (nfds > 0) {
          tvp = ares_timeout(ghbn_chan, &tv, &tv);
          if (select(nfds, &rfds, &wfds, NULL((void*)0), tvp) == -1) { /* call to select() failed */
              /* If it's interrupted by a signal, no need to put out a message */
              if (errno(*__errno_location ()) != EINTR4)
                  fprintf(stderrstderr, "Warning: call to select() failed, error is %s\n", g_strerror(errno(*__errno_location ())));
              return false0;
          }
          ares_process(ghbn_chan, &rfds, &wfds);
      }
      ares_cancel(ghbn_chan);
      if (ahe.addr_size == ahe.copied) {
          return true1;
      }
      return false0;
  }

  return true1;
4201}

4203/*
* Translate IPv6 numeric address or FQDN hostname into binary IPv6 address.
* Return true if we succeed and set "*addrp" to that numeric IPv6 address;
* return false if we fail.
*/
4208bool_Bool
4209get_host_ipaddr6(const char *host, ws_in6_addr *addrp)
4210{
  struct timeval tv = { 0, GHI_TIMEOUT(250 * 1000) }, *tvp;
  int nfds;
  fd_set rfds, wfds;
  async_hostent_t ahe;

  if (str_to_ip6(host, addrp))
      return true1;

  /* It's not a valid dotted-quad IP address; is it a valid
   * host name?
   *
   * XXX - are there places where this is used to translate something
   * that's *only* supposed to be an IPv6 address, and where it
   * *shouldn't* translate host names?
   */

  /* If we're not allowed to do name resolution, don't do name
   * resolution...
   * XXX - What if we're allowed to do name resolution, and the name
   * is in a DNS packet we've dissected or in a Name Resolution Block,
   * or a user-entered manual name resolution?
   */
  if (!gbl_resolv_flags.network_name ||
          !gbl_resolv_flags.use_external_net_name_resolver) {
      return false0;
  }

  /* try FQDN */
  if (!async_dns_initialized || name_resolve_concurrency < 1) {
      return false0;
  }
  ahe.addr_size = (int) sizeof (ws_in6_addr);
  ahe.copied = 0;
  ahe.addrp = addrp;
  ares_gethostbyname(ghbn_chan, host, AF_INET610, c_ares_ghi_cb, &ahe);
  FD_ZERO(&rfds)do { unsigned int __i; fd_set *__arr = (&rfds); for (__i =
 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr
)->__fds_bits)[__i] = 0; } while (0);
  FD_ZERO(&wfds)do { unsigned int __i; fd_set *__arr = (&wfds); for (__i =
 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) ((__arr
)->__fds_bits)[__i] = 0; } while (0);
  nfds = ares_fds(ghbn_chan, &rfds, &wfds);
  if (nfds > 0) {
      tvp = ares_timeout(ghbn_chan, &tv, &tv);
      if (select(nfds, &rfds, &wfds, NULL((void*)0), tvp) == -1) { /* call to select() failed */
          /* If it's interrupted by a signal, no need to put out a message */
          if (errno(*__errno_location ()) != EINTR4)
              fprintf(stderrstderr, "Warning: call to select() failed, error is %s\n", g_strerror(errno(*__errno_location ())));
          return false0;
      }
      ares_process(ghbn_chan, &rfds, &wfds);
  }
  ares_cancel(ghbn_chan);
  if (ahe.addr_size == ahe.copied) {
      return true1;
  }

  return false0;
4265}

4267wmem_map_t *
4268get_manuf_hashtable(void)
4269{
  return manuf_hashtable;
4271}

4273wmem_map_t *
4274get_wka_hashtable(void)
4275{
  return wka_hashtable;
4277}

4279wmem_map_t *
4280get_eth_hashtable(void)
4281{
  return eth_hashtable;
4283}

4285wmem_map_t *
4286get_serv_port_hashtable(void)
4287{
  return serv_port_hashtable;
4289}

4291wmem_map_t *
4292get_ipxnet_hash_table(void)
4293{
      return ipxnet_hash_table;
4295}

4297wmem_map_t *
4298get_vlan_hash_table(void)
4299{
      return vlan_hash_table;
4301}

4303wmem_map_t *
4304get_ipv4_hash_table(void)
4305{
      return ipv4_hash_table;
4307}

4309wmem_map_t *
4310get_ipv6_hash_table(void)
4311{
      return ipv6_hash_table;
4313}
4314/* Initialize all the address resolution subsystems in this file */
4315void
4316addr_resolv_init(const char* app_env_var_prefix)
4317{
  ws_assert(addr_resolv_scope == NULL)do { if ((1) && !(addr_resolv_scope == ((void*)0))) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 4318, __func__, "assertion failed: %s"
, "addr_resolv_scope == ((void*)0)"); } while (0);
2
←
Taking false branch→
3
←
Loop condition is false.  Exiting loop→
  addr_resolv_scope = wmem_allocator_new(WMEM_ALLOCATOR_BLOCK);
  initialize_services(app_env_var_prefix);
  initialize_ethers(app_env_var_prefix);
  initialize_ipxnets(app_env_var_prefix);
  initialize_vlans(app_env_var_prefix);
  initialize_enterprises(app_env_var_prefix);
  host_name_lookup_init(app_env_var_prefix);
4
←
Calling 'host_name_lookup_init'→
  initialize_tacs(app_env_var_prefix);
4327}

4329/* Clean up all the address resolution subsystems in this file */
4330void
4331addr_resolv_cleanup(void)
4332{
  vlan_name_lookup_cleanup();
  service_name_lookup_cleanup();
  ethers_cleanup();
  ipx_name_lookup_cleanup();
  enterprises_cleanup();
  host_name_lookup_cleanup();
  tac_name_lookup_cleanup();

  wmem_destroy_allocator(addr_resolv_scope);
  addr_resolv_scope = NULL((void*)0);
4343}

4345bool_Bool
4346str_to_ip(const char *str, void *dst)
4347{
  return ws_inet_pton4(str, (uint32_t *)dst);
4349}

4351bool_Bool
4352str_to_ip6(const char *str, void *dst)
4353{
  return ws_inet_pton6(str, (ws_in6_addr *)dst);
4355}

4357/*
* convert a 0-terminated string that contains an ethernet address into
* the corresponding sequence of 6 bytes
* eth_bytes is a buffer >= 6 bytes that was allocated by the caller
*/
4362bool_Bool
4363str_to_eth(const char *str, uint8_t (*eth_bytes)[6])
4364{
  ether_t eth;
  unsigned mask;

  if (!parse_ether_address(str, &eth, &mask, false0))
      return false0;

  if (mask == 48) {
      memcpy(eth_bytes, eth.addr, 6);
  }
  return true1;
4375}

4377/*
* Editor modelines  -  https://www.wireshark.org/tools/modelines.html
*
* Local variables:
* c-basic-offset: 4
* tab-width: 8
* indent-tabs-mode: nil
* End:
*
* vi: set shiftwidth=4 tabstop=8 expandtab:
* :indentSize=4:tabSize=8:noTabs=true:
*/