/builds/wireshark/wireshark/epan/addr

Bug Summary

File:	builds/wireshark/wireshark/epan/addr_resolv.c
Warning:	line 3593, 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-22/lib/clang/22 -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/lua5.5 -isystem /usr/include/libxml2 -D CARES_NO_DEPRECATED -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-22/lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../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=gnu17 -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 -fdwarf2-cfi-asm -o /builds/wireshark/wireshark/sbout/2026-06-06-100355-3529-1 -x c /builds/wireshark/wireshark/epan/addr_resolv.c
1/* addr_resolv.c
* Routines for network object lookup
*
* Laurent Deniel <laurent.deniel@free.fr>
*
* Add option to resolv VLAN ID to describing name
* Uli Heilmeier, March 2016
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* 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 "iana-info.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>

99#define ENAME_HOSTS"hosts"     "hosts"
100#define ENAME_SUBNETS"subnets"   "subnets"
101#define ENAME_SUBNETS_V6"subnetsipv6" "subnetsipv6"
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.*/
116#define SUBNETLENGTHSIZE_V6128 128 /*1-128 inc.*/

118/* hash table used for IPv4 lookup */

120#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))


123typedef 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];
129} sub_net_hashipv4_t;

131/* Array of entries of subnets of different lengths */
132typedef 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 */
136} subnet_length_entry_t;


139/* IPv6 subnet lookup structures */
140typedef struct sub_net_hashipv6 {
  uint8_t                   addr[16];   /* masked network address */
  uint8_t                   flags;
  struct sub_net_hashipv6  *next;
  char                      name[MAXNAMELEN64];
145} sub_net_hashipv6_t;

147typedef struct {
  size_t               mask_length;       /* 1-128 */
  uint8_t              mask[16];          /* byte mask */
  sub_net_hashipv6_t **subnet_addresses;  /* hash table */
151} subnet_length_entry_v6_t;

153typedef struct {
  uint8_t     mask[16];
  size_t      mask_length;
  const char *name;
157} subnet_entry_v6_t;

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

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

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

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

171typedef struct hashvlan {
  unsigned            id;
173/*    struct hashvlan     *next; */
  char                name[MAXVLANNAMELEN128];
175} hashvlan_t;

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

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

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

198struct hashwka {
  uint8_t           flags;  /* (See above) */
  char*             name;
201};

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

211/* internal type used when reading ethers file (or wka, manuf) */
212typedef struct _ether
213{
  uint8_t           addr[8];
  char              name[MAXNAMELEN64];
  char              longname[MAXNAMELEN64];
217} ether_t;

219/* internal ipxnet type */
220typedef struct _ipxnet
221{
  unsigned          addr;
  char              name[MAXNAMELEN64];
224} ipxnet_t;

226/* internal vlan type */
227typedef struct _vlan
228{
  unsigned          id;
  char              name[MAXVLANNAMELEN128];
231} vlan_t;

233static wmem_allocator_t *addr_resolv_scope;

235// Maps unsigned -> hashipxnet_t*
236static wmem_map_t *ipxnet_hash_table;
237static wmem_map_t *ipv4_hash_table;
238static wmem_map_t *ipv6_hash_table;
239// Maps unsigned -> hashvlan_t*
240static wmem_map_t *vlan_hash_table;
241static wmem_map_t *ss7pc_hash_table;
242static wmem_map_t *tac_hash_table;

244// Maps IP address -> manually set hostname.
245static wmem_map_t *manually_resolved_ipv4_list;
246static wmem_map_t *manually_resolved_ipv6_list;

248static addrinfo_lists_t addrinfo_lists;

250struct cb_serv_data {
  char        *service;
  port_type    proto;
253};

255// Maps unsigned -> hashmanuf_t*
256// XXX: Note that hashmanuf_t* only accommodates 24-bit OUIs.
257// We might want to store vendor names from MA-M and MA-S to
258// present in the Resolved Addresses dialog.
259static wmem_map_t *manuf_hashtable;
260// Maps address -> hashwka_t*
261static wmem_map_t *wka_hashtable;
262// Maps address -> hashether_t*
263static wmem_map_t *eth_hashtable;
264// Maps address -> hasheui64_t*
265static wmem_map_t *eui64_hashtable;
266// Maps unsigned -> serv_port_t*
267static wmem_map_t *serv_port_hashtable;
268static wmem_map_t *serv_port_custom_hashtable;

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

273static subnet_length_entry_t subnet_length_entries[SUBNETLENGTHSIZE32]; /* Ordered array of entries */
274static bool_Bool have_subnet_entry;

276static subnet_length_entry_v6_t subnet_length_entries_v6[SUBNETLENGTHSIZE_V6128]; /* IPv6 subnet entries */
277static bool_Bool have_subnet_entry_v6;

279static bool_Bool new_resolved_objects;

281static GPtrArray* extra_hosts_files;

283static hashether_t *add_eth_name(const uint8_t *addr, const char *name, bool_Bool static_entry);
284static hasheui64_t *add_eui64_name(const uint8_t *addr, const char *name, bool_Bool static_entry);
285static void add_serv_port_cb(const uint32_t port, void *ptr);

287/* http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx#existing
* One-at-a-Time hash
*/
290unsigned
291ipv6_oat_hash(const void *key)
292{
  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;
309}

311unsigned
312ws_ipv6_hash(const void* key)
313{
314#ifdef HAVE_XXHASH1
  return wmem_strong_hash(key, 16);
316#else
  return ipv6_oat_hash(key);
318#endif
319}

321gboolean
322ipv6_equal(const void *v1, const void *v2)
323{

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

  return false0;
330}

332/*
* Flag controlling what names to resolve.
*/
335e_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 */
346};

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

354/*
*  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.
*/

360static char *g_ethers_path;     /* global ethers file     */
361static char *g_pethers_path;     /* personal ethers file   */
362static char *g_wka_path;     /* global well-known-addresses file */
363static char *g_manuf_path;     /* global manuf file      */
364static char *g_pmanuf_path;     /* personal manuf file      */
365static char *g_ipxnets_path;     /* global ipxnets file    */
366static char *g_pipxnets_path;     /* personal ipxnets file  */
367static char *g_services_path;     /* global services file   */
368static char *g_pservices_path;     /* personal services file */
369static char *g_pvlan_path;     /* personal vlans file    */
370static char *g_enterprises_path;   /* global enterprises file   */
371static char *g_penterprises_path;  /* personal enterprises file */
                                  /* first resolving call   */

374/*
* 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.
*/
381typedef struct _async_dns_queue_msg
382{
  union {
      uint32_t          ip4;
      ws_in6_addr ip6;
  } addr;
  int                 family;
388} async_dns_queue_msg_t;

390typedef struct _async_hostent {
  int addr_size;
  int   copied;
  void *addrp;
394} async_hostent_t;

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

399/*
* 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.
*/
404typedef struct _sync_dns_data
405{
  union {
      uint32_t     ip4;
      ws_in6_addr  ip6;
  } addr;
  int              family;
  bool_Bool            *completed;
412} sync_dns_data_t;

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

417static  bool_Bool        async_dns_initialized;
418static  unsigned    async_dns_in_flight;
419static  wmem_list_t *async_dns_queue_head;
420static  GMutex      async_dns_queue_mtx;

422//UAT for providing a list of DNS servers to C-ARES for name resolution
423static bool_Bool use_custom_dns_server_list;
424struct dns_server_data {
  char *ipaddr;
  uint32_t udp_port;
  uint32_t tcp_port;
428};

430UAT_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); (__builtin_object_size (((((struct dns_server_data
*)rec)->ipaddr)), 0) != ((size_t) - 1)) ? g_free_sized (((
(struct dns_server_data*)rec)->ipaddr), __builtin_object_size
 (((((struct dns_server_data*)rec)->ipaddr)), 0)) : (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; } }
431UAT_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); (__builtin_object_size
 ((tmp_str), 0) != ((size_t) - 1)) ? g_free_sized (tmp_str, __builtin_object_size
 ((tmp_str), 0)) : (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); }
432UAT_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); (__builtin_object_size
 ((tmp_str), 0) != ((size_t) - 1)) ? g_free_sized (tmp_str, __builtin_object_size
 ((tmp_str), 0)) : (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); }

434static uat_t *dnsserver_uat;
435static struct dns_server_data  *dnsserverlist_uats;
436static unsigned ndnsservers;

438static void
439dns_server_free_cb(void *data)
440{
  struct dns_server_data *h = (struct dns_server_data*)data;

  g_free(h->ipaddr)(__builtin_object_size ((h->ipaddr), 0) != ((size_t) - 1))
 ? g_free_sized (h->ipaddr, __builtin_object_size ((h->
ipaddr), 0)) : (g_free) (h->ipaddr);
444}

446static void*
447dns_server_copy_cb(void *dst_, const void *src_, size_t len _U___attribute__((unused)))
448{
  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;
457}

459static bool_Bool
460dnsserver_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)
461{
  //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;
470}

472static bool_Bool
473dnsserver_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)
474{
  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;
491}

493static void
494c_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)(__builtin_object_size ((sdd), 0) != ((size_t) - 1)) ? g_free_sized
 (sdd, __builtin_object_size ((sdd), 0)) : (g_free) (sdd);
524}

526static void
527wait_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);
      }
  }
570}

572static void
573process_async_dns_queue(void)
574{
  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);
603}

605static void
606wait_for_async_queue(void)
607{
  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;
652}

654static void
655sync_lookup_ip4(const uint32_t addr)
656{
  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);
681}

683static void
684sync_lookup_ip6(const ws_in6_addr *addrp)
685{
  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);
710}

712void
713set_resolution_synchrony(bool_Bool synchronous)
714{
  resolve_synchronously = synchronous;
  maxmind_db_set_synchrony(synchronous);

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

723static void
724c_ares_set_dns_servers(void)
725{
  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);
  }
783}

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

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

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

805} /* fgetline */


808/*
*  Local function definitions
*/
811static subnet_entry_t subnet_lookup(const uint32_t addr);
812static void subnet_entry_set(uint32_t subnet_addr, const uint8_t mask_length, const char* name);

814static unsigned serv_port_custom_hash(const void *k)
815{
  const serv_port_key_t *key = (const serv_port_key_t*)k;
  return key->port + (key->type << 16);
818}

820static gboolean serv_port_custom_equal(const void *k1, const void *k2)
821{
  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);
826}

828static void
829add_custom_service_name(port_type proto, const unsigned port, const char *service_name)
830{
  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;
848}

850static void
851add_service_name(port_type proto, const unsigned port, const char *service_name)
852{
  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;
860}

862static void
863parse_service_line (char *line)
864{
  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);
915} /* parse_service_line */


918static void
919add_serv_port_cb(const uint32_t port, void *ptr)
920{
  struct cb_serv_data *cb_data = (struct cb_serv_data *)ptr;

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


929static bool_Bool
930parse_services_file(const char * path)
931{
  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;
947}

949/* -----------------
* unsigned integer to ascii
*/
952static char *
953wmem_utoa(wmem_allocator_t *allocator, unsigned port)
954{
  char *bp = (char *)wmem_alloc(allocator, MAXNAMELEN64);

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

962static const char *
963_serv_name_lookup(port_type proto, unsigned port)
964{
  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;
999}

1001const char *
1002try_serv_name_lookup(port_type proto, unsigned port)
1003{
  return (proto == PT_NONE) ? NULL((void*)0) : _serv_name_lookup(proto, port);
1005}

1007const char *
1008serv_name_lookup(port_type proto, unsigned port)
1009{
  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;
1027}

1029static void
1030initialize_services(const char* app_env_var_prefix)
1031{
  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",
 1032, __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"
, 1034, __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)(__builtin_object_size ((g_pservices_path), 0) != ((size_t) -
 1)) ? g_free_sized (g_pservices_path, __builtin_object_size (
(g_pservices_path), 0)) : (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);
      }
  }
1053}

1055static void
1056service_name_lookup_cleanup(void)
1057{
  serv_port_hashtable = NULL((void*)0);
  serv_port_custom_hashtable = NULL((void*)0);
  g_free(g_services_path)(__builtin_object_size ((g_services_path), 0) != ((size_t) - 1
)) ? g_free_sized (g_services_path, __builtin_object_size ((g_services_path
), 0)) : (g_free) (g_services_path);
  g_services_path = NULL((void*)0);
  g_free(g_pservices_path)(__builtin_object_size ((g_pservices_path), 0) != ((size_t) -
 1)) ? g_free_sized (g_pservices_path, __builtin_object_size (
(g_pservices_path), 0)) : (g_free) (g_pservices_path);
  g_pservices_path = NULL((void*)0);
1064}

1066static void
1067parse_enterprises_line (char *line)
1068{
  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));
1095}


1098static bool_Bool
1099parse_enterprises_file(const char * path)
1100{
  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;
1114}

1116static void
1117initialize_enterprises(const char* app_env_var_prefix)
1118{
  ws_assert(enterprises_hashtable == NULL)do { if ((1) && !(enterprises_hashtable == ((void*)0)
)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/addr_resolv.c"
, 1119, __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)(__builtin_object_size ((g_penterprises_path), 0) != ((size_t
) - 1)) ? g_free_sized (g_penterprises_path, __builtin_object_size
 ((g_penterprises_path), 0)) : (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);
1138}

1140const char *
1141try_enterprises_lookup(uint32_t value)
1142{
  /* 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;

  return val_to_str_ext_const(value, &enterprise_val_ext, "Unknown");
1149}

1151const char *
1152enterprises_lookup(uint32_t value, const char *unknown_str)
1153{
  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>";
1162}

1164void
1165enterprises_base_custom(char *buf, uint32_t value)
1166{
  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);
1172}

1174static void
1175enterprises_cleanup(void)
1176{
  ws_assert(enterprises_hashtable)do { if ((1) && !(enterprises_hashtable)) ws_log_fatal_full
("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 1177, __func__, "assertion failed: %s"
, "enterprises_hashtable"); } while (0);
  g_hash_table_destroy(enterprises_hashtable);
  enterprises_hashtable = NULL((void*)0);
  g_free(g_enterprises_path)(__builtin_object_size ((g_enterprises_path), 0) != ((size_t)
 - 1)) ? g_free_sized (g_enterprises_path, __builtin_object_size
 ((g_enterprises_path), 0)) : (g_free) (g_enterprises_path);
  g_enterprises_path = NULL((void*)0);
  g_free(g_penterprises_path)(__builtin_object_size ((g_penterprises_path), 0) != ((size_t
) - 1)) ? g_free_sized (g_penterprises_path, __builtin_object_size
 ((g_penterprises_path), 0)) : (g_free) (g_penterprises_path);
  g_penterprises_path = NULL((void*)0);
1184}

1186/* Fill in an IP4 structure with info from subnets file or just with the
* string form of the address.
*/
1189bool_Bool
1190fill_dummy_ip4(const unsigned addr, hashipv4_t* volatile tp)
1191{
  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;
          }
      }

      /* XXX - the subnet entry name could be up to MAXDNSNAMELEN, and
       * buffer is WS_INET_ADDRSTRLEN chars, so the total length of
       * this string could be up to MAXDNSNAMELEN+WS_INET_ADDRSTRLEN,
       * which won't fit in the name field of a hashipv4_t, which is only
       * MAXDNSNAMELEN chars.
       *
       * For now, we do it this way, to suppress compiler warnings.
       * g_strlcpy() returns the length of the string being copied, which
       * should be < MAXDNSNAMELEN as it does not include the trailing NUL,
       * but let's be cautious.
       */
      size_t subnet_entry_name_len;
      subnet_entry_name_len = g_strlcpy(tp->name, subnet_entry.name, MAXDNSNAMELEN256);
      if (subnet_entry_name_len < MAXDNSNAMELEN256)
              g_strlcpy(tp->name + subnet_entry_name_len, paddr, MAXDNSNAMELEN256 - subnet_entry_name_len);

      /* 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;
1262}


1265/* Forward declaration — defined later with the IPv6 subnet functions. */
1266static subnet_entry_v6_t subnet6_lookup(const ws_in6_addr *addr);

1268/* Fill in an IP6 structure with info from subnetIpv6 file or the string form
* of the address.
*/
1271static void
1272fill_dummy_ip6(hashipv6_t* volatile tp)
1273{
  ws_in6_addr addr;
  memcpy(addr.bytes, tp->addr, 16);

  /* Overwrite if we get async DNS reply */
  subnet_entry_v6_t subnet_entry = subnet6_lookup(&addr);
  if (subnet_entry.mask_length != 0) {
      ws_in6_addr host_addr;
      for (int i = 0; i < 16; i++)
          host_addr.bytes[i] = addr.bytes[i] & ~subnet_entry.mask[i];

      /* Build host-portion 16-bit groups directly from bytes — avoids
       * ambiguity from IPv6 '::' zero-compression in string scanning. */
      size_t first_host_group = subnet_entry.mask_length / 16;
      wmem_strbuf_t *host_strbuf = wmem_strbuf_new_sized(addr_resolv_scope,
                                                          WS_INET6_ADDRSTRLEN46);
      for (size_t g = first_host_group; g < 8; g++) {
          if (g > first_host_group)
              wmem_strbuf_append_c(host_strbuf, ':');
          uint16_t grp = ((uint16_t)host_addr.bytes[g * 2] << 8)
                         | host_addr.bytes[g * 2 + 1];
          wmem_strbuf_append_printf(host_strbuf, "%x", (unsigned)grp);
      }

      /* Assemble name: "subnetName:host_portion" */
      wmem_strbuf_t *name_strbuf = wmem_strbuf_new_sized(addr_resolv_scope,
                                                          MAXDNSNAMELEN256);
      wmem_strbuf_append(name_strbuf, subnet_entry.name);
      if (wmem_strbuf_get_len(host_strbuf) > 0) {
          wmem_strbuf_append_c(name_strbuf, ':');
          wmem_strbuf_append(name_strbuf, wmem_strbuf_get_str(host_strbuf));
      }
      g_strlcpy(tp->name, wmem_strbuf_get_str(name_strbuf), MAXDNSNAMELEN256);
      wmem_strbuf_destroy(name_strbuf);
      wmem_strbuf_destroy(host_strbuf);

      /* Build CIDR notation for cidr_addr */
      ws_in6_addr net_addr;
      for (int i = 0; i < 16; i++)
          net_addr.bytes[i] = addr.bytes[i] & subnet_entry.mask[i];
      char net_buf[WS_INET6_ADDRSTRLEN46];
      ip6_to_str_buf(&net_addr, net_buf, sizeof(net_buf));
      wmem_strbuf_t *cidr_strbuf = wmem_strbuf_new_sized(addr_resolv_scope,
                                                          WS_INET6_CIDRADDRSTRLEN50);
      wmem_strbuf_append_printf(cidr_strbuf, "%s/%zu", net_buf,
                                subnet_entry.mask_length);
      g_strlcpy(tp->cidr_addr, wmem_strbuf_get_str(cidr_strbuf),
                WS_INET6_CIDRADDRSTRLEN50);
      wmem_strbuf_destroy(cidr_strbuf);
  } else {
      (void)g_strlcpy(tp->name, tp->ip6, MAXDNSNAMELEN256);
      (void)g_strlcpy(tp->cidr_addr, tp->ip6, WS_INET6_CIDRADDRSTRLEN50);
  }
1326}

1328static void
1329c_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);
1353}

1355/* --------------- */
1356hashipv4_t *
1357new_ipv4(const unsigned addr)
1358{
  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;
1365}

1367static hashipv4_t *
1368host_lookup(const unsigned addr)
1369{
  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;

1423} /* host_lookup */

1425/* --------------- */
1426static hashipv6_t *
1427new_ipv6(const ws_in6_addr *addr)
1428{
  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;
1435}

1437/* ------------------------------------ */
1438static hashipv6_t *
1439host_lookup6(const ws_in6_addr *addr)
1440{
  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;

1498} /* host_lookup6 */

1500/*
* 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.
*/

1524/*
* 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.
*/
1530static bool_Bool
1531parse_ether_address_fast(const unsigned char *cp, ether_t *eth, unsigned int *mask,
      const bool_Bool accept_mask)
1533{
  /* 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;
1624}

1626/*
* 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.
*/
1632static bool_Bool
1633parse_ether_address(const char *cp, ether_t *eth, unsigned int *mask,
      const bool_Bool accept_mask)
1635{
  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;
1733}

1735static int
1736parse_ether_line(char *line, ether_t *eth, unsigned int *mask,
      const bool_Bool accept_mask)
1738{
  /*
   *  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;

1782} /* parse_ether_line */

1784static FILE *eth_p;

1786static void
1787set_ethent(char *path)
1788{
  if (eth_p)
      rewind(eth_p);
  else
      eth_p = ws_fopenfopen(path, "r");
1793}

1795static void
1796end_ethent(void)
1797{
  if (eth_p) {
      fclose(eth_p);
      eth_p = NULL((void*)0);
  }
1802}

1804static ether_t *
1805get_ethent(unsigned int *mask, const bool_Bool accept_mask)
1806{

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

1822} /* get_ethent */

1824static hashmanuf_t *
1825manuf_hash_new_entry(const uint8_t *addr, const char* name, const char* longname)
1826{
  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;
1857}

1859static hashwka_t*
1860wka_hash_new_entry(const uint8_t *addr, char* name)
1861{
  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;
1874}

1876static void
1877add_manuf_name(const uint8_t *addr, unsigned int mask, char *name, char *longname)
1878{
  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;
      }
  }
1902} /* add_manuf_name */

1904/* 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?
*/
1918static hashmanuf_t *
1919manuf_name_lookup(const uint8_t *addr, size_t size _U___attribute__((unused)))
1920{
  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", 1925, __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;

1973} /* manuf_name_lookup */

1975static char *
1976wka_name_lookup(const uint8_t *addr, const unsigned int mask)
1977{
  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);

2005} /* wka_name_lookup */

2007unsigned get_hash_ether_status(hashether_t* ether)
2008{
  return ether->flags;
2010}

2012bool_Bool get_hash_ether_used(hashether_t* ether)
2013{
  return ((ether->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) == TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)));
2015}

2017char* get_hash_ether_hexaddr(hashether_t* ether)
2018{
  return ether->hexaddr;
2020}

2022char* get_hash_ether_resolved_name(hashether_t* ether)
2023{
  return ether->resolved_name;
2025}

2027bool_Bool get_hash_wka_used(hashwka_t* wka)
2028{
  return ((wka->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) == TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)));
2030}

2032char* get_hash_wka_resolved_name(hashwka_t* wka)
2033{
  return wka->name;
2035}

2037static unsigned
2038eth_addr_hash(const void *key)
2039{
  return wmem_strong_hash((const uint8_t *)key, 6);
2041}

2043static gboolean
2044eth_addr_cmp(const void *a, const void *b)
2045{
  return (memcmp(a, b, 6) == 0);
2047}

2049static unsigned
2050eui64_addr_hash(const void *key)
2051{
  return wmem_strong_hash((const uint8_t *)key, EUI64_ADDR_LEN8);
2053}

2055static gboolean
2056eui64_addr_cmp(const void *a, const void *b)
2057{
  return (memcmp(a, b, EUI64_ADDR_LEN8) == 0);
2059}

2061static void
2062initialize_ethers(const char* app_env_var_prefix)
2063{
  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", 2068, __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", 2070, __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", 2072, __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", 2074, __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)(__builtin_object_size ((g_pethers_path), 0) != ((size_t) - 1
)) ? g_free_sized (g_pethers_path, __builtin_object_size ((g_pethers_path
), 0)) : (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)(__builtin_object_size ((g_pmanuf_path), 0) != ((size_t) - 1)
) ? g_free_sized (g_pmanuf_path, __builtin_object_size ((g_pmanuf_path
), 0)) : (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();
  }

2164} /* initialize_ethers */

2166static void
2167ethers_cleanup(void)
2168{
  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)(__builtin_object_size ((g_ethers_path), 0) != ((size_t) - 1)
) ? g_free_sized (g_ethers_path, __builtin_object_size ((g_ethers_path
), 0)) : (g_free) (g_ethers_path);
  g_ethers_path = NULL((void*)0);
  g_free(g_pethers_path)(__builtin_object_size ((g_pethers_path), 0) != ((size_t) - 1
)) ? g_free_sized (g_pethers_path, __builtin_object_size ((g_pethers_path
), 0)) : (g_free) (g_pethers_path);
  g_pethers_path = NULL((void*)0);
  g_free(g_manuf_path)(__builtin_object_size ((g_manuf_path), 0) != ((size_t) - 1))
 ? g_free_sized (g_manuf_path, __builtin_object_size ((g_manuf_path
), 0)) : (g_free) (g_manuf_path);
  g_manuf_path = NULL((void*)0);
  g_free(g_pmanuf_path)(__builtin_object_size ((g_pmanuf_path), 0) != ((size_t) - 1)
) ? g_free_sized (g_pmanuf_path, __builtin_object_size ((g_pmanuf_path
), 0)) : (g_free) (g_pmanuf_path);
  g_pmanuf_path = NULL((void*)0);
  g_free(g_wka_path)(__builtin_object_size ((g_wka_path), 0) != ((size_t) - 1)) ?
 g_free_sized (g_wka_path, __builtin_object_size ((g_wka_path
), 0)) : (g_free) (g_wka_path);
  g_wka_path = NULL((void*)0);
2183}

2185static void
2186eth_resolved_name_fill(hashether_t *tp, const char *name, unsigned mask, const uint8_t *addr)
2187{
  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++;
          }
      }
  }
2224}

2226/* Resolve ethernet address */
2227static hashether_t *
2228eth_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;
2343} /* eth_addr_resolve */

2345static hashether_t *
2346eth_hash_new_entry(const uint8_t *addr, const bool_Bool resolve)
2347{
  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;
2365} /* eth_hash_new_entry */

2367static hashether_t *
2368add_eth_name(const uint8_t *addr, const char *name, bool_Bool static_entry)
2369{
  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;
2388} /* add_eth_name */

2390static hashether_t *
2391eth_name_lookup(const uint8_t *addr, const bool_Bool resolve)
2392{
  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;

2410} /* eth_name_lookup */

2412static void
2413eui64_resolved_name_fill(hasheui64_t *tp, const char *name, unsigned mask, const uint8_t *addr)
2414{
  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++;
          }
      }
  }
2451}

2453/* Resolve EUI-64 address */
2454static hasheui64_t *
2455eui64_addr_resolve(hasheui64_t *tp)
2456{
  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;
2500} /* eui64_addr_resolve */

2502static hasheui64_t *
2503eui64_hash_new_entry(const uint8_t *addr, const bool_Bool resolve)
2504{
  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;
2522} /* eui64_hash_new_entry */

2524static hasheui64_t *
2525add_eui64_name(const uint8_t *addr, const char *name, bool_Bool static_entry)
2526{
  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;
2545} /* add_eui64_name */

2547static hasheui64_t *
2548eui64_name_lookup(const uint8_t *addr, const bool_Bool resolve)
2549{
  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;

2567} /* eui64_name_lookup */

2569/* IPXNETS */
2570static int
2571parse_ipxnets_line(char *line, ipxnet_t *ipxnet)
2572{
  /*
   *  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;

2619} /* parse_ipxnets_line */

2621static FILE *ipxnet_p;

2623static void
2624set_ipxnetent(char *path)
2625{
  if (ipxnet_p)
      rewind(ipxnet_p);
  else
      ipxnet_p = ws_fopenfopen(path, "r");
2630}

2632static void
2633end_ipxnetent(void)
2634{
  if (ipxnet_p) {
      fclose(ipxnet_p);
      ipxnet_p = NULL((void*)0);
  }
2639}

2641static ipxnet_t *
2642get_ipxnetent(void)
2643{

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

2659} /* get_ipxnetent */

2661static ipxnet_t *
2662get_ipxnetbyaddr(uint32_t addr)
2663{
  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;

2683} /* get_ipxnetbyaddr */

2685static void
2686initialize_ipxnets(const char* app_env_var_prefix)
2687{
  /* 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)(__builtin_object_size ((g_pipxnets_path), 0) != ((size_t) - 1
)) ? g_free_sized (g_pipxnets_path, __builtin_object_size ((g_pipxnets_path
), 0)) : (g_free) (g_pipxnets_path);
          g_pipxnets_path = get_persconffile_path(ENAME_IPXNETS"ipxnets", false0, app_env_var_prefix);
      }
  }

2712} /* initialize_ipxnets */

2714static void
2715ipx_name_lookup_cleanup(void)
2716{
  g_ipxnets_path = NULL((void*)0);
  g_free(g_pipxnets_path)(__builtin_object_size ((g_pipxnets_path), 0) != ((size_t) - 1
)) ? g_free_sized (g_pipxnets_path, __builtin_object_size ((g_pipxnets_path
), 0)) : (g_free) (g_pipxnets_path);
  g_pipxnets_path = NULL((void*)0);
2720}

2722static char *
2723ipxnet_name_lookup(wmem_allocator_t *allocator, const unsigned addr)
2724{
  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);

2750} /* ipxnet_name_lookup */

2752/* VLANS */
2753static int
2754parse_vlan_line(char *line, vlan_t *vlan)
2755{
  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;

2779} /* parse_vlan_line */

2781static FILE *vlan_p;

2783static void
2784set_vlanent(char *path)
2785{
  if (vlan_p)
      rewind(vlan_p);
  else
      vlan_p = ws_fopenfopen(path, "r");
2790}

2792static void
2793end_vlanent(void)
2794{
  if (vlan_p) {
      fclose(vlan_p);
      vlan_p = NULL((void*)0);
  }
2799}

2801static vlan_t *
2802get_vlanent(void)
2803{

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

2819} /* get_vlanent */

2821static vlan_t *
2822get_vlannamebyid(uint16_t id)
2823{
  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;

2837} /* get_vlannamebyid */

2839static void
2840initialize_vlans(const char* app_env_var_prefix)
2841{
  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", 2842, __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)(__builtin_object_size ((g_pvlan_path), 0) != ((size_t) - 1))
 ? g_free_sized (g_pvlan_path, __builtin_object_size ((g_pvlan_path
), 0)) : (g_free) (g_pvlan_path);
          g_pvlan_path = get_persconffile_path(ENAME_VLANS"vlans", false0, app_env_var_prefix);
      }
  }
2856} /* initialize_vlans */

2858static void
2859vlan_name_lookup_cleanup(void)
2860{
  end_vlanent();
  vlan_hash_table = NULL((void*)0);
  g_free(g_pvlan_path)(__builtin_object_size ((g_pvlan_path), 0) != ((size_t) - 1))
 ? g_free_sized (g_pvlan_path, __builtin_object_size ((g_pvlan_path
), 0)) : (g_free) (g_pvlan_path);
  g_pvlan_path = NULL((void*)0);
2865}

2867static const char *
2868vlan_name_lookup(const unsigned id)
2869{
  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;

2895} /* vlan_name_lookup */
2896/* VLAN END */

2898static bool_Bool
2899read_hosts_file (const char *hostspath, bool_Bool store_entries)
2900{
  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;
2949} /* read_hosts_file */

2951bool_Bool
2952add_hosts_file (const char *hosts_file)
2953{
  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;
2973}

2975bool_Bool
2976add_ip_name_from_string (const char *addr, const char *name)
2977{
  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;
3029} /* add_ip_name_from_string */

3031extern resolved_name_t* get_edited_resolved_name(const char* addr)
3032{
  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;
3045}

3047/*
* Add the resolved addresses that are in use to the list used to create the pcapng NRB
*/
3050static void
3051ipv4_hash_table_resolved_to_list(void *key _U___attribute__((unused)), void *value, void *user_data)
3052{
  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);
  }
3059}

3061/*
* Add the resolved addresses that are in use to the list used to create the pcapng NRB
*/
3064static void
3065ipv6_hash_table_resolved_to_list(void *key _U___attribute__((unused)), void *value, void *user_data)
3066{
  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);
  }
3073}

3075addrinfo_lists_t *
3076get_addrinfo_list(void)
3077{
  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;
3087}

3089/* 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
*/
3103static bool_Bool
3104read_subnets_file (const char *subnetspath)
3105{
  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;
3149} /* read_subnets_file */

3151static subnet_entry_t
3152subnet_lookup(const uint32_t addr)
3153{
  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", 3166, __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;
3197}

3199/* 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.
*/
3203static void
3204subnet_entry_set(uint32_t subnet_addr, const uint8_t mask_length, const char* name)
3205{
  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"
, 3210, __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;
3244}

3246static void
3247subnet_name_lookup_init(const char* app_env_var_prefix)
3248{
  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)(__builtin_object_size ((subnetspath), 0) != ((size_t) - 1)) ?
 g_free_sized (subnetspath, __builtin_object_size ((subnetspath
), 0)) : (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)(__builtin_object_size ((subnetspath), 0) != ((size_t) - 1)) ?
 g_free_sized (subnetspath, __builtin_object_size ((subnetspath
), 0)) : (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)(__builtin_object_size ((subnetspath), 0) != ((size_t) - 1)) ?
 g_free_sized (subnetspath, __builtin_object_size ((subnetspath
), 0)) : (g_free) (subnetspath);
3283}

3285/* IPv6 Subnet Name Resolution */

3287/* Compute a 16-byte subnet mask from a prefix length (1-128). */
3288static void
3289ipv6_get_subnet_mask(uint32_t mask_length, uint8_t mask[16])
3290{
  uint32_t full_bytes = mask_length / 8;
  uint32_t remaining  = mask_length % 8;
  memset(mask, 0, 16);
  for (uint32_t i = 0; i < full_bytes; i++)
      mask[i] = 0xff;
  if (remaining > 0 && full_bytes < 16)
      mask[full_bytes] = (uint8_t)(0xff << (8 - remaining));
3298}

3300static void
3301subnet6_entry_set(const ws_in6_addr *subnet_addr, const uint32_t mask_length,
                const char *name)
3303{
  subnet_length_entry_v6_t *entry;
  sub_net_hashipv6_t *tp;
  uint8_t masked[16];
  size_t hash_idx;

  ws_assert(mask_length > 0 && mask_length <= 128)do { if ((1) && !(mask_length > 0 && mask_length
 <= 128)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/addr_resolv.c"
, 3309, __func__, "assertion failed: %s", "mask_length > 0 && mask_length <= 128"
); } while (0);
  entry = &subnet_length_entries_v6[mask_length - 1];

  for (int i = 0; i < 16; i++)
      masked[i] = subnet_addr->bytes[i] & entry->mask[i];

  hash_idx = ipv6_oat_hash(masked) & (HASHHOSTSIZE2048 - 1);

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

  if ((tp = entry->subnet_addresses[hash_idx]) != NULL((void*)0)) {
      sub_net_hashipv6_t *new_tp;
      while (tp->next) {
          if (memcmp(tp->addr, masked, 16) == 0)
              return; /* duplicate */
          tp = tp->next;
      }
      if (memcmp(tp->addr, masked, 16) == 0)
          return; /* duplicate at tail */
      new_tp = wmem_new(addr_resolv_scope, sub_net_hashipv6_t)((sub_net_hashipv6_t*)wmem_alloc((addr_resolv_scope), sizeof(
sub_net_hashipv6_t)));
      tp->next = new_tp;
      tp = new_tp;
  } else {
      tp = entry->subnet_addresses[hash_idx] =
          wmem_new(addr_resolv_scope, sub_net_hashipv6_t)((sub_net_hashipv6_t*)wmem_alloc((addr_resolv_scope), sizeof(
sub_net_hashipv6_t)));
  }

  tp->next = NULL((void*)0);
  memcpy(tp->addr, masked, 16);
  (void)g_strlcpy(tp->name, name, MAXNAMELEN64);
  have_subnet_entry_v6 = true1;
3342}

3344static subnet_entry_v6_t
3345subnet6_lookup(const ws_in6_addr *addr)
3346{
  subnet_entry_v6_t result;
  uint32_t i = SUBNETLENGTHSIZE_V6128;

  while (have_subnet_entry_v6 && i > 0) {
      subnet_length_entry_v6_t *length_entry;
      uint8_t masked[16];
      size_t hash_idx;
      sub_net_hashipv6_t *tp;

      --i;
      length_entry = &subnet_length_entries_v6[i];

      if (length_entry->subnet_addresses == NULL((void*)0))
          continue;

      for (int b = 0; b < 16; b++)
          masked[b] = addr->bytes[b] & length_entry->mask[b];

      hash_idx = ipv6_oat_hash(masked) & (HASHHOSTSIZE2048 - 1);
      tp = length_entry->subnet_addresses[hash_idx];

      while (tp != NULL((void*)0) && memcmp(tp->addr, masked, 16) != 0)
          tp = tp->next;

      if (tp != NULL((void*)0)) {
          memcpy(result.mask, length_entry->mask, 16);
          result.mask_length = i + 1;
          result.name = tp->name;
          return result;
      }
  }

  memset(result.mask, 0, 16);
  result.mask_length = 0;
  result.name = NULL((void*)0);
  return result;
3383}

3385static bool_Bool
3386read_subnets_ipv6_file(const char *subnetspath)
3387{
  FILE *hf;
  char line[MAX_LINELEN1024];
  char *cp, *cp2;
  ws_in6_addr host_addr;
  uint32_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;

      /* Expected format: <IPv6_address>/<prefix_length> */
      cp2 = strchr(cp, '/');
      if (cp2 == NULL((void*)0))
          continue;
      *cp2 = '\0';
      ++cp2;

      if (!ws_inet_pton6(cp, &host_addr))
          continue;

      if (!ws_strtou32(cp2, NULL((void*)0), &mask_length) || mask_length == 0 || mask_length > 128)
          continue;

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

      subnet6_entry_set(&host_addr, mask_length, cp);
  }

  fclose(hf);
  return true1;
3425}

3427static void
3428subnet6_name_lookup_init(const char *app_env_var_prefix)
3429{
  char *subnetspath;

  for (uint32_t i = 0; i < SUBNETLENGTHSIZE_V6128; ++i) {
      subnet_length_entries_v6[i].subnet_addresses = NULL((void*)0);
      subnet_length_entries_v6[i].mask_length = i + 1;
      ipv6_get_subnet_mask((uint32_t)(i + 1), subnet_length_entries_v6[i].mask);
  }

  /* Check profile directory before personal configuration */
  subnetspath = get_persconffile_path(ENAME_SUBNETS_V6"subnetsipv6", true1, app_env_var_prefix);
  if (!read_subnets_ipv6_file(subnetspath)) {
      if (errno(*__errno_location ()) != ENOENT2)
          report_open_failure(subnetspath, errno(*__errno_location ()), false0);
      g_free(subnetspath)(__builtin_object_size ((subnetspath), 0) != ((size_t) - 1)) ?
 g_free_sized (subnetspath, __builtin_object_size ((subnetspath
), 0)) : (g_free) (subnetspath);
      subnetspath = get_persconffile_path(ENAME_SUBNETS_V6"subnetsipv6", false0, app_env_var_prefix);
      if (!read_subnets_ipv6_file(subnetspath) && errno(*__errno_location ()) != ENOENT2)
          report_open_failure(subnetspath, errno(*__errno_location ()), false0);
  }
  g_free(subnetspath)(__builtin_object_size ((subnetspath), 0) != ((size_t) - 1)) ?
 g_free_sized (subnetspath, __builtin_object_size ((subnetspath
), 0)) : (g_free) (subnetspath);

  /*
   * Load the global IPv6 subnets file, if we have one.
   */
  subnetspath = get_datafile_path(ENAME_SUBNETS_V6"subnetsipv6", app_env_var_prefix);
  if (!read_subnets_ipv6_file(subnetspath) && errno(*__errno_location ()) != ENOENT2)
      report_open_failure(subnetspath, errno(*__errno_location ()), false0);
  g_free(subnetspath)(__builtin_object_size ((subnetspath), 0) != ((size_t) - 1)) ?
 g_free_sized (subnetspath, __builtin_object_size ((subnetspath
), 0)) : (g_free) (subnetspath);
3457}

3459/* SS7 PC Name Resolution Portion */
3460static hashss7pc_t *
3461new_ss7pc(const uint8_t ni, const uint32_t pc)
3462{
  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;
3469}

3471static hashss7pc_t *
3472host_lookup_ss7pc(const uint8_t ni, const uint32_t pc)
3473{
  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;
3486}

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

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

3495const char *
3496get_hostname_ss7pc(const uint8_t ni, const uint32_t pc)
3497{
  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;
3512}

3514static void
3515add_ss7pc_name(const uint8_t ni, uint32_t pc, const char *name)
3516{
  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);
  }
3533}

3535static bool_Bool
3536read_ss7pcs_file(const char *ss7pcspath)
3537{
  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))
38
←
Taking false branch→
      return false0;

  while (fgetline(line, sizeof(line), hf) >= 0) {
39
←
Loop condition is false. Execution continues on line 3576→
      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);
40
←
Assuming that 'fclose' is successful; 'errno' becomes undefined after the call→
  return entry_found40.1
'entry_found' is false
 ? true1 : false0;
41
←
'?' condition is false→
3578}

3580static void
3581ss7pc_name_lookup_init(const char* app_env_var_prefix)
3582{
  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", 3585, __func__, "assertion failed: %s"
, "ss7pc_hash_table == ((void*)0)"); } while (0);
34
←
Assuming 'ss7pc_hash_table' is equal to null→
35
←
Taking false branch→
36
←
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) {
37
←
Calling 'read_ss7pcs_file'→
42
←
Returning from 'read_ss7pcs_file'→
43
←
An undefined value may be read from 'errno'
      report_open_failure(ss7pcspath, errno(*__errno_location ()), false0);
  }
  g_free(ss7pcspath)(__builtin_object_size ((ss7pcspath), 0) != ((size_t) - 1)) ?
 g_free_sized (ss7pcspath, __builtin_object_size ((ss7pcspath
), 0)) : (g_free) (ss7pcspath);
3597}

3599/* SS7PC Name Resolution End*/

3601/* TACS */
3602static bool_Bool
3603read_tacs_file(const char *tacspath)
3604{
  FILE *hf;
  char line[MAX_LINELEN1024];
  char *cp;
  uint16_t id;

  /*
  *  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)))) {
          char *buf = wmem_strdup(addr_resolv_scope, cp);
          wmem_map_insert(tac_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)), (void *)buf);
      }
  }

  fclose(hf);
  return true1;
3638}

3640static void
3641initialize_tacs(const char* app_env_var_prefix)
3642{
  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", 3644, __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)(__builtin_object_size ((tacspath), 0) != ((size_t) - 1)) ? g_free_sized
 (tacspath, __builtin_object_size ((tacspath), 0)) : (g_free)
 (tacspath);
3652}

3654static void
3655tac_name_lookup_cleanup(void)
3656{
  tac_hash_table = NULL((void*)0);
3658}

3660const char *
3661tac_name_lookup(const unsigned id)
3662{
  return (const char *)wmem_map_lookup(tac_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)));
3664}
3665/* TAC END */

3667/*
*  External Functions
*/

3671void
3672addr_resolve_pref_init(module_t *nameres)
3673{
  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, subnets or subnetsipv6 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);

3778}

3780void addr_resolve_pref_apply(void)
3781{
  c_ares_set_dns_servers();
  maxmind_db_pref_apply();
3784}

3786void
3787disable_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;
3798}

3800bool_Bool
3801host_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;
3831}

3833static void
3834_host_name_lookup_cleanup(void) {
  async_dns_queue_head = NULL((void*)0);

  if (async_dns_initialized) {
      ares_destroy(ghba_chan);
      ares_destroy(ghbn_chan);
  }
3841#ifdef CARES_HAVE_ARES_LIBRARY_INIT1
  ares_library_cleanup();
3843#endif
  async_dns_initialized = false0;
3845}

3847const char *
3848get_hostname(const unsigned addr)
3849{
  /* 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;
3872}

3874char *
3875get_hostname_wmem(wmem_allocator_t *allocator, const unsigned addr)
3876{
  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);
3885}
3886/* -------------------------- */

3888const char *
3889get_hostname6(const ws_in6_addr *addr)
3890{
  /* 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;
3902}

3904char *
3905get_hostname6_wmem(wmem_allocator_t *allocator, const ws_in6_addr *addr)
3906{
  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);
3915}
3916/* -------------------------- */
3917void
3918add_ipv4_name(const unsigned addr, const char *name, bool_Bool static_entry)
3919{
  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);
3942} /* add_ipv4_name */

3944/* -------------------------- */
3945void
3946add_ipv6_name(const ws_in6_addr *addrp, const char *name, const bool_Bool static_entry)
3947{
  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);
3974} /* add_ipv6_name */

3976static void
3977add_manually_resolved_ipv4(void *key, void *value, void *user_data _U___attribute__((unused)))
3978{
  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);
3981}

3983static void
3984add_manually_resolved_ipv6(void *key, void *value, void *user_data _U___attribute__((unused)))
3985{
  resolved_name_t *resolved_ipv6_entry = (resolved_name_t*)value;
  add_ipv6_name((ws_in6_addr*)key, resolved_ipv6_entry->name, true1);
3988}

3990static void
3991add_manually_resolved(void)
3992{
  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));
  }
4000}

4002static void
4003host_name_lookup_init(const char* app_env_var_prefix)
4004{
  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", 4008, __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", 4011, __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", 4014, __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"
, 4017, __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→
      report_open_failure(hostspath, errno(*__errno_location ()), false0);
  }
  g_free(hostspath)(__builtin_object_size ((hostspath), 0) != ((size_t) - 1)) ? g_free_sized
 (hostspath, __builtin_object_size ((hostspath), 0)) : (g_free
) (hostspath);
22
←
Taking false branch→
23
←
Assuming the condition is false→
24
←
'?' condition is false→
  /*
   * 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) {
25
←
Assuming the condition is false→
      report_open_failure(hostspath, errno(*__errno_location ()), false0);
  }
  g_free(hostspath)(__builtin_object_size ((hostspath), 0) != ((size_t) - 1)) ? g_free_sized
 (hostspath, __builtin_object_size ((hostspath), 0)) : (g_free
) (hostspath);
26
←
Taking false branch→
27
←
Assuming the condition is false→
28
←
'?' condition is false→
4049#ifdef CARES_HAVE_ARES_LIBRARY_INIT1
  if (ares_library_init(ARES_LIB_INIT_ALL((1 << 0))) == ARES_SUCCESS) {
29
←
Assuming the condition is false→
30
←
Taking false branch→
4051#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();
      }
4057#ifdef CARES_HAVE_ARES_LIBRARY_INIT1
  }
4059#endif

  if (extra_hosts_files) {
31
←
Assuming 'extra_hosts_files' is null→
32
←
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);
  subnet6_name_lookup_init(app_env_var_prefix);

  add_manually_resolved();

  ss7pc_name_lookup_init(app_env_var_prefix);
33
←
Calling 'ss7pc_name_lookup_init'→
4073}

4075static void
4076host_name_lookup_cleanup(void)
4077{
  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;

  for(i = 0; i < SUBNETLENGTHSIZE_V6128; ++i) {
      sub_net_hashipv6_t *entry6, *next_entry6;
      if (subnet_length_entries_v6[i].subnet_addresses != NULL((void*)0)) {
          for (j = 0; j < HASHHOSTSIZE2048; j++) {
              for (entry6 = subnet_length_entries_v6[i].subnet_addresses[j];
                   entry6 != NULL((void*)0); entry6 = next_entry6) {
                  next_entry6 = entry6->next;
                  wmem_free(addr_resolv_scope, entry6);
              }
          }
          wmem_free(addr_resolv_scope, subnet_length_entries_v6[i].subnet_addresses);
          subnet_length_entries_v6[i].subnet_addresses = NULL((void*)0);
      }
  }
  have_subnet_entry_v6 = false0;

  new_resolved_objects = false0;
4121}


4124void host_name_lookup_reset(const char* app_env_var_prefix)
4125{
  addr_resolv_cleanup();
  addr_resolv_init(app_env_var_prefix);
1
Calling 'addr_resolv_init'→
4128}

4130char *
4131udp_port_to_display(wmem_allocator_t *allocator, unsigned port)
4132{

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

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

4140} /* udp_port_to_display */

4142char *
4143dccp_port_to_display(wmem_allocator_t *allocator, unsigned port)
4144{

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

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

4152} /* dccp_port_to_display */

4154char *
4155tcp_port_to_display(wmem_allocator_t *allocator, unsigned port)
4156{

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

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

4164} /* tcp_port_to_display */

4166char *
4167sctp_port_to_display(wmem_allocator_t *allocator, unsigned port)
4168{

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

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

4176} /* sctp_port_to_display */

4178char *
4179port_with_resolution_to_str(wmem_allocator_t *scope, port_type proto, unsigned port)
4180{
  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", 4188, __func__, "assertion failed: %s"
, "port_str"); } while (0);
  return wmem_strdup_printf(scope, "%s (%u)", port_str, port);
4190}

4192int
4193port_with_resolution_to_str_buf(char *buf, unsigned long buf_size, port_type proto, unsigned port)
4194{
  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", 4202, __func__, "assertion failed: %s"
, "port_str"); } while (0);
  return snprintf(buf, buf_size, "%s (%u)", port_str, port);
4204}

4206const char *
4207get_ether_name(const uint8_t *addr)
4208{
  hashether_t *tp;
  bool_Bool resolve = gbl_resolv_flags.mac_name;

  tp = eth_name_lookup(addr, resolve);

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

4216} /* get_ether_name */

4218const char *
4219tvb_get_ether_name(tvbuff_t *tvb, unsigned offset)
4220{
  return get_ether_name(tvb_get_ptr(tvb, offset, 6));
4222}

4224/* Look for a (non-dummy) ether name in the hash, and return it if found.
* If it's not found, simply return NULL.
*/
4227const char *
4228get_ether_name_if_known(const uint8_t *addr)
4229{
  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);
  }
4249}

4251void
4252add_ether_byip(const unsigned ip, const uint8_t *eth)
4253{
  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);
  }

4273} /* add_ether_byip */

4275char *
4276get_ipxnet_name(wmem_allocator_t *allocator, const uint32_t addr)
4277{

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

  return ipxnet_name_lookup(allocator, addr);

4285} /* get_ipxnet_name */

4287char *
4288get_vlan_name(wmem_allocator_t *allocator, const uint16_t id)
4289{

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

  return wmem_strdup(allocator, vlan_name_lookup(id));

4297} /* get_vlan_name */

4299const char *
4300get_manuf_name(const uint8_t *addr, size_t size)
4301{
  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", 4304, __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;

4312} /* get_manuf_name */

4314const char *
4315tvb_get_manuf_name(tvbuff_t *tvb, unsigned offset)
4316{
  uint8_t buf[3] = { 0 };
  tvb_memcpy(tvb, buf, offset, 3);
  return get_manuf_name(buf, sizeof(buf));
4320}

4322const char *
4323get_manuf_name_if_known(const uint8_t *addr, size_t size)
4324{
  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", 4327, __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);

4346} /* get_manuf_name_if_known */

4348const char *
4349uint_get_manuf_name_if_known(const uint32_t manuf_key)
4350{
  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));
4357}

4359const char *
4360tvb_get_manuf_name_if_known(tvbuff_t *tvb, unsigned offset)
4361{
  uint8_t buf[3] = { 0 };
  tvb_memcpy(tvb, buf, offset, 3);
  return get_manuf_name_if_known(buf, sizeof(buf));
4365}

4367bool_Bool get_hash_manuf_used(hashmanuf_t* manuf)
4368{
  return ((manuf->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) == TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)));
4370}

4372char* get_hash_manuf_resolved_name(hashmanuf_t* manuf)
4373{
  return manuf->resolved_longname;
4375}

4377const char *
4378get_eui64_name(const uint8_t *addr)
4379{
  hasheui64_t *tp;
  bool_Bool resolve = gbl_resolv_flags.mac_name;

  tp = eui64_name_lookup(addr, resolve);

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

4387} /* get_eui64_name */

4389char *
4390eui64_to_display(wmem_allocator_t *allocator, const uint64_t addr_eui64)
4391{
  uint8_t addr[EUI64_ADDR_LEN8];

  phtonu64(addr, addr_eui64);

  const char *result = get_eui64_name(addr);

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

4401#define GHI_TIMEOUT(250 * 1000) (250 * 1000)
4402static void
4403c_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;
  }
4415}

4417/* 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. */
4420bool_Bool
4421get_host_ipaddr(const char *host, uint32_t *addrp)
4422{
  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;
4478}

4480/*
* 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.
*/
4485bool_Bool
4486get_host_ipaddr6(const char *host, ws_in6_addr *addrp)
4487{
  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;
4542}

4544wmem_map_t *
4545get_manuf_hashtable(void)
4546{
  return manuf_hashtable;
4548}

4550wmem_map_t *
4551get_wka_hashtable(void)
4552{
  return wka_hashtable;
4554}

4556wmem_map_t *
4557get_eth_hashtable(void)
4558{
  return eth_hashtable;
4560}

4562wmem_map_t *
4563get_serv_port_hashtable(void)
4564{
  return serv_port_hashtable;
4566}

4568wmem_map_t *
4569get_ipxnet_hash_table(void)
4570{
      return ipxnet_hash_table;
4572}

4574wmem_map_t *
4575get_vlan_hash_table(void)
4576{
      return vlan_hash_table;
4578}

4580wmem_map_t *
4581get_ipv4_hash_table(void)
4582{
      return ipv4_hash_table;
4584}

4586wmem_map_t *
4587get_ipv6_hash_table(void)
4588{
      return ipv6_hash_table;
4590}
4591/* Initialize all the address resolution subsystems in this file */
4592void
4593addr_resolv_init(const char* app_env_var_prefix)
4594{
  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", 4595, __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);
4604}

4606/* Clean up all the address resolution subsystems in this file */
4607void
4608addr_resolv_cleanup(void)
4609{
  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);
4620}

4622bool_Bool
4623str_to_ip(const char *str, void *dst)
4624{
  return ws_inet_pton4(str, (uint32_t *)dst);
4626}

4628bool_Bool
4629str_to_ip6(const char *str, void *dst)
4630{
  return ws_inet_pton6(str, (ws_in6_addr *)dst);
4632}

4634/*
* 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
*/
4639bool_Bool
4640str_to_eth(const char *str, uint8_t (*eth_bytes)[6])
4641{
  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;
4652}

4654/*
* 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:
*/