/builds/wireshark/wireshark/epan/addr

Bug Summary

File:	epan/addr_resolv.c
Warning:	line 3330, 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-20/lib/clang/20 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -isystem /builds/wireshark/wireshark/epan -isystem /builds/wireshark/wireshark/build/epan -isystem /usr/include/mit-krb5 -isystem /usr/include/libxml2 -isystem /usr/include/lua5.4 -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_BUILD_DLL -D WS_DEBUG -D WS_DEBUG_UTF_8 -D epan_EXPORTS -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/wiretap -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-20/lib/clang/20/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-truncation -Wno-format-nonliteral -Wno-pointer-sign -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/wireshark/wireshark/sbout/2025-09-10-100354-3933-1 -x c /builds/wireshark/wireshark/epan/addr_resolv.c
1/* addr_resolv.c
* Routines for network object lookup
*
* Laurent Deniel <[email protected]>
*
* Add option to resolv VLAN ID to describing name
* Uli Heilmeier, March 2016
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <[email protected]>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/

16#include "config.h"

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

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

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

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

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

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

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

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

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

82#include <glib.h>

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

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

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

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

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

116/* hash table used for IPv4 lookup */

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


121typedef 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];
127} sub_net_hashipv4_t;

129/* Array of entries of subnets of different lengths */
130typedef 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 */
134} subnet_length_entry_t;


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

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

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

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

149typedef struct hashvlan {
  unsigned            id;
151/*    struct hashvlan     *next; */
  char                name[MAXVLANNAMELEN128];
153} hashvlan_t;

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

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

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

176struct hashwka {
  uint8_t           flags;  /* (See above) */
  char*             name;
179};

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

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

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

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

211static wmem_allocator_t *addr_resolv_scope;

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

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

225static addrinfo_lists_t addrinfo_lists;

227struct cb_serv_data {
  char        *service;
  port_type    proto;
230};

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

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

250static subnet_length_entry_t subnet_length_entries[SUBNETLENGTHSIZE32]; /* Ordered array of entries */
251static bool_Bool have_subnet_entry;

253static bool_Bool new_resolved_objects;

255static GPtrArray* extra_hosts_files;

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

261/* http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx#existing
* One-at-a-Time hash
*/
264unsigned
265ipv6_oat_hash(const void *key)
266{
  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;
283}

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

295gboolean
296ipv6_equal(const void *v1, const void *v2)
297{

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

  return false0;
304}

306/*
* Flag controlling what names to resolve.
*/
309e_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 */
319};

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

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

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

348/*
* 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.
*/
355typedef struct _async_dns_queue_msg
356{
  union {
      uint32_t          ip4;
      ws_in6_addr ip6;
  } addr;
  int                 family;
362} async_dns_queue_msg_t;

364typedef struct _async_hostent {
  int addr_size;
  int   copied;
  void *addrp;
368} async_hostent_t;

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

373/*
* 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.
*/
378typedef struct _sync_dns_data
379{
  union {
      uint32_t     ip4;
      ws_in6_addr  ip6;
  } addr;
  int              family;
  bool_Bool            *completed;
386} sync_dns_data_t;

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

391static  bool_Bool        async_dns_initialized;
392static  unsigned    async_dns_in_flight;
393static  wmem_list_t *async_dns_queue_head;
394static  GMutex      async_dns_queue_mtx;

396//UAT for providing a list of DNS servers to C-ARES for name resolution
397bool_Bool use_custom_dns_server_list;
398struct dns_server_data {
  char *ipaddr;
  uint32_t udp_port;
  uint32_t tcp_port;
402};

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

408static uat_t *dnsserver_uat;
409static struct dns_server_data  *dnsserverlist_uats;
410static unsigned ndnsservers;

412static void
413dns_server_free_cb(void *data)
414{
  struct dns_server_data *h = (struct dns_server_data*)data;

  g_free(h->ipaddr);
418}

420static void*
421dns_server_copy_cb(void *dst_, const void *src_, size_t len _U___attribute__((unused)))
422{
  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;
431}

433static bool_Bool
434dnsserver_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)
435{
  //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;
444}

446static bool_Bool
447dnsserver_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)
448{
  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;
465}

467static void
468c_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);
498}

500static void
501wait_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);
      }
  }
544}

546static void
547process_async_dns_queue(void)
548{
  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);
577}

579static void
580wait_for_async_queue(void)
581{
  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;
626}

628static void
629sync_lookup_ip4(const uint32_t addr)
630{
  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);
655}

657static void
658sync_lookup_ip6(const ws_in6_addr *addrp)
659{
  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);
684}

686void
687set_resolution_synchrony(bool_Bool synchronous)
688{
  resolve_synchronously = synchronous;
  maxmind_db_set_synchrony(synchronous);

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

697static void
698c_ares_set_dns_servers(void)
699{
  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);
  }
757}

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

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

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

779} /* fgetline */


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

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

794static gboolean serv_port_custom_equal(const void *k1, const void *k2)
795{
  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);
800}

802static void
803add_custom_service_name(port_type proto, const unsigned port, const char *service_name)
804{
  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;
822}

824static void
825add_service_name(port_type proto, const unsigned port, const char *service_name)
826{
  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;
834}

836static void
837parse_service_line (char *line)
838{
  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);
889} /* parse_service_line */


892static void
893add_serv_port_cb(const uint32_t port, void *ptr)
894{
  struct cb_serv_data *cb_data = (struct cb_serv_data *)ptr;

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


903static bool_Bool
904parse_services_file(const char * path)
905{
  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;
921}

923/* -----------------
* unsigned integer to ascii
*/
926static char *
927wmem_utoa(wmem_allocator_t *allocator, unsigned port)
928{
  char *bp = (char *)wmem_alloc(allocator, MAXNAMELEN64);

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

936static const char *
937_serv_name_lookup(port_type proto, unsigned port)
938{
  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;
973}

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

981const char *
982serv_name_lookup(port_type proto, unsigned port)
983{
  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;
1001}

1003static void
1004initialize_services(void)
1005{
  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",
 1006, __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"
, 1008, __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");
  }
  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);
      if (!parse_services_file(g_pservices_path)) {
          g_free(g_pservices_path);
          g_pservices_path = get_persconffile_path(ENAME_SERVICES"services", false0);
          parse_services_file(g_pservices_path);
      }
  }
1027}

1029static void
1030service_name_lookup_cleanup(void)
1031{
  serv_port_hashtable = NULL((void*)0);
  serv_port_custom_hashtable = NULL((void*)0);
  g_free(g_services_path);
  g_services_path = NULL((void*)0);
  g_free(g_pservices_path);
  g_pservices_path = NULL((void*)0);
1038}

1040static void
1041parse_enterprises_line (char *line)
1042{
  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));
1069}


1072static bool_Bool
1073parse_enterprises_file(const char * path)
1074{
  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;
1088}

1090static void
1091initialize_enterprises(void)
1092{
  ws_assert(enterprises_hashtable == NULL)do { if ((1) && !(enterprises_hashtable == ((void*)0)
)) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/addr_resolv.c"
, 1093, __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");
  }
  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);
      if (!file_exists(g_penterprises_path)) {
          g_free(g_penterprises_path);
          g_penterprises_path = get_persconffile_path(ENAME_ENTERPRISES"enterprises", false0);
      }
  }
  /* Parse personal file (if present) */
  parse_enterprises_file(g_penterprises_path);
1112}

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

1127const char *
1128enterprises_lookup(uint32_t value, const char *unknown_str)
1129{
  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>";
1138}

1140void
1141enterprises_base_custom(char *buf, uint32_t value)
1142{
  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);
1148}

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

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

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

  /* Overwrite if we get async DNS reply */

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

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

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

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

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

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

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

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

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


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

1239static void
1240c_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);
1264}

1266/* --------------- */
1267hashipv4_t *
1268new_ipv4(const unsigned addr)
1269{
  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;
1276}

1278static hashipv4_t *
1279host_lookup(const unsigned addr)
1280{
  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 concurrencly 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;

1334} /* host_lookup */

1336/* --------------- */
1337static hashipv6_t *
1338new_ipv6(const ws_in6_addr *addr)
1339{
  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;
1346}

1348/* ------------------------------------ */
1349static hashipv6_t *
1350host_lookup6(const ws_in6_addr *addr)
1351{
  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 concurrencly 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;

1409} /* host_lookup6 */

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

1435/*
* 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.
*/
1441static bool_Bool
1442parse_ether_address_fast(const unsigned char *cp, ether_t *eth, unsigned int *mask,
      const bool_Bool accept_mask)
1444{
  /* 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;
1535}

1537/*
* 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.
*/
1543static bool_Bool
1544parse_ether_address(const char *cp, ether_t *eth, unsigned int *mask,
      const bool_Bool accept_mask)
1546{
  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;
1644}

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

1693} /* parse_ether_line */

1695static FILE *eth_p;

1697static void
1698set_ethent(char *path)
1699{
  if (eth_p)
      rewind(eth_p);
  else
      eth_p = ws_fopenfopen(path, "r");
1704}

1706static void
1707end_ethent(void)
1708{
  if (eth_p) {
      fclose(eth_p);
      eth_p = NULL((void*)0);
  }
1713}

1715static ether_t *
1716get_ethent(unsigned int *mask, const bool_Bool accept_mask)
1717{

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

1733} /* get_ethent */

1735static hashmanuf_t *
1736manuf_hash_new_entry(const uint8_t *addr, const char* name, const char* longname)
1737{
  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;
1768}

1770static hashwka_t*
1771wka_hash_new_entry(const uint8_t *addr, char* name)
1772{
  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;
1785}

1787static void
1788add_manuf_name(const uint8_t *addr, unsigned int mask, char *name, char *longname)
1789{
  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;
      }
  }
1813} /* add_manuf_name */

1815/* 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?
*/
1829static hashmanuf_t *
1830manuf_name_lookup(const uint8_t *addr, size_t size _U___attribute__((unused)))
1831{
  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", 1836, __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;

1884} /* manuf_name_lookup */

1886static char *
1887wka_name_lookup(const uint8_t *addr, const unsigned int mask)
1888{
  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);

1916} /* wka_name_lookup */

1918unsigned get_hash_ether_status(hashether_t* ether)
1919{
  return ether->flags;
1921}

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

1928char* get_hash_ether_hexaddr(hashether_t* ether)
1929{
  return ether->hexaddr;
1931}

1933char* get_hash_ether_resolved_name(hashether_t* ether)
1934{
  return ether->resolved_name;
1936}

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

1943char* get_hash_wka_resolved_name(hashwka_t* wka)
1944{
  return wka->name;
1946}

1948static unsigned
1949eth_addr_hash(const void *key)
1950{
  return wmem_strong_hash((const uint8_t *)key, 6);
1952}

1954static gboolean
1955eth_addr_cmp(const void *a, const void *b)
1956{
  return (memcmp(a, b, 6) == 0);
1958}

1960static unsigned
1961eui64_addr_hash(const void *key)
1962{
  return wmem_strong_hash((const uint8_t *)key, EUI64_ADDR_LEN8);
1964}

1966static gboolean
1967eui64_addr_cmp(const void *a, const void *b)
1968{
  return (memcmp(a, b, EUI64_ADDR_LEN8) == 0);
1970}

1972static void
1973initialize_ethers(void)
1974{
  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", 1979, __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", 1981, __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", 1983, __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", 1985, __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(), 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);
      if (!file_exists(g_pethers_path)) {
          g_free(g_pethers_path);
          g_pethers_path = get_persconffile_path(ENAME_ETHERS"ethers", false0);
      }
  }

  /* Compute the pathname of the global manuf file */
  if (g_manuf_path == NULL((void*)0))
      g_manuf_path = get_datafile_path(ENAME_MANUF"manuf");
  /* 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);
      if (!file_exists(g_pmanuf_path)) {
          g_free(g_pmanuf_path);
          g_pmanuf_path = get_persconffile_path(ENAME_MANUF"manuf", false0);
      }
  }
  /* 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");

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

2075} /* initialize_ethers */

2077static void
2078ethers_cleanup(void)
2079{
  wka_hashtable = NULL((void*)0);
  manuf_hashtable = NULL((void*)0);
  eth_hashtable = NULL((void*)0);
  eui64_hashtable = NULL((void*)0);
  g_free(g_ethers_path);
  g_ethers_path = NULL((void*)0);
  g_free(g_pethers_path);
  g_pethers_path = NULL((void*)0);
  g_free(g_manuf_path);
  g_manuf_path = NULL((void*)0);
  g_free(g_pmanuf_path);
  g_pmanuf_path = NULL((void*)0);
  g_free(g_wka_path);
  g_wka_path = NULL((void*)0);
2094}

2096static void
2097eth_resolved_name_fill(hashether_t *tp, const char *name, unsigned mask, const uint8_t *addr)
2098{
  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++;
          }
      }
  }
2135}

2137/* Resolve ethernet address */
2138static hashether_t *
2139eth_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;
2254} /* eth_addr_resolve */

2256static hashether_t *
2257eth_hash_new_entry(const uint8_t *addr, const bool_Bool resolve)
2258{
  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;
2276} /* eth_hash_new_entry */

2278static hashether_t *
2279add_eth_name(const uint8_t *addr, const char *name, bool_Bool static_entry)
2280{
  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;
2299} /* add_eth_name */

2301static hashether_t *
2302eth_name_lookup(const uint8_t *addr, const bool_Bool resolve)
2303{
  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;

2321} /* eth_name_lookup */

2323static void
2324eui64_resolved_name_fill(hasheui64_t *tp, const char *name, unsigned mask, const uint8_t *addr)
2325{
  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++;
          }
      }
  }
2362}

2364/* Resolve EUI-64 address */
2365static hasheui64_t *
2366eui64_addr_resolve(hasheui64_t *tp)
2367{
  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;
2411} /* eui64_addr_resolve */

2413static hasheui64_t *
2414eui64_hash_new_entry(const uint8_t *addr, const bool_Bool resolve)
2415{
  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;
2433} /* eui64_hash_new_entry */

2435static hasheui64_t *
2436add_eui64_name(const uint8_t *addr, const char *name, bool_Bool static_entry)
2437{
  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;
2456} /* add_eui64_name */

2458static hasheui64_t *
2459eui64_name_lookup(const uint8_t *addr, const bool_Bool resolve)
2460{
  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;

2478} /* eui64_name_lookup */

2480/* IPXNETS */
2481static int
2482parse_ipxnets_line(char *line, ipxnet_t *ipxnet)
2483{
  /*
   *  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;

2530} /* parse_ipxnets_line */

2532static FILE *ipxnet_p;

2534static void
2535set_ipxnetent(char *path)
2536{
  if (ipxnet_p)
      rewind(ipxnet_p);
  else
      ipxnet_p = ws_fopenfopen(path, "r");
2541}

2543static void
2544end_ipxnetent(void)
2545{
  if (ipxnet_p) {
      fclose(ipxnet_p);
      ipxnet_p = NULL((void*)0);
  }
2550}

2552static ipxnet_t *
2553get_ipxnetent(void)
2554{

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

2570} /* get_ipxnetent */

2572static ipxnet_t *
2573get_ipxnetbyaddr(uint32_t addr)
2574{
  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;

2594} /* get_ipxnetbyaddr */

2596static void
2597initialize_ipxnets(void)
2598{
  /* 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(), 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);
      if (!file_exists(g_pipxnets_path)) {
          g_free(g_pipxnets_path);
          g_pipxnets_path = get_persconffile_path(ENAME_IPXNETS"ipxnets", false0);
      }
  }

2623} /* initialize_ipxnets */

2625static void
2626ipx_name_lookup_cleanup(void)
2627{
  g_ipxnets_path = NULL((void*)0);
  g_free(g_pipxnets_path);
  g_pipxnets_path = NULL((void*)0);
2631}

2633static char *
2634ipxnet_name_lookup(wmem_allocator_t *allocator, const unsigned addr)
2635{
  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);

2661} /* ipxnet_name_lookup */

2663/* VLANS */
2664static int
2665parse_vlan_line(char *line, vlan_t *vlan)
2666{
  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;

2690} /* parse_vlan_line */

2692static FILE *vlan_p;

2694static void
2695set_vlanent(char *path)
2696{
  if (vlan_p)
      rewind(vlan_p);
  else
      vlan_p = ws_fopenfopen(path, "r");
2701}

2703static void
2704end_vlanent(void)
2705{
  if (vlan_p) {
      fclose(vlan_p);
      vlan_p = NULL((void*)0);
  }
2710}

2712static vlan_t *
2713get_vlanent(void)
2714{

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

2730} /* get_vlanent */

2732static vlan_t *
2733get_vlannamebyid(uint16_t id)
2734{
  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;

2748} /* get_vlannamebyid */

2750static void
2751initialize_vlans(void)
2752{
  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", 2753, __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);
      if (!file_exists(g_pvlan_path)) {
          g_free(g_pvlan_path);
          g_pvlan_path = get_persconffile_path(ENAME_VLANS"vlans", false0);
      }
  }
2767} /* initialize_vlans */

2769static void
2770vlan_name_lookup_cleanup(void)
2771{
  end_vlanent();
  vlan_hash_table = NULL((void*)0);
  g_free(g_pvlan_path);
  g_pvlan_path = NULL((void*)0);
2776}

2778static const char *
2779vlan_name_lookup(const unsigned id)
2780{
  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;

2806} /* vlan_name_lookup */
2807/* VLAN END */

2809static bool_Bool
2810read_hosts_file (const char *hostspath, bool_Bool store_entries)
2811{
  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;
2860} /* read_hosts_file */

2862bool_Bool
2863add_hosts_file (const char *hosts_file)
2864{
  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;
2884}

2886bool_Bool
2887add_ip_name_from_string (const char *addr, const char *name)
2888{
  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;
2940} /* add_ip_name_from_string */

2942extern resolved_name_t* get_edited_resolved_name(const char* addr)
2943{
  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;
2956}

2958/*
* Add the resolved addresses that are in use to the list used to create the pcapng NRB
*/
2961static void
2962ipv4_hash_table_resolved_to_list(void *key _U___attribute__((unused)), void *value, void *user_data)
2963{
  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);
  }
2970}

2972/*
* Add the resolved addresses that are in use to the list used to create the pcapng NRB
*/
2975static void
2976ipv6_hash_table_resolved_to_list(void *key _U___attribute__((unused)), void *value, void *user_data)
2977{
  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);
  }
2984}

2986addrinfo_lists_t *
2987get_addrinfo_list(void)
2988{
  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;
2998}

3000/* 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
*/
3014static bool_Bool
3015read_subnets_file (const char *subnetspath)
3016{
  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;
3060} /* read_subnets_file */

3062static subnet_entry_t
3063subnet_lookup(const uint32_t addr)
3064{
  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", 3077, __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;
3108}

3110/* 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.
*/
3114static void
3115subnet_entry_set(uint32_t subnet_addr, const uint8_t mask_length, const char* name)
3116{
  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"
, 3121, __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;
3155}

3157static void
3158subnet_name_lookup_init(void)
3159{
  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);
  if (!read_subnets_file(subnetspath)) {
      if (errno(*__errno_location ()) != ENOENT2) {
          report_open_failure(subnetspath, errno(*__errno_location ()), false0);
      }

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

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

3196/* SS7 PC Name Resolution Portion */
3197static hashss7pc_t *
3198new_ss7pc(const uint8_t ni, const uint32_t pc)
3199{
  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;
3206}

3208static hashss7pc_t *
3209host_lookup_ss7pc(const uint8_t ni, const uint32_t pc)
3210{
  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;
3223}

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

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

3232const char *
3233get_hostname_ss7pc(const uint8_t ni, const uint32_t pc)
3234{
  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;
3249}

3251static void
3252add_ss7pc_name(const uint8_t ni, uint32_t pc, const char *name)
3253{
  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);
  }
3270}

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

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

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

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

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

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

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

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

3317static void
3318ss7pc_name_lookup_init(void)
3319{
  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", 3322, __func__, "assertion failed: %s"
, "ss7pc_hash_table == ((void*)0)"); } while (0);
30
←
Assuming 'ss7pc_hash_table' is equal to null→
31
←
Taking false branch→
32
←
Loop condition is false.  Exiting loop→

  ss7pc_hash_table = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal);

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

3336/* SS7PC Name Resolution End*/


3339/*
*  External Functions
*/

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

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

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

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

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

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

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

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

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

  prefs_register_obsolete_preference(nameres, "concurrent_dns");

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

  prefs_register_obsolete_preference(nameres, "hosts_file_handling");

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

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

3443}

3445void addr_resolve_pref_apply(void)
3446{
  c_ares_set_dns_servers();
  maxmind_db_pref_apply();
3449}

3451void
3452disable_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;
3462}

3464bool_Bool
3465host_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;
3495}

3497static void
3498_host_name_lookup_cleanup(void) {
  async_dns_queue_head = NULL((void*)0);

  if (async_dns_initialized) {
      ares_destroy(ghba_chan);
      ares_destroy(ghbn_chan);
  }
3505#ifdef CARES_HAVE_ARES_LIBRARY_INIT1
  ares_library_cleanup();
3507#endif
  async_dns_initialized = false0;
3509}

3511const char *
3512get_hostname(const unsigned addr)
3513{
  /* 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;
3536}

3538char *
3539get_hostname_wmem(wmem_allocator_t *allocator, const unsigned addr)
3540{
  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);
3549}
3550/* -------------------------- */

3552const char *
3553get_hostname6(const ws_in6_addr *addr)
3554{
  /* 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;
3566}

3568char *
3569get_hostname6_wmem(wmem_allocator_t *allocator, const ws_in6_addr *addr)
3570{
  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);
3579}
3580/* -------------------------- */
3581void
3582add_ipv4_name(const unsigned addr, const char *name, bool_Bool static_entry)
3583{
  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);
3606} /* add_ipv4_name */

3608/* -------------------------- */
3609void
3610add_ipv6_name(const ws_in6_addr *addrp, const char *name, const bool_Bool static_entry)
3611{
  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);
3638} /* add_ipv6_name */

3640static void
3641add_manually_resolved_ipv4(void *key, void *value, void *user_data _U___attribute__((unused)))
3642{
  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);
3645}

3647static void
3648add_manually_resolved_ipv6(void *key, void *value, void *user_data _U___attribute__((unused)))
3649{
  resolved_name_t *resolved_ipv6_entry = (resolved_name_t*)value;
  add_ipv6_name((ws_in6_addr*)key, resolved_ipv6_entry->name, true1);
3652}

3654static void
3655add_manually_resolved(void)
3656{
  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));
  }
3664}

3666static void
3667host_name_lookup_init(void)
3668{
  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", 3672, __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", 3675, __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", 3678, __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"
, 3681, __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");
  if (!read_hosts_file(hostspath, true1) && errno(*__errno_location ()) != ENOENT2) {
21
←
Assuming the condition is false→
22
←
Taking false branch→
      report_open_failure(hostspath, errno(*__errno_location ()), false0);
  }
  g_free(hostspath);
  /*
   * Load the user's hosts file no matter what, if they have one.
   */
  hostspath = get_persconffile_path(ENAME_HOSTS"hosts", true1);
  if (!read_hosts_file(hostspath, true1) && errno(*__errno_location ()) != ENOENT2) {
23
←
Assuming the condition is false→
24
←
Taking false branch→
      report_open_failure(hostspath, errno(*__errno_location ()), false0);
  }
  g_free(hostspath);
3713#ifdef CARES_HAVE_ARES_LIBRARY_INIT1
  if (ares_library_init(ARES_LIB_INIT_ALL((1 << 0))) == ARES_SUCCESS) {
25
←
Assuming the condition is false→
26
←
Taking false branch→
3715#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();
      }
3721#ifdef CARES_HAVE_ARES_LIBRARY_INIT1
  }
3723#endif

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

  subnet_name_lookup_init();

  add_manually_resolved();

  ss7pc_name_lookup_init();
29
←
Calling 'ss7pc_name_lookup_init'→
3736}

3738static void
3739host_name_lookup_cleanup(void)
3740{
  uint32_t i, j;
  sub_net_hashipv4_t *entry, *next_entry;

  _host_name_lookup_cleanup();

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

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

  have_subnet_entry = false0;
  new_resolved_objects = false0;
3767}


3770void host_name_lookup_reset(void)
3771{
  addr_resolv_cleanup();
  addr_resolv_init();
1
Calling 'addr_resolv_init'→
3774}

3776char *
3777udp_port_to_display(wmem_allocator_t *allocator, unsigned port)
3778{

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

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

3786} /* udp_port_to_display */

3788char *
3789dccp_port_to_display(wmem_allocator_t *allocator, unsigned port)
3790{

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

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

3798} /* dccp_port_to_display */

3800char *
3801tcp_port_to_display(wmem_allocator_t *allocator, unsigned port)
3802{

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

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

3810} /* tcp_port_to_display */

3812char *
3813sctp_port_to_display(wmem_allocator_t *allocator, unsigned port)
3814{

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

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

3822} /* sctp_port_to_display */

3824char *
3825port_with_resolution_to_str(wmem_allocator_t *scope, port_type proto, unsigned port)
3826{
  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", 3834, __func__, "assertion failed: %s"
, "port_str"); } while (0);
  return wmem_strdup_printf(scope, "%s (%u)", port_str, port);
3836}

3838int
3839port_with_resolution_to_str_buf(char *buf, unsigned long buf_size, port_type proto, unsigned port)
3840{
  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", 3848, __func__, "assertion failed: %s"
, "port_str"); } while (0);
  return snprintf(buf, buf_size, "%s (%u)", port_str, port);
3850}

3852const char *
3853get_ether_name(const uint8_t *addr)
3854{
  hashether_t *tp;
  bool_Bool resolve = gbl_resolv_flags.mac_name;

  tp = eth_name_lookup(addr, resolve);

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

3862} /* get_ether_name */

3864const char *
3865tvb_get_ether_name(tvbuff_t *tvb, int offset)
3866{
  return get_ether_name(tvb_get_ptr(tvb, offset, 6));
3868}

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

3897void
3898add_ether_byip(const unsigned ip, const uint8_t *eth)
3899{
  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);
  }

3919} /* add_ether_byip */

3921char *
3922get_ipxnet_name(wmem_allocator_t *allocator, const uint32_t addr)
3923{

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

  return ipxnet_name_lookup(allocator, addr);

3931} /* get_ipxnet_name */

3933char *
3934get_vlan_name(wmem_allocator_t *allocator, const uint16_t id)
3935{

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

  return wmem_strdup(allocator, vlan_name_lookup(id));

3943} /* get_vlan_name */

3945const char *
3946get_manuf_name(const uint8_t *addr, size_t size)
3947{
  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", 3950, __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;

3958} /* get_manuf_name */

3960const char *
3961tvb_get_manuf_name(tvbuff_t *tvb, int offset)
3962{
  uint8_t buf[3] = { 0 };
  tvb_memcpy(tvb, buf, offset, 3);
  return get_manuf_name(buf, sizeof(buf));
3966}

3968const char *
3969get_manuf_name_if_known(const uint8_t *addr, size_t size)
3970{
  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", 3973, __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);

3992} /* get_manuf_name_if_known */

3994const char *
3995uint_get_manuf_name_if_known(const uint32_t manuf_key)
3996{
  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));
4003}

4005const char *
4006tvb_get_manuf_name_if_known(tvbuff_t *tvb, int offset)
4007{
  uint8_t buf[3] = { 0 };
  tvb_memcpy(tvb, buf, offset, 3);
  return get_manuf_name_if_known(buf, sizeof(buf));
4011}

4013bool_Bool get_hash_manuf_used(hashmanuf_t* manuf)
4014{
  return ((manuf->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) == TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)));
4016}

4018char* get_hash_manuf_resolved_name(hashmanuf_t* manuf)
4019{
  return manuf->resolved_longname;
4021}

4023const char *
4024get_eui64_name(const uint8_t *addr)
4025{
  hasheui64_t *tp;
  bool_Bool resolve = gbl_resolv_flags.mac_name;

  tp = eui64_name_lookup(addr, resolve);

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

4033} /* get_eui64_name */

4035char *
4036eui64_to_display(wmem_allocator_t *allocator, const uint64_t addr_eui64)
4037{
  uint8_t addr[EUI64_ADDR_LEN8];

  phtonu64(addr, addr_eui64);

  const char *result = get_eui64_name(addr);

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

4047#define GHI_TIMEOUT(250 * 1000) (250 * 1000)
4048static void
4049c_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;
  }
4061}

4063/* 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. */
4066bool_Bool
4067get_host_ipaddr(const char *host, uint32_t *addrp)
4068{
  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;
4124}

4126/*
* 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.
*/
4131bool_Bool
4132get_host_ipaddr6(const char *host, ws_in6_addr *addrp)
4133{
  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;
4188}

4190wmem_map_t *
4191get_manuf_hashtable(void)
4192{
  return manuf_hashtable;
4194}

4196wmem_map_t *
4197get_wka_hashtable(void)
4198{
  return wka_hashtable;
4200}

4202wmem_map_t *
4203get_eth_hashtable(void)
4204{
  return eth_hashtable;
4206}

4208wmem_map_t *
4209get_serv_port_hashtable(void)
4210{
  return serv_port_hashtable;
4212}

4214wmem_map_t *
4215get_ipxnet_hash_table(void)
4216{
      return ipxnet_hash_table;
4218}

4220wmem_map_t *
4221get_vlan_hash_table(void)
4222{
      return vlan_hash_table;
4224}

4226wmem_map_t *
4227get_ipv4_hash_table(void)
4228{
      return ipv4_hash_table;
4230}

4232wmem_map_t *
4233get_ipv6_hash_table(void)
4234{
      return ipv6_hash_table;
4236}
4237/* Initialize all the address resolution subsystems in this file */
4238void
4239addr_resolv_init(void)
4240{
  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", 4241, __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();
  initialize_ethers();
  initialize_ipxnets();
  initialize_vlans();
  initialize_enterprises();
  host_name_lookup_init();
4
←
Calling 'host_name_lookup_init'→
4249}

4251/* Clean up all the address resolution subsystems in this file */
4252void
4253addr_resolv_cleanup(void)
4254{
  vlan_name_lookup_cleanup();
  service_name_lookup_cleanup();
  ethers_cleanup();
  ipx_name_lookup_cleanup();
  enterprises_cleanup();
  host_name_lookup_cleanup();

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

4266bool_Bool
4267str_to_ip(const char *str, void *dst)
4268{
  return ws_inet_pton4(str, (uint32_t *)dst);
4270}

4272bool_Bool
4273str_to_ip6(const char *str, void *dst)
4274{
  return ws_inet_pton6(str, (ws_in6_addr *)dst);
4276}

4278/*
* 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
*/
4283bool_Bool
4284str_to_eth(const char *str, char *eth_bytes)
4285{
  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;
4296}

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