| File: | epan/addr_resolv.c |
| Warning: | line 3746, column 46 An undefined value may be read from 'errno' |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* addr_resolv.c | |||
| 2 | * Routines for network object lookup | |||
| 3 | * | |||
| 4 | * Laurent Deniel <laurent.deniel@free.fr> | |||
| 5 | * | |||
| 6 | * Add option to resolv VLAN ID to describing name | |||
| 7 | * Uli Heilmeier, March 2016 | |||
| 8 | * | |||
| 9 | * Wireshark - Network traffic analyzer | |||
| 10 | * By Gerald Combs <gerald@wireshark.org> | |||
| 11 | * Copyright 1998 Gerald Combs | |||
| 12 | * | |||
| 13 | * SPDX-License-Identifier: GPL-2.0-or-later | |||
| 14 | */ | |||
| 15 | ||||
| 16 | #include "config.h" | |||
| 17 | ||||
| 18 | #include <stdio.h> | |||
| 19 | #include <stdlib.h> | |||
| 20 | #include <string.h> | |||
| 21 | #include <errno(*__errno_location ()).h> | |||
| 22 | ||||
| 23 | #include <wsutil/strtoi.h> | |||
| 24 | #include <wsutil/ws_assert.h> | |||
| 25 | ||||
| 26 | #include "enterprises.h" | |||
| 27 | #include "manuf.h" | |||
| 28 | ||||
| 29 | /* | |||
| 30 | * Win32 doesn't have SIGALRM (and it's the OS where name lookup calls | |||
| 31 | * are most likely to take a long time, given the way address-to-name | |||
| 32 | * lookups are done over NBNS). | |||
| 33 | * | |||
| 34 | * macOS does have SIGALRM, but if you longjmp() out of a name resolution | |||
| 35 | * call in a signal handler, you might crash, because the state of the | |||
| 36 | * resolution code that sends messages to lookupd might be inconsistent | |||
| 37 | * if you jump out of it in middle of a call. | |||
| 38 | * | |||
| 39 | * There's no guarantee that longjmp()ing out of name resolution calls | |||
| 40 | * will work on *any* platform; OpenBSD got rid of the alarm/longjmp | |||
| 41 | * code in tcpdump, to avoid those sorts of problems, and that was | |||
| 42 | * picked up by tcpdump.org tcpdump. | |||
| 43 | * | |||
| 44 | * So, for now, we do not use alarm() and SIGALRM to time out host name | |||
| 45 | * lookups. If we get a lot of complaints about lookups taking a long time, | |||
| 46 | * we can reconsider that decision. (Note that tcpdump originally added | |||
| 47 | * such a timeout mechanism that for the benefit of systems using NIS to | |||
| 48 | * look up host names; that might now be fixed in NIS implementations, for | |||
| 49 | * those sites still using NIS rather than DNS for that.... tcpdump no | |||
| 50 | * longer does that, for the same reasons that we don't.) | |||
| 51 | * | |||
| 52 | * If we're using an asynchronous DNS resolver, that shouldn't be an issue. | |||
| 53 | * If we're using a synchronous name lookup mechanism (which we'd do mainly | |||
| 54 | * to support resolving addresses and host names using more mechanisms than | |||
| 55 | * just DNS, such as NIS, NBNS, or Mr. Hosts File), we could do that in | |||
| 56 | * a separate thread, making it, in effect, asynchronous. | |||
| 57 | */ | |||
| 58 | ||||
| 59 | #ifdef HAVE_NETINET_IN_H1 | |||
| 60 | # include <netinet/in.h> | |||
| 61 | #endif | |||
| 62 | ||||
| 63 | #ifdef HAVE_NETDB_H1 | |||
| 64 | #include <netdb.h> | |||
| 65 | #endif | |||
| 66 | ||||
| 67 | #ifdef HAVE_SYS_SOCKET_H1 | |||
| 68 | #include <sys/socket.h> /* needed to define AF_ values on UNIX */ | |||
| 69 | #endif | |||
| 70 | ||||
| 71 | #ifdef _WIN32 | |||
| 72 | #include <winsock2.h> /* needed to define AF_ values on Windows */ | |||
| 73 | #include <ws2tcpip.h> | |||
| 74 | #endif | |||
| 75 | ||||
| 76 | #ifdef _WIN32 | |||
| 77 | # define socklen_t unsigned int | |||
| 78 | #endif | |||
| 79 | #include <ares.h> | |||
| 80 | #include <ares_version.h> | |||
| 81 | ||||
| 82 | #include <glib.h> | |||
| 83 | ||||
| 84 | #include "packet.h" | |||
| 85 | #include "addr_resolv.h" | |||
| 86 | #include "wsutil/filesystem.h" | |||
| 87 | ||||
| 88 | #include <wsutil/report_message.h> | |||
| 89 | #include <wsutil/file_util.h> | |||
| 90 | #include <wsutil/pint.h> | |||
| 91 | #include <wsutil/inet_cidr.h> | |||
| 92 | ||||
| 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" | |||
| 99 | ||||
| 100 | #define ENAME_HOSTS"hosts" "hosts" | |||
| 101 | #define ENAME_SUBNETS"subnets" "subnets" | |||
| 102 | #define ENAME_ETHERS"ethers" "ethers" | |||
| 103 | #define ENAME_IPXNETS"ipxnets" "ipxnets" | |||
| 104 | #define ENAME_MANUF"manuf" "manuf" | |||
| 105 | #define ENAME_WKA"wka" "wka" | |||
| 106 | #define ENAME_SERVICES"services" "services" | |||
| 107 | #define ENAME_VLANS"vlans" "vlans" | |||
| 108 | #define ENAME_SS7PCS"ss7pcs" "ss7pcs" | |||
| 109 | #define ENAME_ENTERPRISES"enterprises" "enterprises" | |||
| 110 | ||||
| 111 | #define HASHETHSIZE2048 2048 | |||
| 112 | #define HASHHOSTSIZE2048 2048 | |||
| 113 | #define HASHIPXNETSIZE256 256 | |||
| 114 | #define SUBNETLENGTHSIZE32 32 /*1-32 inc.*/ | |||
| 115 | ||||
| 116 | /* hash table used for IPv4 lookup */ | |||
| 117 | ||||
| 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)) | |||
| 119 | ||||
| 120 | ||||
| 121 | typedef struct sub_net_hashipv4 { | |||
| 122 | unsigned addr; | |||
| 123 | /* XXX: No longer needed?*/ | |||
| 124 | uint8_t flags; /* B0 dummy_entry, B1 resolve, B2 If the address is used in the trace */ | |||
| 125 | struct sub_net_hashipv4 *next; | |||
| 126 | char name[MAXNAMELEN64]; | |||
| 127 | } sub_net_hashipv4_t; | |||
| 128 | ||||
| 129 | /* Array of entries of subnets of different lengths */ | |||
| 130 | typedef struct { | |||
| 131 | size_t mask_length; /*1-32*/ | |||
| 132 | uint32_t mask; /* e.g. 255.255.255.*/ | |||
| 133 | sub_net_hashipv4_t** subnet_addresses; /* Hash table of subnet addresses */ | |||
| 134 | } subnet_length_entry_t; | |||
| 135 | ||||
| 136 | ||||
| 137 | /* hash table used for IPX network lookup */ | |||
| 138 | ||||
| 139 | /* XXX - check goodness of hash function */ | |||
| 140 | ||||
| 141 | #define HASH_IPX_NET(net)((net) & (256 - 1)) ((net) & (HASHIPXNETSIZE256 - 1)) | |||
| 142 | ||||
| 143 | typedef struct hashipxnet { | |||
| 144 | unsigned addr; | |||
| 145 | struct hashipxnet *next; | |||
| 146 | char name[MAXNAMELEN64]; | |||
| 147 | } hashipxnet_t; | |||
| 148 | ||||
| 149 | typedef struct hashvlan { | |||
| 150 | unsigned id; | |||
| 151 | /* struct hashvlan *next; */ | |||
| 152 | char name[MAXVLANNAMELEN128]; | |||
| 153 | } hashvlan_t; | |||
| 154 | ||||
| 155 | typedef struct ss7pc { | |||
| 156 | uint32_t id; /* 1st byte NI, 3 following bytes: Point Code */ | |||
| 157 | char pc_addr[MAXNAMELEN64]; | |||
| 158 | char name[MAXNAMELEN64]; | |||
| 159 | } hashss7pc_t; | |||
| 160 | ||||
| 161 | /* hash tables used for ethernet and manufacturer lookup */ | |||
| 162 | struct hashether { | |||
| 163 | uint8_t flags; /* (See above) */ | |||
| 164 | uint8_t addr[6]; | |||
| 165 | char hexaddr[6*3]; | |||
| 166 | char resolved_name[MAXNAMELEN64]; | |||
| 167 | }; | |||
| 168 | ||||
| 169 | struct hasheui64 { | |||
| 170 | uint8_t flags; /* (See above) */ | |||
| 171 | uint8_t addr[EUI64_ADDR_LEN8]; | |||
| 172 | char hexaddr[EUI64_ADDR_LEN8*3]; | |||
| 173 | char resolved_name[MAXNAMELEN64]; | |||
| 174 | }; | |||
| 175 | ||||
| 176 | struct hashwka { | |||
| 177 | uint8_t flags; /* (See above) */ | |||
| 178 | char* name; | |||
| 179 | }; | |||
| 180 | ||||
| 181 | struct hashmanuf { | |||
| 182 | uint8_t flags; /* (See above) */ | |||
| 183 | uint8_t addr[3]; | |||
| 184 | char hexaddr[3*3]; | |||
| 185 | char resolved_name[MAXNAMELEN64]; | |||
| 186 | char resolved_longname[MAXNAMELEN64]; | |||
| 187 | }; | |||
| 188 | ||||
| 189 | /* internal type used when reading ethers file (or wka, manuf) */ | |||
| 190 | typedef struct _ether | |||
| 191 | { | |||
| 192 | uint8_t addr[8]; | |||
| 193 | char name[MAXNAMELEN64]; | |||
| 194 | char longname[MAXNAMELEN64]; | |||
| 195 | } ether_t; | |||
| 196 | ||||
| 197 | /* internal ipxnet type */ | |||
| 198 | typedef struct _ipxnet | |||
| 199 | { | |||
| 200 | unsigned addr; | |||
| 201 | char name[MAXNAMELEN64]; | |||
| 202 | } ipxnet_t; | |||
| 203 | ||||
| 204 | /* internal vlan type */ | |||
| 205 | typedef struct _vlan | |||
| 206 | { | |||
| 207 | unsigned id; | |||
| 208 | char name[MAXVLANNAMELEN128]; | |||
| 209 | } vlan_t; | |||
| 210 | ||||
| 211 | /* internal services custom type */ | |||
| 212 | typedef struct _serv_port_custom_key { | |||
| 213 | uint16_t port; | |||
| 214 | port_type type; | |||
| 215 | } serv_port_custom_key_t; | |||
| 216 | ||||
| 217 | static wmem_allocator_t *addr_resolv_scope; | |||
| 218 | ||||
| 219 | // Maps unsigned -> hashipxnet_t* | |||
| 220 | static wmem_map_t *ipxnet_hash_table; | |||
| 221 | static wmem_map_t *ipv4_hash_table; | |||
| 222 | static wmem_map_t *ipv6_hash_table; | |||
| 223 | // Maps unsigned -> hashvlan_t* | |||
| 224 | static wmem_map_t *vlan_hash_table; | |||
| 225 | static wmem_map_t *ss7pc_hash_table; | |||
| 226 | ||||
| 227 | // Maps IP address -> manually set hostname. | |||
| 228 | static wmem_map_t *manually_resolved_ipv4_list; | |||
| 229 | static wmem_map_t *manually_resolved_ipv6_list; | |||
| 230 | ||||
| 231 | static addrinfo_lists_t addrinfo_lists; | |||
| 232 | ||||
| 233 | struct cb_serv_data { | |||
| 234 | char *service; | |||
| 235 | port_type proto; | |||
| 236 | }; | |||
| 237 | ||||
| 238 | // Maps unsigned -> hashmanuf_t* | |||
| 239 | // XXX: Note that hashmanuf_t* only accommodates 24-bit OUIs. | |||
| 240 | // We might want to store vendor names from MA-M and MA-S to | |||
| 241 | // present in the Resolved Addresses dialog. | |||
| 242 | static wmem_map_t *manuf_hashtable; | |||
| 243 | // Maps address -> hashwka_t* | |||
| 244 | static wmem_map_t *wka_hashtable; | |||
| 245 | // Maps address -> hashether_t* | |||
| 246 | static wmem_map_t *eth_hashtable; | |||
| 247 | // Maps address -> hasheui64_t* | |||
| 248 | static wmem_map_t *eui64_hashtable; | |||
| 249 | // Maps unsigned -> serv_port_t* | |||
| 250 | static wmem_map_t *serv_port_hashtable; | |||
| 251 | static wmem_map_t *serv_port_custom_hashtable; | |||
| 252 | ||||
| 253 | // Maps enterprise-id -> enterprise-desc (only used for user additions) | |||
| 254 | static GHashTable *enterprises_hashtable; | |||
| 255 | ||||
| 256 | static subnet_length_entry_t subnet_length_entries[SUBNETLENGTHSIZE32]; /* Ordered array of entries */ | |||
| 257 | static bool_Bool have_subnet_entry; | |||
| 258 | ||||
| 259 | static bool_Bool new_resolved_objects; | |||
| 260 | ||||
| 261 | static GPtrArray* extra_hosts_files; | |||
| 262 | ||||
| 263 | static hashether_t *add_eth_name(const uint8_t *addr, const char *name, bool_Bool static_entry); | |||
| 264 | static hasheui64_t *add_eui64_name(const uint8_t *addr, const char *name, bool_Bool static_entry); | |||
| 265 | static void add_serv_port_cb(const uint32_t port, void *ptr); | |||
| 266 | ||||
| 267 | /* http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx#existing | |||
| 268 | * One-at-a-Time hash | |||
| 269 | */ | |||
| 270 | unsigned | |||
| 271 | ipv6_oat_hash(const void *key) | |||
| 272 | { | |||
| 273 | int len = 16; | |||
| 274 | const unsigned char *p = (const unsigned char *)key; | |||
| 275 | unsigned h = 0; | |||
| 276 | int i; | |||
| 277 | ||||
| 278 | for ( i = 0; i < len; i++ ) { | |||
| 279 | h += p[i]; | |||
| 280 | h += ( h << 10 ); | |||
| 281 | h ^= ( h >> 6 ); | |||
| 282 | } | |||
| 283 | ||||
| 284 | h += ( h << 3 ); | |||
| 285 | h ^= ( h >> 11 ); | |||
| 286 | h += ( h << 15 ); | |||
| 287 | ||||
| 288 | return h; | |||
| 289 | } | |||
| 290 | ||||
| 291 | gboolean | |||
| 292 | ipv6_equal(const void *v1, const void *v2) | |||
| 293 | { | |||
| 294 | ||||
| 295 | if (memcmp(v1, v2, sizeof (ws_in6_addr)) == 0) { | |||
| 296 | return true1; | |||
| 297 | } | |||
| 298 | ||||
| 299 | return false0; | |||
| 300 | } | |||
| 301 | ||||
| 302 | /* | |||
| 303 | * Flag controlling what names to resolve. | |||
| 304 | */ | |||
| 305 | e_addr_resolve gbl_resolv_flags = { | |||
| 306 | true1, /* mac_name */ | |||
| 307 | false0, /* network_name */ | |||
| 308 | false0, /* transport_name */ | |||
| 309 | true1, /* dns_pkt_addr_resolution */ | |||
| 310 | false0, /* handshake_sni_addr_resolution */ | |||
| 311 | true1, /* use_external_net_name_resolver */ | |||
| 312 | false0, /* vlan_name */ | |||
| 313 | false0, /* ss7 point code names */ | |||
| 314 | true1, /* maxmind_geoip */ | |||
| 315 | }; | |||
| 316 | ||||
| 317 | /* XXX - ares_init_options(3) says: | |||
| 318 | * "The recommended concurrent query limit is about 32k queries" | |||
| 319 | */ | |||
| 320 | static unsigned name_resolve_concurrency = 500; | |||
| 321 | static bool_Bool resolve_synchronously; | |||
| 322 | ||||
| 323 | /* | |||
| 324 | * Global variables (can be changed in GUI sections) | |||
| 325 | * XXX - they could be changed in GUI code, but there's currently no | |||
| 326 | * GUI code to change them. | |||
| 327 | */ | |||
| 328 | ||||
| 329 | char *g_ethers_path; /* global ethers file */ | |||
| 330 | char *g_pethers_path; /* personal ethers file */ | |||
| 331 | char *g_wka_path; /* global well-known-addresses file */ | |||
| 332 | char *g_manuf_path; /* global manuf file */ | |||
| 333 | char *g_pmanuf_path; /* personal manuf file */ | |||
| 334 | char *g_ipxnets_path; /* global ipxnets file */ | |||
| 335 | char *g_pipxnets_path; /* personal ipxnets file */ | |||
| 336 | char *g_services_path; /* global services file */ | |||
| 337 | char *g_pservices_path; /* personal services file */ | |||
| 338 | char *g_pvlan_path; /* personal vlans file */ | |||
| 339 | char *g_ss7pcs_path; /* personal ss7pcs file */ | |||
| 340 | char *g_enterprises_path; /* global enterprises file */ | |||
| 341 | char *g_penterprises_path; /* personal enterprises file */ | |||
| 342 | /* first resolving call */ | |||
| 343 | ||||
| 344 | /* | |||
| 345 | * Submitted asynchronous queries trigger a callback (c_ares_ghba_cb()). | |||
| 346 | * Queries are added to c_ares_queue_head. During processing, queries are | |||
| 347 | * popped off the front of c_ares_queue_head and submitted using | |||
| 348 | * ares_gethostbyaddr(). | |||
| 349 | * The callback processes the response, then frees the request. | |||
| 350 | */ | |||
| 351 | typedef struct _async_dns_queue_msg | |||
| 352 | { | |||
| 353 | union { | |||
| 354 | uint32_t ip4; | |||
| 355 | ws_in6_addr ip6; | |||
| 356 | } addr; | |||
| 357 | int family; | |||
| 358 | } async_dns_queue_msg_t; | |||
| 359 | ||||
| 360 | typedef struct _async_hostent { | |||
| 361 | int addr_size; | |||
| 362 | int copied; | |||
| 363 | void *addrp; | |||
| 364 | } async_hostent_t; | |||
| 365 | ||||
| 366 | static void | |||
| 367 | c_ares_ghba_cb(void *arg, int status, int timeouts _U___attribute__((unused)), struct hostent *he); | |||
| 368 | ||||
| 369 | /* | |||
| 370 | * Submitted synchronous queries trigger a callback (c_ares_ghba_sync_cb()). | |||
| 371 | * The callback processes the response, sets completed to true if | |||
| 372 | * completed is non-NULL, then frees the request. | |||
| 373 | */ | |||
| 374 | typedef struct _sync_dns_data | |||
| 375 | { | |||
| 376 | union { | |||
| 377 | uint32_t ip4; | |||
| 378 | ws_in6_addr ip6; | |||
| 379 | } addr; | |||
| 380 | int family; | |||
| 381 | bool_Bool *completed; | |||
| 382 | } sync_dns_data_t; | |||
| 383 | ||||
| 384 | static ares_channel ghba_chan; /* ares_gethostbyaddr -- Usually non-interactive, no timeout */ | |||
| 385 | static ares_channel ghbn_chan; /* ares_gethostbyname -- Usually interactive, timeout */ | |||
| 386 | ||||
| 387 | static bool_Bool async_dns_initialized; | |||
| 388 | static unsigned async_dns_in_flight; | |||
| 389 | static wmem_list_t *async_dns_queue_head; | |||
| 390 | static GMutex async_dns_queue_mtx; | |||
| 391 | ||||
| 392 | //UAT for providing a list of DNS servers to C-ARES for name resolution | |||
| 393 | bool_Bool use_custom_dns_server_list; | |||
| 394 | struct dns_server_data { | |||
| 395 | char *ipaddr; | |||
| 396 | uint32_t udp_port; | |||
| 397 | uint32_t tcp_port; | |||
| 398 | }; | |||
| 399 | ||||
| 400 | UAT_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; } } | |||
| 401 | UAT_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); } | |||
| 402 | UAT_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); } | |||
| 403 | ||||
| 404 | static uat_t *dnsserver_uat; | |||
| 405 | static struct dns_server_data *dnsserverlist_uats; | |||
| 406 | static unsigned ndnsservers; | |||
| 407 | ||||
| 408 | static void | |||
| 409 | dns_server_free_cb(void *data) | |||
| 410 | { | |||
| 411 | struct dns_server_data *h = (struct dns_server_data*)data; | |||
| 412 | ||||
| 413 | g_free(h->ipaddr); | |||
| 414 | } | |||
| 415 | ||||
| 416 | static void* | |||
| 417 | dns_server_copy_cb(void *dst_, const void *src_, size_t len _U___attribute__((unused))) | |||
| 418 | { | |||
| 419 | const struct dns_server_data *src = (const struct dns_server_data *)src_; | |||
| 420 | struct dns_server_data *dst = (struct dns_server_data *)dst_; | |||
| 421 | ||||
| 422 | dst->ipaddr = g_strdup(src->ipaddr)g_strdup_inline (src->ipaddr); | |||
| 423 | dst->udp_port = src->udp_port; | |||
| 424 | dst->tcp_port = src->tcp_port; | |||
| 425 | ||||
| 426 | return dst; | |||
| 427 | } | |||
| 428 | ||||
| 429 | static bool_Bool | |||
| 430 | dnsserver_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) | |||
| 431 | { | |||
| 432 | //Check for a valid IPv4 or IPv6 address. | |||
| 433 | if (ipaddr && g_hostname_is_ip_address(ipaddr)) { | |||
| 434 | *err = NULL((void*)0); | |||
| 435 | return true1; | |||
| 436 | } | |||
| 437 | ||||
| 438 | *err = ws_strdup_printf("No valid IP address given.")wmem_strdup_printf(((void*)0), "No valid IP address given."); | |||
| 439 | return false0; | |||
| 440 | } | |||
| 441 | ||||
| 442 | static bool_Bool | |||
| 443 | dnsserver_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) | |||
| 444 | { | |||
| 445 | if (!p || strlen(p) == 0u) { | |||
| 446 | // This should be removed in favor of Decode As. Make it optional. | |||
| 447 | *err = NULL((void*)0); | |||
| 448 | return true1; | |||
| 449 | } | |||
| 450 | ||||
| 451 | if (strcmp(p, "53") != 0){ | |||
| 452 | uint16_t port; | |||
| 453 | if (!ws_strtou16(p, NULL((void*)0), &port)) { | |||
| 454 | *err = g_strdup("Invalid port given.")g_strdup_inline ("Invalid port given."); | |||
| 455 | return false0; | |||
| 456 | } | |||
| 457 | } | |||
| 458 | ||||
| 459 | *err = NULL((void*)0); | |||
| 460 | return true1; | |||
| 461 | } | |||
| 462 | ||||
| 463 | static void | |||
| 464 | c_ares_ghba_sync_cb(void *arg, int status, int timeouts _U___attribute__((unused)), struct hostent *he) { | |||
| 465 | sync_dns_data_t *sdd = (sync_dns_data_t *)arg; | |||
| 466 | char **p; | |||
| 467 | ||||
| 468 | if (status == ARES_SUCCESS) { | |||
| 469 | for (p = he->h_addr_list; *p != NULL((void*)0); p++) { | |||
| 470 | switch(sdd->family) { | |||
| 471 | case AF_INET2: | |||
| 472 | add_ipv4_name(sdd->addr.ip4, he->h_name, false0); | |||
| 473 | break; | |||
| 474 | case AF_INET610: | |||
| 475 | add_ipv6_name(&sdd->addr.ip6, he->h_name, false0); | |||
| 476 | break; | |||
| 477 | default: | |||
| 478 | /* Throw an exception? */ | |||
| 479 | break; | |||
| 480 | } | |||
| 481 | } | |||
| 482 | ||||
| 483 | } | |||
| 484 | ||||
| 485 | /* | |||
| 486 | * Let our caller know that this is complete. | |||
| 487 | */ | |||
| 488 | *sdd->completed = true1; | |||
| 489 | ||||
| 490 | /* | |||
| 491 | * Free the structure for this call. | |||
| 492 | */ | |||
| 493 | g_free(sdd); | |||
| 494 | } | |||
| 495 | ||||
| 496 | static void | |||
| 497 | wait_for_sync_resolv(bool_Bool *completed) { | |||
| 498 | int nfds; | |||
| 499 | fd_set rfds, wfds; | |||
| 500 | struct timeval tv; | |||
| 501 | ||||
| 502 | while (!*completed) { | |||
| 503 | /* | |||
| 504 | * Not yet resolved; wait for something to show up on the | |||
| 505 | * address-to-name C-ARES channel. | |||
| 506 | * | |||
| 507 | * To quote the source code for ares_timeout() as of C-ARES | |||
| 508 | * 1.12.0, "WARNING: Beware that this is linear in the number | |||
| 509 | * of outstanding requests! You are probably far better off | |||
| 510 | * just calling ares_process() once per second, rather than | |||
| 511 | * calling ares_timeout() to figure out when to next call | |||
| 512 | * ares_process().", although we should have only one request | |||
| 513 | * outstanding. | |||
| 514 | * As of C-ARES 1.20.0, the ares_timeout() function is now O(1), | |||
| 515 | * but we don't require that minimum version. | |||
| 516 | * https://github.com/c-ares/c-ares/commit/cf99c025cfb3e21295b59923876a31a68ea2cb4b | |||
| 517 | * | |||
| 518 | * And, yes, we have to reset it each time, as select(), in | |||
| 519 | * some OSes modifies the timeout to reflect the time remaining | |||
| 520 | * (e.g., Linux) and select() in other OSes doesn't (most if not | |||
| 521 | * all other UN*Xes, Windows?), so we can't rely on *either* | |||
| 522 | * behavior. | |||
| 523 | */ | |||
| 524 | tv.tv_sec = 1; | |||
| 525 | tv.tv_usec = 0; | |||
| 526 | ||||
| 527 | 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); | |||
| 528 | 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); | |||
| 529 | nfds = ares_fds(ghba_chan, &rfds, &wfds); | |||
| 530 | if (nfds > 0) { | |||
| 531 | if (select(nfds, &rfds, &wfds, NULL((void*)0), &tv) == -1) { /* call to select() failed */ | |||
| 532 | /* If it's interrupted by a signal, no need to put out a message */ | |||
| 533 | if (errno(*__errno_location ()) != EINTR4) | |||
| 534 | fprintf(stderrstderr, "Warning: call to select() failed, error is %s\n", g_strerror(errno(*__errno_location ()))); | |||
| 535 | return; | |||
| 536 | } | |||
| 537 | ares_process(ghba_chan, &rfds, &wfds); | |||
| 538 | } | |||
| 539 | } | |||
| 540 | } | |||
| 541 | ||||
| 542 | static void | |||
| 543 | process_async_dns_queue(void) | |||
| 544 | { | |||
| 545 | wmem_list_frame_t* head; | |||
| 546 | async_dns_queue_msg_t *caqm; | |||
| 547 | ||||
| 548 | if (async_dns_queue_head == NULL((void*)0)) | |||
| 549 | return; | |||
| 550 | ||||
| 551 | if (!g_mutex_trylock(&async_dns_queue_mtx)) | |||
| 552 | return; | |||
| 553 | ||||
| 554 | head = wmem_list_head(async_dns_queue_head); | |||
| 555 | ||||
| 556 | while (head != NULL((void*)0) && async_dns_in_flight <= name_resolve_concurrency) { | |||
| 557 | caqm = (async_dns_queue_msg_t *)wmem_list_frame_data(head); | |||
| 558 | wmem_list_remove_frame(async_dns_queue_head, head); | |||
| 559 | if (caqm->family == AF_INET2) { | |||
| 560 | ares_gethostbyaddr(ghba_chan, &caqm->addr.ip4, sizeof(uint32_t), AF_INET2, | |||
| 561 | c_ares_ghba_cb, caqm); | |||
| 562 | async_dns_in_flight++; | |||
| 563 | } else if (caqm->family == AF_INET610) { | |||
| 564 | ares_gethostbyaddr(ghba_chan, &caqm->addr.ip6, sizeof(ws_in6_addr), | |||
| 565 | AF_INET610, c_ares_ghba_cb, caqm); | |||
| 566 | async_dns_in_flight++; | |||
| 567 | } | |||
| 568 | ||||
| 569 | head = wmem_list_head(async_dns_queue_head); | |||
| 570 | } | |||
| 571 | ||||
| 572 | g_mutex_unlock(&async_dns_queue_mtx); | |||
| 573 | } | |||
| 574 | ||||
| 575 | static void | |||
| 576 | wait_for_async_queue(void) | |||
| 577 | { | |||
| 578 | struct timeval tv = { 0, 0 }; | |||
| 579 | int nfds; | |||
| 580 | fd_set rfds, wfds; | |||
| 581 | ||||
| 582 | new_resolved_objects = false0; | |||
| 583 | ||||
| 584 | if (!async_dns_initialized) { | |||
| 585 | maxmind_db_lookup_process(); | |||
| 586 | return; | |||
| 587 | } | |||
| 588 | ||||
| 589 | while (1) { | |||
| 590 | /* We're switching to synchronous lookups, so process anything in | |||
| 591 | * the asynchronous queue. There might be more in the queue than | |||
| 592 | * name_resolve_concurrency allows, so check each cycle. | |||
| 593 | */ | |||
| 594 | process_async_dns_queue(); | |||
| 595 | ||||
| 596 | 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); | |||
| 597 | 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); | |||
| 598 | nfds = ares_fds(ghba_chan, &rfds, &wfds); | |||
| 599 | if (nfds == 0) { | |||
| 600 | /* No more requests waiting for reply; we're done here. */ | |||
| 601 | break; | |||
| 602 | } | |||
| 603 | ||||
| 604 | /* See comment in wait_for_sync_resolv() about ares_timeout() being | |||
| 605 | * O(N) in the number of outstanding requests until c-ares 1.20, and | |||
| 606 | * why we might as well just set a 1 second to select(). | |||
| 607 | */ | |||
| 608 | tv.tv_sec = 1; | |||
| 609 | tv.tv_usec = 0; | |||
| 610 | ||||
| 611 | if (select(nfds, &rfds, &wfds, NULL((void*)0), &tv) == -1) { /* call to select() failed */ | |||
| 612 | /* If it's interrupted by a signal, no need to put out a message */ | |||
| 613 | if (errno(*__errno_location ()) != EINTR4) | |||
| 614 | fprintf(stderrstderr, "Warning: call to select() failed, error is %s\n", g_strerror(errno(*__errno_location ()))); | |||
| 615 | return; | |||
| 616 | } | |||
| 617 | ares_process(ghba_chan, &rfds, &wfds); | |||
| 618 | } | |||
| 619 | ||||
| 620 | maxmind_db_lookup_process(); | |||
| 621 | return; | |||
| 622 | } | |||
| 623 | ||||
| 624 | static void | |||
| 625 | sync_lookup_ip4(const uint32_t addr) | |||
| 626 | { | |||
| 627 | bool_Bool completed = false0; | |||
| 628 | sync_dns_data_t *sdd; | |||
| 629 | ||||
| 630 | if (!async_dns_initialized) { | |||
| 631 | /* | |||
| 632 | * c-ares not initialized. Bail out. | |||
| 633 | */ | |||
| 634 | return; | |||
| 635 | } | |||
| 636 | ||||
| 637 | /* | |||
| 638 | * Start the request. | |||
| 639 | */ | |||
| 640 | sdd = g_new(sync_dns_data_t, 1)((sync_dns_data_t *) g_malloc_n ((1), sizeof (sync_dns_data_t ))); | |||
| 641 | sdd->family = AF_INET2; | |||
| 642 | sdd->addr.ip4 = addr; | |||
| 643 | sdd->completed = &completed; | |||
| 644 | ares_gethostbyaddr(ghba_chan, &addr, sizeof(uint32_t), AF_INET2, | |||
| 645 | c_ares_ghba_sync_cb, sdd); | |||
| 646 | ||||
| 647 | /* | |||
| 648 | * Now wait for it to finish. | |||
| 649 | */ | |||
| 650 | wait_for_sync_resolv(&completed); | |||
| 651 | } | |||
| 652 | ||||
| 653 | static void | |||
| 654 | sync_lookup_ip6(const ws_in6_addr *addrp) | |||
| 655 | { | |||
| 656 | bool_Bool completed = false0; | |||
| 657 | sync_dns_data_t *sdd; | |||
| 658 | ||||
| 659 | if (!async_dns_initialized) { | |||
| 660 | /* | |||
| 661 | * c-ares not initialized. Bail out. | |||
| 662 | */ | |||
| 663 | return; | |||
| 664 | } | |||
| 665 | ||||
| 666 | /* | |||
| 667 | * Start the request. | |||
| 668 | */ | |||
| 669 | sdd = g_new(sync_dns_data_t, 1)((sync_dns_data_t *) g_malloc_n ((1), sizeof (sync_dns_data_t ))); | |||
| 670 | sdd->family = AF_INET610; | |||
| 671 | memcpy(&sdd->addr.ip6, addrp, sizeof(sdd->addr.ip6)); | |||
| 672 | sdd->completed = &completed; | |||
| 673 | ares_gethostbyaddr(ghba_chan, addrp, sizeof(ws_in6_addr), AF_INET610, | |||
| 674 | c_ares_ghba_sync_cb, sdd); | |||
| 675 | ||||
| 676 | /* | |||
| 677 | * Now wait for it to finish. | |||
| 678 | */ | |||
| 679 | wait_for_sync_resolv(&completed); | |||
| 680 | } | |||
| 681 | ||||
| 682 | void | |||
| 683 | set_resolution_synchrony(bool_Bool synchronous) | |||
| 684 | { | |||
| 685 | resolve_synchronously = synchronous; | |||
| 686 | maxmind_db_set_synchrony(synchronous); | |||
| 687 | ||||
| 688 | if (synchronous) { | |||
| 689 | wait_for_async_queue(); | |||
| 690 | } | |||
| 691 | } | |||
| 692 | ||||
| 693 | static void | |||
| 694 | c_ares_set_dns_servers(void) | |||
| 695 | { | |||
| 696 | if ((!async_dns_initialized) || (!use_custom_dns_server_list)) | |||
| 697 | return; | |||
| 698 | ||||
| 699 | if (ndnsservers == 0) { | |||
| 700 | //clear the list of servers. This may effectively disable name resolution | |||
| 701 | ares_set_servers_ports(ghba_chan, NULL((void*)0)); | |||
| 702 | ares_set_servers_ports(ghbn_chan, NULL((void*)0)); | |||
| 703 | } else { | |||
| 704 | 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)))))); | |||
| 705 | ws_in4_addr ipv4addr; | |||
| 706 | ws_in6_addr ipv6addr; | |||
| 707 | bool_Bool invalid_IP_found = false0; | |||
| 708 | struct ares_addr_port_node* server; | |||
| 709 | unsigned i; | |||
| 710 | for (i = 0, server = servers; i < ndnsservers-1; i++, server++) { | |||
| 711 | if (ws_inet_pton6(dnsserverlist_uats[i].ipaddr, &ipv6addr)) { | |||
| 712 | server->family = AF_INET610; | |||
| 713 | memcpy(&server->addr.addr6, &ipv6addr, 16); | |||
| 714 | } else if (ws_inet_pton4(dnsserverlist_uats[i].ipaddr, &ipv4addr)) { | |||
| 715 | server->family = AF_INET2; | |||
| 716 | memcpy(&server->addr.addr4, &ipv4addr, 4); | |||
| 717 | } else { | |||
| 718 | //This shouldn't happen, but just in case... | |||
| 719 | invalid_IP_found = true1; | |||
| 720 | server->family = 0; | |||
| 721 | memset(&server->addr.addr4, 0, 4); | |||
| 722 | break; | |||
| 723 | } | |||
| 724 | ||||
| 725 | server->udp_port = (int)dnsserverlist_uats[i].udp_port; | |||
| 726 | server->tcp_port = (int)dnsserverlist_uats[i].tcp_port; | |||
| 727 | ||||
| 728 | server->next = (server+1); | |||
| 729 | } | |||
| 730 | if (!invalid_IP_found) { | |||
| 731 | if (ws_inet_pton6(dnsserverlist_uats[i].ipaddr, &ipv6addr)) { | |||
| 732 | server->family = AF_INET610; | |||
| 733 | memcpy(&server->addr.addr6, &ipv6addr, 16); | |||
| 734 | } | |||
| 735 | else if (ws_inet_pton4(dnsserverlist_uats[i].ipaddr, &ipv4addr)) { | |||
| 736 | server->family = AF_INET2; | |||
| 737 | memcpy(&server->addr.addr4, &ipv4addr, 4); | |||
| 738 | } else { | |||
| 739 | //This shouldn't happen, but just in case... | |||
| 740 | server->family = 0; | |||
| 741 | memset(&server->addr.addr4, 0, 4); | |||
| 742 | } | |||
| 743 | } | |||
| 744 | server->udp_port = (int)dnsserverlist_uats[i].udp_port; | |||
| 745 | server->tcp_port = (int)dnsserverlist_uats[i].tcp_port; | |||
| 746 | ||||
| 747 | server->next = NULL((void*)0); | |||
| 748 | ||||
| 749 | ares_set_servers_ports(ghba_chan, servers); | |||
| 750 | ares_set_servers_ports(ghbn_chan, servers); | |||
| 751 | wmem_free(NULL((void*)0), servers); | |||
| 752 | } | |||
| 753 | } | |||
| 754 | ||||
| 755 | typedef struct { | |||
| 756 | uint32_t mask; | |||
| 757 | size_t mask_length; | |||
| 758 | const char* name; /* Shallow copy */ | |||
| 759 | } subnet_entry_t; | |||
| 760 | ||||
| 761 | /* Maximum supported line length of hosts, services, manuf, etc. */ | |||
| 762 | #define MAX_LINELEN1024 1024 | |||
| 763 | ||||
| 764 | /** Read a line without trailing (CR)LF. Returns -1 on failure. */ | |||
| 765 | static int | |||
| 766 | fgetline(char *buf, int size, FILE *fp) | |||
| 767 | { | |||
| 768 | if (fgets(buf, size, fp)) { | |||
| 769 | int len = (int)strcspn(buf, "\r\n"); | |||
| 770 | buf[len] = '\0'; | |||
| 771 | return len; | |||
| 772 | } | |||
| 773 | return -1; | |||
| 774 | ||||
| 775 | } /* fgetline */ | |||
| 776 | ||||
| 777 | ||||
| 778 | /* | |||
| 779 | * Local function definitions | |||
| 780 | */ | |||
| 781 | static subnet_entry_t subnet_lookup(const uint32_t addr); | |||
| 782 | static void subnet_entry_set(uint32_t subnet_addr, const uint8_t mask_length, const char* name); | |||
| 783 | ||||
| 784 | static unsigned serv_port_custom_hash(const void *k) | |||
| 785 | { | |||
| 786 | const serv_port_custom_key_t *key = (const serv_port_custom_key_t*)k; | |||
| 787 | return key->port + (key->type << 16); | |||
| 788 | } | |||
| 789 | ||||
| 790 | static gboolean serv_port_custom_equal(const void *k1, const void *k2) | |||
| 791 | { | |||
| 792 | const serv_port_custom_key_t *key1 = (const serv_port_custom_key_t*)k1; | |||
| 793 | const serv_port_custom_key_t *key2 = (const serv_port_custom_key_t*)k2; | |||
| 794 | ||||
| 795 | return (key1->port == key2->port) && (key1->type == key2->type); | |||
| 796 | } | |||
| 797 | ||||
| 798 | static void | |||
| 799 | add_custom_service_name(port_type proto, const unsigned port, const char *service_name) | |||
| 800 | { | |||
| 801 | char *name; | |||
| 802 | serv_port_custom_key_t *key, *orig_key; | |||
| 803 | ||||
| 804 | key = wmem_new(addr_resolv_scope, serv_port_custom_key_t)((serv_port_custom_key_t*)wmem_alloc((addr_resolv_scope), sizeof (serv_port_custom_key_t))); | |||
| 805 | key->port = (uint16_t)port; | |||
| 806 | key->type = proto; | |||
| 807 | ||||
| 808 | if (wmem_map_lookup_extended(serv_port_custom_hashtable, key, (const void**)&orig_key, (void**)&name)) { | |||
| 809 | wmem_free(addr_resolv_scope, orig_key); | |||
| 810 | wmem_free(addr_resolv_scope, name); | |||
| 811 | } | |||
| 812 | ||||
| 813 | name = wmem_strdup(addr_resolv_scope, service_name); | |||
| 814 | wmem_map_insert(serv_port_custom_hashtable, key, name); | |||
| 815 | ||||
| 816 | // A new custom entry is not a new resolved object. | |||
| 817 | // new_resolved_objects = true; | |||
| 818 | } | |||
| 819 | ||||
| 820 | static serv_port_t* | |||
| 821 | add_service_name(port_type proto, const unsigned port, const char *service_name) | |||
| 822 | { | |||
| 823 | serv_port_t *serv_port_names; | |||
| 824 | ||||
| 825 | serv_port_names = (serv_port_t *)wmem_map_lookup(serv_port_hashtable, GUINT_TO_POINTER(port)((gpointer) (gulong) (port))); | |||
| 826 | if (serv_port_names == NULL((void*)0)) { | |||
| 827 | serv_port_names = wmem_new0(addr_resolv_scope, serv_port_t)((serv_port_t*)wmem_alloc0((addr_resolv_scope), sizeof(serv_port_t ))); | |||
| 828 | wmem_map_insert(serv_port_hashtable, GUINT_TO_POINTER(port)((gpointer) (gulong) (port)), serv_port_names); | |||
| 829 | } | |||
| 830 | ||||
| 831 | /* We don't need to strdup because service_name is owned by either | |||
| 832 | * the global arrays or the custom table, which manage the memory | |||
| 833 | * and have lifespans at least as long as the addr_resolv_scope. | |||
| 834 | */ | |||
| 835 | switch(proto) { | |||
| 836 | case PT_TCP: | |||
| 837 | serv_port_names->tcp_name = service_name; | |||
| 838 | break; | |||
| 839 | case PT_UDP: | |||
| 840 | serv_port_names->udp_name = service_name; | |||
| 841 | break; | |||
| 842 | case PT_SCTP: | |||
| 843 | serv_port_names->sctp_name = service_name; | |||
| 844 | break; | |||
| 845 | case PT_DCCP: | |||
| 846 | serv_port_names->dccp_name = service_name; | |||
| 847 | break; | |||
| 848 | default: | |||
| 849 | return serv_port_names; | |||
| 850 | /* Should not happen */ | |||
| 851 | } | |||
| 852 | ||||
| 853 | new_resolved_objects = true1; | |||
| 854 | return serv_port_names; | |||
| 855 | } | |||
| 856 | ||||
| 857 | static void | |||
| 858 | parse_service_line (char *line) | |||
| 859 | { | |||
| 860 | char *cp; | |||
| 861 | char *service; | |||
| 862 | char *port; | |||
| 863 | port_type proto; | |||
| 864 | struct cb_serv_data cb_data; | |||
| 865 | range_t *port_rng = NULL((void*)0); | |||
| 866 | ||||
| 867 | if ((cp = strchr(line, '#'))) | |||
| 868 | *cp = '\0'; | |||
| 869 | ||||
| 870 | if ((cp = strtok(line, " \t")) == NULL((void*)0)) | |||
| 871 | return; | |||
| 872 | ||||
| 873 | service = cp; | |||
| 874 | ||||
| 875 | if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0)) | |||
| 876 | return; | |||
| 877 | ||||
| 878 | port = cp; | |||
| 879 | ||||
| 880 | if (strtok(cp, "/") == NULL((void*)0)) | |||
| 881 | return; | |||
| 882 | ||||
| 883 | if (range_convert_str(NULL((void*)0), &port_rng, port, UINT16_MAX(65535)) != CVT_NO_ERROR) { | |||
| 884 | wmem_free (NULL((void*)0), port_rng); | |||
| 885 | return; | |||
| 886 | } | |||
| 887 | ||||
| 888 | while ((cp = strtok(NULL((void*)0), "/")) != NULL((void*)0)) { | |||
| 889 | if (strcmp(cp, "tcp") == 0) { | |||
| 890 | proto = PT_TCP; | |||
| 891 | } | |||
| 892 | else if (strcmp(cp, "udp") == 0) { | |||
| 893 | proto = PT_UDP; | |||
| 894 | } | |||
| 895 | else if (strcmp(cp, "sctp") == 0) { | |||
| 896 | proto = PT_SCTP; | |||
| 897 | } | |||
| 898 | else if (strcmp(cp, "dccp") == 0) { | |||
| 899 | proto = PT_DCCP; | |||
| 900 | } | |||
| 901 | else { | |||
| 902 | break; | |||
| 903 | } | |||
| 904 | cb_data.service = service; | |||
| 905 | cb_data.proto = proto; | |||
| 906 | range_foreach(port_rng, add_serv_port_cb, &cb_data); | |||
| 907 | } | |||
| 908 | ||||
| 909 | wmem_free (NULL((void*)0), port_rng); | |||
| 910 | } /* parse_service_line */ | |||
| 911 | ||||
| 912 | ||||
| 913 | static void | |||
| 914 | add_serv_port_cb(const uint32_t port, void *ptr) | |||
| 915 | { | |||
| 916 | struct cb_serv_data *cb_data = (struct cb_serv_data *)ptr; | |||
| 917 | ||||
| 918 | if ( port ) { | |||
| 919 | add_custom_service_name(cb_data->proto, port, cb_data->service); | |||
| 920 | } | |||
| 921 | } | |||
| 922 | ||||
| 923 | ||||
| 924 | static bool_Bool | |||
| 925 | parse_services_file(const char * path) | |||
| 926 | { | |||
| 927 | FILE *serv_p; | |||
| 928 | char buf[MAX_LINELEN1024]; | |||
| 929 | ||||
| 930 | /* services hash table initialization */ | |||
| 931 | serv_p = ws_fopenfopen(path, "r"); | |||
| 932 | ||||
| 933 | if (serv_p == NULL((void*)0)) | |||
| 934 | return false0; | |||
| 935 | ||||
| 936 | while (fgetline(buf, sizeof(buf), serv_p) >= 0) { | |||
| 937 | parse_service_line(buf); | |||
| 938 | } | |||
| 939 | ||||
| 940 | fclose(serv_p); | |||
| 941 | return true1; | |||
| 942 | } | |||
| 943 | ||||
| 944 | /* ----------------- | |||
| 945 | * unsigned integer to ascii | |||
| 946 | */ | |||
| 947 | static char * | |||
| 948 | wmem_utoa(wmem_allocator_t *allocator, unsigned port) | |||
| 949 | { | |||
| 950 | char *bp = (char *)wmem_alloc(allocator, MAXNAMELEN64); | |||
| 951 | ||||
| 952 | /* XXX, uint32_to_str() ? */ | |||
| 953 | uint32_to_str_buf(port, bp, MAXNAMELEN64); | |||
| 954 | return bp; | |||
| 955 | } | |||
| 956 | ||||
| 957 | static const char * | |||
| 958 | _serv_name_lookup(port_type proto, unsigned port, serv_port_t **value_ret) | |||
| 959 | { | |||
| 960 | serv_port_t *serv_port_names; | |||
| 961 | const char* name = NULL((void*)0); | |||
| 962 | ws_services_proto_t p; | |||
| 963 | ws_services_entry_t const *serv; | |||
| 964 | ||||
| 965 | /* Look in the cache */ | |||
| 966 | serv_port_names = (serv_port_t *)wmem_map_lookup(serv_port_hashtable, GUINT_TO_POINTER(port)((gpointer) (gulong) (port))); | |||
| 967 | ||||
| 968 | if (serv_port_names == NULL((void*)0)) { | |||
| 969 | /* Try the user custom table */ | |||
| 970 | serv_port_custom_key_t custom_key = { (uint16_t)port, proto }; | |||
| 971 | name = wmem_map_lookup(serv_port_custom_hashtable, &custom_key); | |||
| 972 | } | |||
| 973 | ||||
| 974 | if (name == NULL((void*)0) && serv_port_names == NULL((void*)0)) { | |||
| 975 | /* now look in the global tables */ | |||
| 976 | bool_Bool valid_proto = true1; | |||
| 977 | switch(proto) { | |||
| 978 | case PT_TCP: p = ws_tcp; break; | |||
| 979 | case PT_UDP: p = ws_udp; break; | |||
| 980 | case PT_SCTP: p = ws_sctp; break; | |||
| 981 | case PT_DCCP: p = ws_dccp; break; | |||
| 982 | default: valid_proto = false0; | |||
| 983 | } | |||
| 984 | if (valid_proto) { | |||
| 985 | serv = global_services_lookup(port, p); | |||
| 986 | if (serv) { | |||
| 987 | name = serv->name; | |||
| 988 | } | |||
| 989 | } | |||
| 990 | } | |||
| 991 | ||||
| 992 | if (name) { | |||
| 993 | /* Cache result */ | |||
| 994 | serv_port_names = add_service_name(proto, port, name); | |||
| 995 | } | |||
| 996 | ||||
| 997 | if (value_ret != NULL((void*)0)) | |||
| 998 | *value_ret = serv_port_names; | |||
| 999 | ||||
| 1000 | if (serv_port_names == NULL((void*)0)) | |||
| 1001 | return NULL((void*)0); | |||
| 1002 | ||||
| 1003 | switch (proto) { | |||
| 1004 | case PT_UDP: | |||
| 1005 | return serv_port_names->udp_name; | |||
| 1006 | case PT_TCP: | |||
| 1007 | return serv_port_names->tcp_name; | |||
| 1008 | case PT_SCTP: | |||
| 1009 | return serv_port_names->sctp_name; | |||
| 1010 | case PT_DCCP: | |||
| 1011 | return serv_port_names->dccp_name; | |||
| 1012 | default: | |||
| 1013 | break; | |||
| 1014 | } | |||
| 1015 | return NULL((void*)0); | |||
| 1016 | } | |||
| 1017 | ||||
| 1018 | const char * | |||
| 1019 | try_serv_name_lookup(port_type proto, unsigned port) | |||
| 1020 | { | |||
| 1021 | return (proto == PT_NONE) ? NULL((void*)0) : _serv_name_lookup(proto, port, NULL((void*)0)); | |||
| 1022 | } | |||
| 1023 | ||||
| 1024 | const char * | |||
| 1025 | serv_name_lookup(port_type proto, unsigned port) | |||
| 1026 | { | |||
| 1027 | serv_port_t *serv_port_names = NULL((void*)0); | |||
| 1028 | const char *name; | |||
| 1029 | ||||
| 1030 | /* first look for the name */ | |||
| 1031 | name = _serv_name_lookup(proto, port, &serv_port_names); | |||
| 1032 | if (name != NULL((void*)0)) | |||
| 1033 | return name; | |||
| 1034 | ||||
| 1035 | if (serv_port_names == NULL((void*)0)) { | |||
| 1036 | serv_port_names = wmem_new0(addr_resolv_scope, serv_port_t)((serv_port_t*)wmem_alloc0((addr_resolv_scope), sizeof(serv_port_t ))); | |||
| 1037 | wmem_map_insert(serv_port_hashtable, GUINT_TO_POINTER(port)((gpointer) (gulong) (port)), serv_port_names); | |||
| 1038 | } | |||
| 1039 | ||||
| 1040 | /* No name; create the numeric string. */ | |||
| 1041 | if (serv_port_names->numeric == NULL((void*)0)) { | |||
| 1042 | serv_port_names->numeric = wmem_strdup_printf(addr_resolv_scope, "%u", port); | |||
| 1043 | } | |||
| 1044 | ||||
| 1045 | return serv_port_names->numeric; | |||
| 1046 | } | |||
| 1047 | ||||
| 1048 | static void | |||
| 1049 | initialize_services(void) | |||
| 1050 | { | |||
| 1051 | 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", 1051, __func__, "assertion failed: %s", "serv_port_hashtable == ((void*)0)" ); } while (0); | |||
| 1052 | serv_port_hashtable = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal); | |||
| 1053 | 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" , 1053, __func__, "assertion failed: %s", "serv_port_custom_hashtable == ((void*)0)" ); } while (0); | |||
| 1054 | serv_port_custom_hashtable = wmem_map_new(addr_resolv_scope, serv_port_custom_hash, serv_port_custom_equal); | |||
| 1055 | ||||
| 1056 | /* Compute the pathname of the global services file. */ | |||
| 1057 | if (g_services_path == NULL((void*)0)) { | |||
| 1058 | g_services_path = get_datafile_path(ENAME_SERVICES"services"); | |||
| 1059 | } | |||
| 1060 | parse_services_file(g_services_path); | |||
| 1061 | ||||
| 1062 | /* Compute the pathname of the personal services file */ | |||
| 1063 | if (g_pservices_path == NULL((void*)0)) { | |||
| 1064 | /* Check profile directory before personal configuration */ | |||
| 1065 | g_pservices_path = get_persconffile_path(ENAME_SERVICES"services", true1); | |||
| 1066 | if (!parse_services_file(g_pservices_path)) { | |||
| 1067 | g_free(g_pservices_path); | |||
| 1068 | g_pservices_path = get_persconffile_path(ENAME_SERVICES"services", false0); | |||
| 1069 | parse_services_file(g_pservices_path); | |||
| 1070 | } | |||
| 1071 | } | |||
| 1072 | } | |||
| 1073 | ||||
| 1074 | static void | |||
| 1075 | service_name_lookup_cleanup(void) | |||
| 1076 | { | |||
| 1077 | serv_port_hashtable = NULL((void*)0); | |||
| 1078 | serv_port_custom_hashtable = NULL((void*)0); | |||
| 1079 | g_free(g_services_path); | |||
| 1080 | g_services_path = NULL((void*)0); | |||
| 1081 | g_free(g_pservices_path); | |||
| 1082 | g_pservices_path = NULL((void*)0); | |||
| 1083 | } | |||
| 1084 | ||||
| 1085 | static void | |||
| 1086 | parse_enterprises_line (char *line) | |||
| 1087 | { | |||
| 1088 | char *tok, *dec_str, *org_str; | |||
| 1089 | uint32_t dec; | |||
| 1090 | bool_Bool had_comment = false0; | |||
| 1091 | ||||
| 1092 | /* Stop the line at any comment found */ | |||
| 1093 | if ((tok = strchr(line, '#'))) { | |||
| 1094 | *tok = '\0'; | |||
| 1095 | had_comment = true1; | |||
| 1096 | } | |||
| 1097 | /* Get enterprise number */ | |||
| 1098 | dec_str = strtok(line, " \t"); | |||
| 1099 | if (!dec_str) | |||
| 1100 | return; | |||
| 1101 | /* Get enterprise name */ | |||
| 1102 | org_str = strtok(NULL((void*)0), ""); /* everything else */ | |||
| 1103 | if (org_str && had_comment) { | |||
| 1104 | /* Only need to strip after (between name and where comment was) */ | |||
| 1105 | org_str = g_strchomp(org_str); | |||
| 1106 | } | |||
| 1107 | if (!org_str) | |||
| 1108 | return; | |||
| 1109 | ||||
| 1110 | /* Add entry using number as key */ | |||
| 1111 | if (!ws_strtou32(dec_str, NULL((void*)0), &dec)) | |||
| 1112 | return; | |||
| 1113 | g_hash_table_insert(enterprises_hashtable, GUINT_TO_POINTER(dec)((gpointer) (gulong) (dec)), g_strdup(org_str)g_strdup_inline (org_str)); | |||
| 1114 | } | |||
| 1115 | ||||
| 1116 | ||||
| 1117 | static bool_Bool | |||
| 1118 | parse_enterprises_file(const char * path) | |||
| 1119 | { | |||
| 1120 | FILE *fp; | |||
| 1121 | char buf[MAX_LINELEN1024]; | |||
| 1122 | ||||
| 1123 | fp = ws_fopenfopen(path, "r"); | |||
| 1124 | if (fp == NULL((void*)0)) | |||
| 1125 | return false0; | |||
| 1126 | ||||
| 1127 | while (fgetline(buf, sizeof(buf), fp) >= 0) { | |||
| 1128 | parse_enterprises_line(buf); | |||
| 1129 | } | |||
| 1130 | ||||
| 1131 | fclose(fp); | |||
| 1132 | return true1; | |||
| 1133 | } | |||
| 1134 | ||||
| 1135 | static void | |||
| 1136 | initialize_enterprises(void) | |||
| 1137 | { | |||
| 1138 | ws_assert(enterprises_hashtable == NULL)do { if ((1) && !(enterprises_hashtable == ((void*)0) )) ws_log_fatal_full("", LOG_LEVEL_ERROR, "epan/addr_resolv.c" , 1138, __func__, "assertion failed: %s", "enterprises_hashtable == ((void*)0)" ); } while (0); | |||
| 1139 | enterprises_hashtable = g_hash_table_new_full(NULL((void*)0), NULL((void*)0), NULL((void*)0), g_free); | |||
| 1140 | ||||
| 1141 | if (g_enterprises_path == NULL((void*)0)) { | |||
| 1142 | g_enterprises_path = get_datafile_path(ENAME_ENTERPRISES"enterprises"); | |||
| 1143 | } | |||
| 1144 | parse_enterprises_file(g_enterprises_path); | |||
| 1145 | ||||
| 1146 | /* Populate entries from profile or personal */ | |||
| 1147 | if (g_penterprises_path == NULL((void*)0)) { | |||
| 1148 | /* Check profile directory before personal configuration */ | |||
| 1149 | g_penterprises_path = get_persconffile_path(ENAME_ENTERPRISES"enterprises", true1); | |||
| 1150 | if (!file_exists(g_penterprises_path)) { | |||
| 1151 | g_free(g_penterprises_path); | |||
| 1152 | g_penterprises_path = get_persconffile_path(ENAME_ENTERPRISES"enterprises", false0); | |||
| 1153 | } | |||
| 1154 | } | |||
| 1155 | /* Parse personal file (if present) */ | |||
| 1156 | parse_enterprises_file(g_penterprises_path); | |||
| 1157 | } | |||
| 1158 | ||||
| 1159 | const char * | |||
| 1160 | try_enterprises_lookup(uint32_t value) | |||
| 1161 | { | |||
| 1162 | /* Trying extra entries first. N.B. This does allow entries to be overwritten and found.. */ | |||
| 1163 | const char *name = (const char *)g_hash_table_lookup(enterprises_hashtable, GUINT_TO_POINTER(value)((gpointer) (gulong) (value))); | |||
| 1164 | if (name) { | |||
| 1165 | return name; | |||
| 1166 | } | |||
| 1167 | else { | |||
| 1168 | return global_enterprises_lookup(value); | |||
| 1169 | } | |||
| 1170 | } | |||
| 1171 | ||||
| 1172 | const char * | |||
| 1173 | enterprises_lookup(uint32_t value, const char *unknown_str) | |||
| 1174 | { | |||
| 1175 | const char *s; | |||
| 1176 | ||||
| 1177 | s = try_enterprises_lookup(value); | |||
| 1178 | if (s != NULL((void*)0)) | |||
| 1179 | return s; | |||
| 1180 | if (unknown_str != NULL((void*)0)) | |||
| 1181 | return unknown_str; | |||
| 1182 | return "<Unknown>"; | |||
| 1183 | } | |||
| 1184 | ||||
| 1185 | void | |||
| 1186 | enterprises_base_custom(char *buf, uint32_t value) | |||
| 1187 | { | |||
| 1188 | const char *s; | |||
| 1189 | ||||
| 1190 | if ((s = try_enterprises_lookup(value)) == NULL((void*)0)) | |||
| 1191 | s = ITEM_LABEL_UNKNOWN_STR"Unknown"; | |||
| 1192 | snprintf(buf, ITEM_LABEL_LENGTH240, "%s (%u)", s, value); | |||
| 1193 | } | |||
| 1194 | ||||
| 1195 | static void | |||
| 1196 | enterprises_cleanup(void) | |||
| 1197 | { | |||
| 1198 | ws_assert(enterprises_hashtable)do { if ((1) && !(enterprises_hashtable)) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 1198, __func__, "assertion failed: %s" , "enterprises_hashtable"); } while (0); | |||
| 1199 | g_hash_table_destroy(enterprises_hashtable); | |||
| 1200 | enterprises_hashtable = NULL((void*)0); | |||
| 1201 | g_free(g_enterprises_path); | |||
| 1202 | g_enterprises_path = NULL((void*)0); | |||
| 1203 | g_free(g_penterprises_path); | |||
| 1204 | g_penterprises_path = NULL((void*)0); | |||
| 1205 | } | |||
| 1206 | ||||
| 1207 | /* Fill in an IP4 structure with info from subnets file or just with the | |||
| 1208 | * string form of the address. | |||
| 1209 | */ | |||
| 1210 | bool_Bool | |||
| 1211 | fill_dummy_ip4(const unsigned addr, hashipv4_t* volatile tp) | |||
| 1212 | { | |||
| 1213 | subnet_entry_t subnet_entry; | |||
| 1214 | ||||
| 1215 | /* return value : true if addr matches any subnet */ | |||
| 1216 | bool_Bool cidr_covered = false0; | |||
| 1217 | ||||
| 1218 | /* Overwrite if we get async DNS reply */ | |||
| 1219 | ||||
| 1220 | /* Do we have a subnet for this address? */ | |||
| 1221 | subnet_entry = subnet_lookup(addr); | |||
| 1222 | if (0 != subnet_entry.mask) { | |||
| 1223 | /* Print name, then '.' then IP address after subnet mask */ | |||
| 1224 | uint32_t host_addr; | |||
| 1225 | char buffer[WS_INET_ADDRSTRLEN16]; | |||
| 1226 | char* paddr; | |||
| 1227 | size_t i; | |||
| 1228 | ||||
| 1229 | host_addr = addr & (~subnet_entry.mask); | |||
| 1230 | ip_addr_to_str_buf(&host_addr, buffer, WS_INET_ADDRSTRLEN16); | |||
| 1231 | paddr = buffer; | |||
| 1232 | ||||
| 1233 | /* Skip to first octet that is not totally masked | |||
| 1234 | * If length of mask is 32, we chomp the whole address. | |||
| 1235 | * If the address string starts '.' (should not happen?), | |||
| 1236 | * we skip that '.'. | |||
| 1237 | */ | |||
| 1238 | i = subnet_entry.mask_length / 8; | |||
| 1239 | while(*(paddr) != '\0' && i > 0) { | |||
| 1240 | if (*(++paddr) == '.') { | |||
| 1241 | --i; | |||
| 1242 | } | |||
| 1243 | } | |||
| 1244 | ||||
| 1245 | /* There are more efficient ways to do this, but this is safe if we | |||
| 1246 | * trust snprintf and MAXDNSNAMELEN | |||
| 1247 | */ | |||
| 1248 | snprintf(tp->name, MAXDNSNAMELEN256, "%s%s", subnet_entry.name, paddr); | |||
| 1249 | ||||
| 1250 | /* Evaluate the subnet in CIDR notation | |||
| 1251 | * Reuse buffers built above | |||
| 1252 | */ | |||
| 1253 | uint32_t subnet_addr; | |||
| 1254 | subnet_addr = addr & subnet_entry.mask; | |||
| 1255 | ||||
| 1256 | char buffer_subnet[WS_INET_ADDRSTRLEN16]; | |||
| 1257 | ip_addr_to_str_buf(&subnet_addr, buffer_subnet, WS_INET_ADDRSTRLEN16); | |||
| 1258 | ||||
| 1259 | char buffer_cidr[WS_INET_CIDRADDRSTRLEN19]; | |||
| 1260 | snprintf(buffer_cidr, WS_INET_CIDRADDRSTRLEN19, "%s%s%u", buffer_subnet, "/", (unsigned)subnet_entry.mask_length); | |||
| 1261 | ||||
| 1262 | snprintf(tp->cidr_addr, WS_INET_CIDRADDRSTRLEN19, "%s%s%u", buffer_subnet, "/", (unsigned)subnet_entry.mask_length); | |||
| 1263 | cidr_covered = true1; | |||
| 1264 | } else { | |||
| 1265 | /* XXX: This means we end up printing "1.2.3.4 (1.2.3.4)" in many cases */ | |||
| 1266 | ip_addr_to_str_buf(&addr, tp->name, MAXDNSNAMELEN256); | |||
| 1267 | ||||
| 1268 | /* IP does not belong to any known subnet, just indicate this IP without "/.32" */ | |||
| 1269 | ip_addr_to_str_buf(&addr, tp->cidr_addr, MAXDNSNAMELEN256); | |||
| 1270 | } | |||
| 1271 | return cidr_covered; | |||
| 1272 | } | |||
| 1273 | ||||
| 1274 | ||||
| 1275 | /* Fill in an IP6 structure with the string form of the address. | |||
| 1276 | */ | |||
| 1277 | static void | |||
| 1278 | fill_dummy_ip6(hashipv6_t* volatile tp) | |||
| 1279 | { | |||
| 1280 | /* Overwrite if we get async DNS reply */ | |||
| 1281 | (void) g_strlcpy(tp->name, tp->ip6, MAXDNSNAMELEN256); | |||
| 1282 | } | |||
| 1283 | ||||
| 1284 | static void | |||
| 1285 | c_ares_ghba_cb(void *arg, int status, int timeouts _U___attribute__((unused)), struct hostent *he) { | |||
| 1286 | async_dns_queue_msg_t *caqm = (async_dns_queue_msg_t *)arg; | |||
| 1287 | char **p; | |||
| 1288 | ||||
| 1289 | if (!caqm) return; | |||
| 1290 | /* XXX, what to do if async_dns_in_flight == 0? */ | |||
| 1291 | async_dns_in_flight--; | |||
| 1292 | ||||
| 1293 | if (status == ARES_SUCCESS) { | |||
| 1294 | for (p = he->h_addr_list; *p != NULL((void*)0); p++) { | |||
| 1295 | switch(caqm->family) { | |||
| 1296 | case AF_INET2: | |||
| 1297 | add_ipv4_name(caqm->addr.ip4, he->h_name, false0); | |||
| 1298 | break; | |||
| 1299 | case AF_INET610: | |||
| 1300 | add_ipv6_name(&caqm->addr.ip6, he->h_name, false0); | |||
| 1301 | break; | |||
| 1302 | default: | |||
| 1303 | /* Throw an exception? */ | |||
| 1304 | break; | |||
| 1305 | } | |||
| 1306 | } | |||
| 1307 | } | |||
| 1308 | wmem_free(addr_resolv_scope, caqm); | |||
| 1309 | } | |||
| 1310 | ||||
| 1311 | /* --------------- */ | |||
| 1312 | hashipv4_t * | |||
| 1313 | new_ipv4(const unsigned addr) | |||
| 1314 | { | |||
| 1315 | hashipv4_t *tp = wmem_new(addr_resolv_scope, hashipv4_t)((hashipv4_t*)wmem_alloc((addr_resolv_scope), sizeof(hashipv4_t ))); | |||
| 1316 | tp->addr = addr; | |||
| 1317 | tp->flags = 0; | |||
| 1318 | tp->name[0] = '\0'; | |||
| 1319 | ip_addr_to_str_buf(&addr, tp->ip, sizeof(tp->ip)); | |||
| 1320 | return tp; | |||
| 1321 | } | |||
| 1322 | ||||
| 1323 | static hashipv4_t * | |||
| 1324 | host_lookup(const unsigned addr) | |||
| 1325 | { | |||
| 1326 | hashipv4_t * volatile tp; | |||
| 1327 | ||||
| 1328 | tp = (hashipv4_t *)wmem_map_lookup(ipv4_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr))); | |||
| 1329 | if (tp == NULL((void*)0)) { | |||
| 1330 | /* | |||
| 1331 | * We don't already have an entry for this host name; create one, | |||
| 1332 | * and then try to resolve it. | |||
| 1333 | */ | |||
| 1334 | tp = new_ipv4(addr); | |||
| 1335 | fill_dummy_ip4(addr, tp); | |||
| 1336 | wmem_map_insert(ipv4_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr)), tp); | |||
| 1337 | } else if (tp->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) { | |||
| 1338 | return tp; | |||
| 1339 | } | |||
| 1340 | ||||
| 1341 | /* | |||
| 1342 | * This hasn't been resolved yet, and we haven't tried to | |||
| 1343 | * resolve it already. | |||
| 1344 | */ | |||
| 1345 | ||||
| 1346 | if (!gbl_resolv_flags.network_name) | |||
| 1347 | return tp; | |||
| 1348 | ||||
| 1349 | if (gbl_resolv_flags.use_external_net_name_resolver) { | |||
| 1350 | tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0); | |||
| 1351 | ||||
| 1352 | if (async_dns_initialized) { | |||
| 1353 | /* c-ares is initialized, so we can use it */ | |||
| 1354 | if (resolve_synchronously || name_resolve_concurrency == 0) { | |||
| 1355 | /* | |||
| 1356 | * Either all names are to be resolved synchronously or | |||
| 1357 | * the concurrencly level is 0; do the resolution | |||
| 1358 | * synchronously. | |||
| 1359 | */ | |||
| 1360 | sync_lookup_ip4(addr); | |||
| 1361 | } else { | |||
| 1362 | /* | |||
| 1363 | * Names are to be resolved asynchronously, and we | |||
| 1364 | * allow at least one asynchronous request in flight; | |||
| 1365 | * post an asynchronous request. | |||
| 1366 | */ | |||
| 1367 | async_dns_queue_msg_t *caqm; | |||
| 1368 | ||||
| 1369 | 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))); | |||
| 1370 | caqm->family = AF_INET2; | |||
| 1371 | caqm->addr.ip4 = addr; | |||
| 1372 | wmem_list_append(async_dns_queue_head, (void *) caqm); | |||
| 1373 | } | |||
| 1374 | } | |||
| 1375 | } | |||
| 1376 | ||||
| 1377 | return tp; | |||
| 1378 | ||||
| 1379 | } /* host_lookup */ | |||
| 1380 | ||||
| 1381 | /* --------------- */ | |||
| 1382 | static hashipv6_t * | |||
| 1383 | new_ipv6(const ws_in6_addr *addr) | |||
| 1384 | { | |||
| 1385 | hashipv6_t *tp = wmem_new(addr_resolv_scope, hashipv6_t)((hashipv6_t*)wmem_alloc((addr_resolv_scope), sizeof(hashipv6_t ))); | |||
| 1386 | memcpy(tp->addr, addr->bytes, sizeof tp->addr); | |||
| 1387 | tp->flags = 0; | |||
| 1388 | tp->name[0] = '\0'; | |||
| 1389 | ip6_to_str_buf(addr, tp->ip6, sizeof(tp->ip6)); | |||
| 1390 | return tp; | |||
| 1391 | } | |||
| 1392 | ||||
| 1393 | /* ------------------------------------ */ | |||
| 1394 | static hashipv6_t * | |||
| 1395 | host_lookup6(const ws_in6_addr *addr) | |||
| 1396 | { | |||
| 1397 | hashipv6_t * volatile tp; | |||
| 1398 | ||||
| 1399 | tp = (hashipv6_t *)wmem_map_lookup(ipv6_hash_table, addr); | |||
| 1400 | if (tp == NULL((void*)0)) { | |||
| 1401 | /* | |||
| 1402 | * We don't already have an entry for this host name; create one, | |||
| 1403 | * and then try to resolve it. | |||
| 1404 | */ | |||
| 1405 | ws_in6_addr *addr_key; | |||
| 1406 | ||||
| 1407 | addr_key = wmem_new(addr_resolv_scope, ws_in6_addr)((ws_in6_addr*)wmem_alloc((addr_resolv_scope), sizeof(ws_in6_addr ))); | |||
| 1408 | tp = new_ipv6(addr); | |||
| 1409 | memcpy(addr_key, addr, 16); | |||
| 1410 | fill_dummy_ip6(tp); | |||
| 1411 | wmem_map_insert(ipv6_hash_table, addr_key, tp); | |||
| 1412 | } else if (tp->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) { | |||
| 1413 | return tp; | |||
| 1414 | } | |||
| 1415 | ||||
| 1416 | /* | |||
| 1417 | * This hasn't been resolved yet, and we haven't tried to | |||
| 1418 | * resolve it already. | |||
| 1419 | */ | |||
| 1420 | ||||
| 1421 | if (!gbl_resolv_flags.network_name) | |||
| 1422 | return tp; | |||
| 1423 | ||||
| 1424 | if (gbl_resolv_flags.use_external_net_name_resolver) { | |||
| 1425 | tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0); | |||
| 1426 | ||||
| 1427 | if (async_dns_initialized) { | |||
| 1428 | /* c-ares is initialized, so we can use it */ | |||
| 1429 | if (resolve_synchronously || name_resolve_concurrency == 0) { | |||
| 1430 | /* | |||
| 1431 | * Either all names are to be resolved synchronously or | |||
| 1432 | * the concurrencly level is 0; do the resolution | |||
| 1433 | * synchronously. | |||
| 1434 | */ | |||
| 1435 | sync_lookup_ip6(addr); | |||
| 1436 | } else { | |||
| 1437 | /* | |||
| 1438 | * Names are to be resolved asynchronously, and we | |||
| 1439 | * allow at least one asynchronous request in flight; | |||
| 1440 | * post an asynchronous request. | |||
| 1441 | */ | |||
| 1442 | async_dns_queue_msg_t *caqm; | |||
| 1443 | ||||
| 1444 | 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))); | |||
| 1445 | caqm->family = AF_INET610; | |||
| 1446 | memcpy(&caqm->addr.ip6, addr, sizeof(caqm->addr.ip6)); | |||
| 1447 | wmem_list_append(async_dns_queue_head, (void *) caqm); | |||
| 1448 | } | |||
| 1449 | } | |||
| 1450 | } | |||
| 1451 | ||||
| 1452 | return tp; | |||
| 1453 | ||||
| 1454 | } /* host_lookup6 */ | |||
| 1455 | ||||
| 1456 | /* | |||
| 1457 | * Ethernet / manufacturer resolution | |||
| 1458 | * | |||
| 1459 | * The following functions implement ethernet address resolution and | |||
| 1460 | * ethers files parsing (see ethers(4)). | |||
| 1461 | * | |||
| 1462 | * The manuf file has the same format as ethers(4) except that names are | |||
| 1463 | * truncated to MAXMANUFLEN-1 (8) characters and that an address contains | |||
| 1464 | * only 3 bytes (instead of 6). | |||
| 1465 | * | |||
| 1466 | * Notes: | |||
| 1467 | * | |||
| 1468 | * I decide to not use the existing functions (see ethers(3) on some | |||
| 1469 | * operating systems) for the following reasons: | |||
| 1470 | * - performance gains (use of hash tables and some other enhancements), | |||
| 1471 | * - use of two ethers files (system-wide and per user), | |||
| 1472 | * - avoid the use of NIS maps, | |||
| 1473 | * - lack of these functions on some systems. | |||
| 1474 | * | |||
| 1475 | * So the following functions do _not_ behave as the standard ones. | |||
| 1476 | * | |||
| 1477 | * -- Laurent. | |||
| 1478 | */ | |||
| 1479 | ||||
| 1480 | /* | |||
| 1481 | * Converts Ethernet addresses of the form aa:bb:cc or aa:bb:cc:dd:ee:ff/28. | |||
| 1482 | * '-' is also supported as a separator. The | |||
| 1483 | * octets must be exactly two hexadecimal characters and the mask must be either | |||
| 1484 | * 28 or 36. Pre-condition: cp MUST be at least 21 bytes. | |||
| 1485 | */ | |||
| 1486 | static bool_Bool | |||
| 1487 | parse_ether_address_fast(const unsigned char *cp, ether_t *eth, unsigned int *mask, | |||
| 1488 | const bool_Bool accept_mask) | |||
| 1489 | { | |||
| 1490 | /* XXX copied from strutil.c */ | |||
| 1491 | /* a map from ASCII hex chars to their value */ | |||
| 1492 | static const int8_t str_to_nibble[256] = { | |||
| 1493 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1494 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1495 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1496 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1, | |||
| 1497 | -1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1498 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1499 | -1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1500 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1501 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1502 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1503 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1504 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1505 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1506 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1507 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, | |||
| 1508 | -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 | |||
| 1509 | }; | |||
| 1510 | const uint8_t *str_to_nibble_usg = (const uint8_t *)str_to_nibble; | |||
| 1511 | ||||
| 1512 | unsigned char sep = cp[2]; | |||
| 1513 | if ((sep != ':' && sep != '-') || cp[5] != sep) { | |||
| 1514 | /* Unexpected separators. */ | |||
| 1515 | return false0; | |||
| 1516 | } | |||
| 1517 | ||||
| 1518 | /* N.B. store octet values in an int to detect invalid (-1) entries */ | |||
| 1519 | int num0 = (str_to_nibble_usg[cp[0]] << 4) | (int8_t)str_to_nibble_usg[cp[1]]; | |||
| 1520 | int num1 = (str_to_nibble_usg[cp[3]] << 4) | (int8_t)str_to_nibble_usg[cp[4]]; | |||
| 1521 | int num2 = (str_to_nibble_usg[cp[6]] << 4) | (int8_t)str_to_nibble_usg[cp[7]]; | |||
| 1522 | ||||
| 1523 | if ((num0 | num1 | num2) & 0x100) { | |||
| 1524 | /* Not hexadecimal numbers. */ | |||
| 1525 | return false0; | |||
| 1526 | } | |||
| 1527 | ||||
| 1528 | eth->addr[0] = (uint8_t)num0; | |||
| 1529 | eth->addr[1] = (uint8_t)num1; | |||
| 1530 | eth->addr[2] = (uint8_t)num2; | |||
| 1531 | ||||
| 1532 | if (cp[8] == '\0' && accept_mask) { | |||
| 1533 | /* Indicate that this is a manufacturer ID (0 is not allowed as a mask). */ | |||
| 1534 | *mask = 0; | |||
| 1535 | return true1; | |||
| 1536 | } else if (cp[8] != sep || !accept_mask) { | |||
| 1537 | /* Format not handled by this fast path. */ | |||
| 1538 | return false0; | |||
| 1539 | } | |||
| 1540 | ||||
| 1541 | /* N.B. store octet values in an int to detect invalid (-1) entries */ | |||
| 1542 | int num3 = (str_to_nibble_usg[cp[9]] << 4) | (int8_t)str_to_nibble_usg[cp[10]]; | |||
| 1543 | int num4 = (str_to_nibble_usg[cp[12]] << 4) | (int8_t)str_to_nibble_usg[cp[13]]; | |||
| 1544 | int num5 = (str_to_nibble_usg[cp[15]] << 4) | (int8_t)str_to_nibble_usg[cp[16]]; | |||
| 1545 | ||||
| 1546 | if (((num3 | num4 | num5) & 0x100) || cp[11] != sep || cp[14] != sep) { | |||
| 1547 | /* Not hexadecimal numbers or invalid separators. */ | |||
| 1548 | return false0; | |||
| 1549 | } | |||
| 1550 | ||||
| 1551 | eth->addr[3] = (uint8_t)num3; | |||
| 1552 | eth->addr[4] = (uint8_t)num4; | |||
| 1553 | eth->addr[5] = (uint8_t)num5; | |||
| 1554 | if (cp[17] == '\0') { | |||
| 1555 | /* We got 6 bytes, so this is a MAC address (48 is not allowed as a mask). */ | |||
| 1556 | *mask = 48; | |||
| 1557 | return true1; | |||
| 1558 | } else if (cp[17] != '/' || cp[20] != '\0') { | |||
| 1559 | /* Format not handled by this fast path. */ | |||
| 1560 | return false0; | |||
| 1561 | } | |||
| 1562 | ||||
| 1563 | int m1 = cp[18]; | |||
| 1564 | int m2 = cp[19]; | |||
| 1565 | if (m1 == '3' && m2 == '6') { /* Mask /36 */ | |||
| 1566 | eth->addr[4] &= 0xf0; | |||
| 1567 | eth->addr[5] = 0; | |||
| 1568 | *mask = 36; | |||
| 1569 | return true1; | |||
| 1570 | } | |||
| 1571 | if (m1 == '2' && m2 == '8') { /* Mask /28 */ | |||
| 1572 | eth->addr[3] &= 0xf0; | |||
| 1573 | eth->addr[4] = 0; | |||
| 1574 | eth->addr[5] = 0; | |||
| 1575 | *mask = 28; | |||
| 1576 | return true1; | |||
| 1577 | } | |||
| 1578 | /* Unsupported mask */ | |||
| 1579 | return false0; | |||
| 1580 | } | |||
| 1581 | ||||
| 1582 | /* | |||
| 1583 | * If "accept_mask" is false, cp must point to an address that consists | |||
| 1584 | * of exactly 6 (EUI-48) or 8 (EUI-64) bytes. | |||
| 1585 | * If "accept_mask" is true, parse an up-to-6-byte sequence with an optional | |||
| 1586 | * mask. | |||
| 1587 | */ | |||
| 1588 | static bool_Bool | |||
| 1589 | parse_ether_address(const char *cp, ether_t *eth, unsigned int *mask, | |||
| 1590 | const bool_Bool accept_mask) | |||
| 1591 | { | |||
| 1592 | int i; | |||
| 1593 | unsigned long num; | |||
| 1594 | char *p; | |||
| 1595 | char sep = '\0'; | |||
| 1596 | ||||
| 1597 | for (i = 0; i < EUI64_ADDR_LEN8; i++) { | |||
| 1598 | /* Get a hex number, 1 or 2 digits, no sign characters allowed. */ | |||
| 1599 | if (!g_ascii_isxdigit(*cp)((g_ascii_table[(guchar) (*cp)] & G_ASCII_XDIGIT) != 0)) | |||
| 1600 | return false0; | |||
| 1601 | num = strtoul(cp, &p, 16); | |||
| 1602 | if (p == cp) | |||
| 1603 | return false0; /* failed */ | |||
| 1604 | if (num > 0xFF) | |||
| 1605 | return false0; /* not a valid octet */ | |||
| 1606 | eth->addr[i] = (uint8_t) num; | |||
| 1607 | cp = p; /* skip past the number */ | |||
| 1608 | ||||
| 1609 | /* OK, what character terminated the octet? */ | |||
| 1610 | if (*cp == '/') { | |||
| 1611 | /* "/" - this has a mask. */ | |||
| 1612 | if (!accept_mask) { | |||
| 1613 | /* Entries with masks are not allowed in this file. */ | |||
| 1614 | return false0; | |||
| 1615 | } | |||
| 1616 | cp++; /* skip past the '/' to get to the mask */ | |||
| 1617 | if (!g_ascii_isdigit(*cp)((g_ascii_table[(guchar) (*cp)] & G_ASCII_DIGIT) != 0)) | |||
| 1618 | return false0; /* no sign allowed */ | |||
| 1619 | num = strtoul(cp, &p, 10); | |||
| 1620 | if (p == cp) | |||
| 1621 | return false0; /* failed */ | |||
| 1622 | cp = p; /* skip past the number */ | |||
| 1623 | if (*cp != '\0' && !g_ascii_isspace(*cp)((g_ascii_table[(guchar) (*cp)] & G_ASCII_SPACE) != 0)) | |||
| 1624 | return false0; /* bogus terminator */ | |||
| 1625 | if (num == 0 || num >= 48) | |||
| 1626 | return false0; /* bogus mask */ | |||
| 1627 | /* Mask out the bits not covered by the mask */ | |||
| 1628 | *mask = (int)num; | |||
| 1629 | for (i = 0; num >= 8; i++, num -= 8) | |||
| 1630 | ; /* skip octets entirely covered by the mask */ | |||
| 1631 | /* Mask out the first masked octet */ | |||
| 1632 | eth->addr[i] &= (0xFF << (8 - num)); | |||
| 1633 | i++; | |||
| 1634 | /* Mask out completely-masked-out octets */ | |||
| 1635 | for (; i < 6; i++) | |||
| 1636 | eth->addr[i] = 0; | |||
| 1637 | return true1; | |||
| 1638 | } | |||
| 1639 | if (*cp == '\0') { | |||
| 1640 | /* We're at the end of the address, and there's no mask. */ | |||
| 1641 | if (i == 2) { | |||
| 1642 | /* We got 3 bytes, so this is a manufacturer ID. */ | |||
| 1643 | if (!accept_mask) { | |||
| 1644 | /* Manufacturer IDs are not allowed in this file */ | |||
| 1645 | return false0; | |||
| 1646 | } | |||
| 1647 | /* Indicate that this is a manufacturer ID (0 is not allowed | |||
| 1648 | as a mask). */ | |||
| 1649 | *mask = 0; | |||
| 1650 | return true1; | |||
| 1651 | } | |||
| 1652 | ||||
| 1653 | if (i == 5) { | |||
| 1654 | /* We got 6 bytes, so this is a MAC address (48 is not allowed as a mask). */ | |||
| 1655 | if (mask) { | |||
| 1656 | *mask = 48; | |||
| 1657 | } | |||
| 1658 | return true1; | |||
| 1659 | } | |||
| 1660 | ||||
| 1661 | if (i == 7) { | |||
| 1662 | /* We got 8 bytes, so this is a EUI-64 address (64 is not allowed as a mask). */ | |||
| 1663 | if (mask) { | |||
| 1664 | *mask = 64; | |||
| 1665 | } | |||
| 1666 | return true1; | |||
| 1667 | } | |||
| 1668 | ||||
| 1669 | /* We didn't get 3 or 6 or 8 bytes, and there's no mask; this is | |||
| 1670 | illegal. */ | |||
| 1671 | return false0; | |||
| 1672 | } else { | |||
| 1673 | if (sep == '\0') { | |||
| 1674 | /* We don't know the separator used in this number; it can either | |||
| 1675 | be ':', '-', or '.'. */ | |||
| 1676 | if (*cp != ':' && *cp != '-' && *cp != '.') | |||
| 1677 | return false0; | |||
| 1678 | sep = *cp; /* subsequent separators must be the same */ | |||
| 1679 | } else { | |||
| 1680 | /* It has to be the same as the first separator */ | |||
| 1681 | if (*cp != sep) | |||
| 1682 | return false0; | |||
| 1683 | } | |||
| 1684 | } | |||
| 1685 | cp++; | |||
| 1686 | } | |||
| 1687 | ||||
| 1688 | return true1; | |||
| 1689 | } | |||
| 1690 | ||||
| 1691 | static int | |||
| 1692 | parse_ether_line(char *line, ether_t *eth, unsigned int *mask, | |||
| 1693 | const bool_Bool accept_mask) | |||
| 1694 | { | |||
| 1695 | /* | |||
| 1696 | * See the ethers(4) or ethers(5) man page for ethers file format | |||
| 1697 | * (not available on all systems). | |||
| 1698 | * We allow both ethernet address separators (':' and '-'), | |||
| 1699 | * as well as Wireshark's '.' separator. | |||
| 1700 | */ | |||
| 1701 | ||||
| 1702 | char *cp; | |||
| 1703 | ||||
| 1704 | line = g_strstrip(line)g_strchomp (g_strchug (line)); | |||
| 1705 | if (line[0] == '\0' || line[0] == '#') | |||
| 1706 | return -1; | |||
| 1707 | ||||
| 1708 | if ((cp = strchr(line, '#'))) { | |||
| 1709 | *cp = '\0'; | |||
| 1710 | g_strchomp(line); | |||
| 1711 | } | |||
| 1712 | ||||
| 1713 | if ((cp = strtok(line, " \t")) == NULL((void*)0)) | |||
| 1714 | return -1; | |||
| 1715 | ||||
| 1716 | /* First try to match the common format for the large ethers file. */ | |||
| 1717 | if (!parse_ether_address_fast(cp, eth, mask, accept_mask)) { | |||
| 1718 | /* Fallback for the well-known addresses (wka) file. */ | |||
| 1719 | if (!parse_ether_address(cp, eth, mask, accept_mask)) | |||
| 1720 | return -1; | |||
| 1721 | } | |||
| 1722 | ||||
| 1723 | if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0)) | |||
| 1724 | return -1; | |||
| 1725 | ||||
| 1726 | (void) g_strlcpy(eth->name, cp, MAXNAMELEN64); | |||
| 1727 | ||||
| 1728 | if ((cp = strtok(NULL((void*)0), "\t")) != NULL((void*)0)) | |||
| 1729 | { | |||
| 1730 | (void) g_strlcpy(eth->longname, cp, MAXNAMELEN64); | |||
| 1731 | } else { | |||
| 1732 | /* Make the long name the short name */ | |||
| 1733 | (void) g_strlcpy(eth->longname, eth->name, MAXNAMELEN64); | |||
| 1734 | } | |||
| 1735 | ||||
| 1736 | return 0; | |||
| 1737 | ||||
| 1738 | } /* parse_ether_line */ | |||
| 1739 | ||||
| 1740 | static FILE *eth_p; | |||
| 1741 | ||||
| 1742 | static void | |||
| 1743 | set_ethent(char *path) | |||
| 1744 | { | |||
| 1745 | if (eth_p) | |||
| 1746 | rewind(eth_p); | |||
| 1747 | else | |||
| 1748 | eth_p = ws_fopenfopen(path, "r"); | |||
| 1749 | } | |||
| 1750 | ||||
| 1751 | static void | |||
| 1752 | end_ethent(void) | |||
| 1753 | { | |||
| 1754 | if (eth_p) { | |||
| 1755 | fclose(eth_p); | |||
| 1756 | eth_p = NULL((void*)0); | |||
| 1757 | } | |||
| 1758 | } | |||
| 1759 | ||||
| 1760 | static ether_t * | |||
| 1761 | get_ethent(unsigned int *mask, const bool_Bool accept_mask) | |||
| 1762 | { | |||
| 1763 | ||||
| 1764 | static ether_t eth; | |||
| 1765 | char buf[MAX_LINELEN1024]; | |||
| 1766 | ||||
| 1767 | if (eth_p == NULL((void*)0)) | |||
| 1768 | return NULL((void*)0); | |||
| 1769 | ||||
| 1770 | while (fgetline(buf, sizeof(buf), eth_p) >= 0) { | |||
| 1771 | if (parse_ether_line(buf, ð, mask, accept_mask) == 0) { | |||
| 1772 | return ð | |||
| 1773 | } | |||
| 1774 | } | |||
| 1775 | ||||
| 1776 | return NULL((void*)0); | |||
| 1777 | ||||
| 1778 | } /* get_ethent */ | |||
| 1779 | ||||
| 1780 | static hashmanuf_t * | |||
| 1781 | manuf_hash_new_entry(const uint8_t *addr, const char* name, const char* longname) | |||
| 1782 | { | |||
| 1783 | unsigned manuf_key; | |||
| 1784 | hashmanuf_t *manuf_value; | |||
| 1785 | char *endp; | |||
| 1786 | ||||
| 1787 | /* manuf needs only the 3 most significant octets of the ethernet address */ | |||
| 1788 | manuf_key = (addr[0] << 16) + (addr[1] << 8) + addr[2]; | |||
| 1789 | manuf_value = wmem_new(addr_resolv_scope, hashmanuf_t)((hashmanuf_t*)wmem_alloc((addr_resolv_scope), sizeof(hashmanuf_t ))); | |||
| 1790 | ||||
| 1791 | memcpy(manuf_value->addr, addr, 3); | |||
| 1792 | if (name != NULL((void*)0)) { | |||
| 1793 | (void) g_strlcpy(manuf_value->resolved_name, name, MAXNAMELEN64); | |||
| 1794 | manuf_value->flags = NAME_RESOLVED(1U<<1); | |||
| 1795 | if (longname != NULL((void*)0)) { | |||
| 1796 | (void) g_strlcpy(manuf_value->resolved_longname, longname, MAXNAMELEN64); | |||
| 1797 | } | |||
| 1798 | else { | |||
| 1799 | (void) g_strlcpy(manuf_value->resolved_longname, name, MAXNAMELEN64); | |||
| 1800 | } | |||
| 1801 | } | |||
| 1802 | else { | |||
| 1803 | manuf_value->flags = 0; | |||
| 1804 | manuf_value->resolved_name[0] = '\0'; | |||
| 1805 | manuf_value->resolved_longname[0] = '\0'; | |||
| 1806 | } | |||
| 1807 | /* Values returned by bytes_to_hexstr_punct() are *not* null-terminated */ | |||
| 1808 | endp = bytes_to_hexstr_punct(manuf_value->hexaddr, addr, sizeof(manuf_value->addr), ':'); | |||
| 1809 | *endp = '\0'; | |||
| 1810 | ||||
| 1811 | wmem_map_insert(manuf_hashtable, GUINT_TO_POINTER(manuf_key)((gpointer) (gulong) (manuf_key)), manuf_value); | |||
| 1812 | return manuf_value; | |||
| 1813 | } | |||
| 1814 | ||||
| 1815 | static hashwka_t* | |||
| 1816 | wka_hash_new_entry(const uint8_t *addr, char* name) | |||
| 1817 | { | |||
| 1818 | uint8_t *wka_key; | |||
| 1819 | hashwka_t *wka_value; | |||
| 1820 | ||||
| 1821 | wka_key = (uint8_t *)wmem_alloc(addr_resolv_scope, 6); | |||
| 1822 | memcpy(wka_key, addr, 6); | |||
| 1823 | ||||
| 1824 | wka_value = (hashwka_t*)wmem_new(addr_resolv_scope, hashwka_t)((hashwka_t*)wmem_alloc((addr_resolv_scope), sizeof(hashwka_t ))); | |||
| 1825 | wka_value->flags = NAME_RESOLVED(1U<<1); | |||
| 1826 | wka_value->name = wmem_strdup(addr_resolv_scope, name); | |||
| 1827 | ||||
| 1828 | wmem_map_insert(wka_hashtable, wka_key, wka_value); | |||
| 1829 | return wka_value; | |||
| 1830 | } | |||
| 1831 | ||||
| 1832 | static void | |||
| 1833 | add_manuf_name(const uint8_t *addr, unsigned int mask, char *name, char *longname) | |||
| 1834 | { | |||
| 1835 | switch (mask) | |||
| 1836 | { | |||
| 1837 | case 0: | |||
| 1838 | { | |||
| 1839 | /* This is a manufacturer ID; add it to the manufacturer ID hash table */ | |||
| 1840 | hashmanuf_t *entry = manuf_hash_new_entry(addr, name, longname); | |||
| 1841 | entry->flags |= STATIC_HOSTNAME(1U<<3); | |||
| 1842 | break; | |||
| 1843 | } | |||
| 1844 | case 48: | |||
| 1845 | { | |||
| 1846 | /* This is a well-known MAC address; add it to the Ethernet hash table */ | |||
| 1847 | add_eth_name(addr, name, true1); | |||
| 1848 | break; | |||
| 1849 | } | |||
| 1850 | default: | |||
| 1851 | { | |||
| 1852 | /* This is a range of well-known addresses; add it to the well-known-address table */ | |||
| 1853 | hashwka_t *entry = wka_hash_new_entry(addr, name); | |||
| 1854 | entry->flags |= STATIC_HOSTNAME(1U<<3); | |||
| 1855 | break; | |||
| 1856 | } | |||
| 1857 | } | |||
| 1858 | } /* add_manuf_name */ | |||
| 1859 | ||||
| 1860 | /* XXX: manuf_name_lookup returns a hashmanuf_t*, which cannot hold a 28 or | |||
| 1861 | * 36 bit MA-M or MA-S. So it returns those as unresolved. For EUI-48 and | |||
| 1862 | * EUI-64, MA-M and MA-S should be checked for separately in the global | |||
| 1863 | * tables. | |||
| 1864 | * | |||
| 1865 | * XXX - size_t is used only in a ws_return_val_if() that checks | |||
| 1866 | * whether the argument has at least 3 bytes; that's done only if | |||
| 1867 | * assertions are enabled, so it's used only if assertions are | |||
| 1868 | * enabled. This means that, if assertions aren't enabled, a | |||
| 1869 | * warning that the argument is unused will be issued by at least | |||
| 1870 | * some compilers, so we mark it as unused. Should we do that | |||
| 1871 | * check unconditionally, and just emit a warning if assertions | |||
| 1872 | * are enabled? | |||
| 1873 | */ | |||
| 1874 | static hashmanuf_t * | |||
| 1875 | manuf_name_lookup(const uint8_t *addr, size_t size _U___attribute__((unused))) | |||
| 1876 | { | |||
| 1877 | uint32_t manuf_key; | |||
| 1878 | uint8_t oct; | |||
| 1879 | hashmanuf_t *manuf_value; | |||
| 1880 | ||||
| 1881 | ws_return_val_if(size < 3, NULL)do { if (1 && (size < 3)) { ws_log_full("InvalidArg" , LOG_LEVEL_WARNING, "epan/addr_resolv.c", 1881, __func__, "invalid argument: %s" , "size < 3"); return (((void*)0)); } } while (0); | |||
| 1882 | ||||
| 1883 | /* manuf needs only the 3 most significant octets of the ethernet address */ | |||
| 1884 | manuf_key = addr[0]; | |||
| 1885 | manuf_key = manuf_key<<8; | |||
| 1886 | oct = addr[1]; | |||
| 1887 | manuf_key = manuf_key | oct; | |||
| 1888 | manuf_key = manuf_key<<8; | |||
| 1889 | oct = addr[2]; | |||
| 1890 | manuf_key = manuf_key | oct; | |||
| 1891 | ||||
| 1892 | ||||
| 1893 | /* first try to find a "perfect match" */ | |||
| 1894 | manuf_value = (hashmanuf_t*)wmem_map_lookup(manuf_hashtable, GUINT_TO_POINTER(manuf_key)((gpointer) (gulong) (manuf_key))); | |||
| 1895 | if (manuf_value != NULL((void*)0)) { | |||
| 1896 | manuf_value->flags |= TRIED_RESOLVE_ADDRESS(1U<<0); | |||
| 1897 | return manuf_value; | |||
| 1898 | } | |||
| 1899 | ||||
| 1900 | /* Mask out the broadcast/multicast flag but not the locally | |||
| 1901 | * administered flag as locally administered means: not assigned | |||
| 1902 | * by the IEEE but the local administrator instead. | |||
| 1903 | * 0x01 multicast / broadcast bit | |||
| 1904 | * 0x02 locally administered bit */ | |||
| 1905 | if ((manuf_key & 0x00010000) != 0) { | |||
| 1906 | manuf_key &= 0x00FEFFFF; | |||
| 1907 | manuf_value = (hashmanuf_t*)wmem_map_lookup(manuf_hashtable, GUINT_TO_POINTER(manuf_key)((gpointer) (gulong) (manuf_key))); | |||
| 1908 | if (manuf_value != NULL((void*)0)) { | |||
| 1909 | manuf_value->flags |= TRIED_RESOLVE_ADDRESS(1U<<0); | |||
| 1910 | return manuf_value; | |||
| 1911 | } | |||
| 1912 | } | |||
| 1913 | ||||
| 1914 | /* Try the global manuf tables. */ | |||
| 1915 | const char *short_name, *long_name; | |||
| 1916 | /* We can't insert a 28 or 36 bit entry into the used hash table. */ | |||
| 1917 | short_name = ws_manuf_lookup_oui24(addr, &long_name); | |||
| 1918 | if (short_name != NULL((void*)0)) { | |||
| 1919 | /* Found it */ | |||
| 1920 | manuf_value = manuf_hash_new_entry(addr, short_name, long_name); | |||
| 1921 | } else { | |||
| 1922 | /* Add the address as a hex string */ | |||
| 1923 | manuf_value = manuf_hash_new_entry(addr, NULL((void*)0), NULL((void*)0)); | |||
| 1924 | } | |||
| 1925 | ||||
| 1926 | manuf_value->flags |= TRIED_RESOLVE_ADDRESS(1U<<0); | |||
| 1927 | return manuf_value; | |||
| 1928 | ||||
| 1929 | } /* manuf_name_lookup */ | |||
| 1930 | ||||
| 1931 | static char * | |||
| 1932 | wka_name_lookup(const uint8_t *addr, const unsigned int mask) | |||
| 1933 | { | |||
| 1934 | uint8_t masked_addr[6]; | |||
| 1935 | unsigned num; | |||
| 1936 | int i; | |||
| 1937 | hashwka_t *value; | |||
| 1938 | ||||
| 1939 | if (wka_hashtable == NULL((void*)0)) { | |||
| 1940 | return NULL((void*)0); | |||
| 1941 | } | |||
| 1942 | /* Get the part of the address covered by the mask. */ | |||
| 1943 | for (i = 0, num = mask; num >= 8; i++, num -= 8) | |||
| 1944 | masked_addr[i] = addr[i]; /* copy octets entirely covered by the mask */ | |||
| 1945 | /* Mask out the first masked octet */ | |||
| 1946 | masked_addr[i] = addr[i] & (0xFF << (8 - num)); | |||
| 1947 | i++; | |||
| 1948 | /* Zero out completely-masked-out octets */ | |||
| 1949 | for (; i < 6; i++) | |||
| 1950 | masked_addr[i] = 0; | |||
| 1951 | ||||
| 1952 | value = (hashwka_t*)wmem_map_lookup(wka_hashtable, masked_addr); | |||
| 1953 | ||||
| 1954 | if (value) { | |||
| 1955 | value->flags |= TRIED_RESOLVE_ADDRESS(1U<<0); | |||
| 1956 | return value->name; | |||
| 1957 | } | |||
| 1958 | ||||
| 1959 | return NULL((void*)0); | |||
| 1960 | ||||
| 1961 | } /* wka_name_lookup */ | |||
| 1962 | ||||
| 1963 | unsigned get_hash_ether_status(hashether_t* ether) | |||
| 1964 | { | |||
| 1965 | return ether->flags; | |||
| 1966 | } | |||
| 1967 | ||||
| 1968 | bool_Bool get_hash_ether_used(hashether_t* ether) | |||
| 1969 | { | |||
| 1970 | return ((ether->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) == TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))); | |||
| 1971 | } | |||
| 1972 | ||||
| 1973 | char* get_hash_ether_hexaddr(hashether_t* ether) | |||
| 1974 | { | |||
| 1975 | return ether->hexaddr; | |||
| 1976 | } | |||
| 1977 | ||||
| 1978 | char* get_hash_ether_resolved_name(hashether_t* ether) | |||
| 1979 | { | |||
| 1980 | return ether->resolved_name; | |||
| 1981 | } | |||
| 1982 | ||||
| 1983 | bool_Bool get_hash_wka_used(hashwka_t* wka) | |||
| 1984 | { | |||
| 1985 | return ((wka->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) == TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))); | |||
| 1986 | } | |||
| 1987 | ||||
| 1988 | char* get_hash_wka_resolved_name(hashwka_t* wka) | |||
| 1989 | { | |||
| 1990 | return wka->name; | |||
| 1991 | } | |||
| 1992 | ||||
| 1993 | static unsigned | |||
| 1994 | eth_addr_hash(const void *key) | |||
| 1995 | { | |||
| 1996 | return wmem_strong_hash((const uint8_t *)key, 6); | |||
| 1997 | } | |||
| 1998 | ||||
| 1999 | static gboolean | |||
| 2000 | eth_addr_cmp(const void *a, const void *b) | |||
| 2001 | { | |||
| 2002 | return (memcmp(a, b, 6) == 0); | |||
| 2003 | } | |||
| 2004 | ||||
| 2005 | static unsigned | |||
| 2006 | eui64_addr_hash(const void *key) | |||
| 2007 | { | |||
| 2008 | return wmem_strong_hash((const uint8_t *)key, EUI64_ADDR_LEN8); | |||
| 2009 | } | |||
| 2010 | ||||
| 2011 | static gboolean | |||
| 2012 | eui64_addr_cmp(const void *a, const void *b) | |||
| 2013 | { | |||
| 2014 | return (memcmp(a, b, EUI64_ADDR_LEN8) == 0); | |||
| 2015 | } | |||
| 2016 | ||||
| 2017 | static void | |||
| 2018 | initialize_ethers(void) | |||
| 2019 | { | |||
| 2020 | ether_t *eth; | |||
| 2021 | unsigned mask = 0; | |||
| 2022 | ||||
| 2023 | /* hash table initialization */ | |||
| 2024 | ws_assert(wka_hashtable == NULL)do { if ((1) && !(wka_hashtable == ((void*)0))) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 2024, __func__, "assertion failed: %s" , "wka_hashtable == ((void*)0)"); } while (0); | |||
| 2025 | wka_hashtable = wmem_map_new(addr_resolv_scope, eth_addr_hash, eth_addr_cmp); | |||
| 2026 | ws_assert(manuf_hashtable == NULL)do { if ((1) && !(manuf_hashtable == ((void*)0))) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 2026, __func__, "assertion failed: %s" , "manuf_hashtable == ((void*)0)"); } while (0); | |||
| 2027 | manuf_hashtable = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal); | |||
| 2028 | ws_assert(eth_hashtable == NULL)do { if ((1) && !(eth_hashtable == ((void*)0))) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 2028, __func__, "assertion failed: %s" , "eth_hashtable == ((void*)0)"); } while (0); | |||
| 2029 | eth_hashtable = wmem_map_new(addr_resolv_scope, eth_addr_hash, eth_addr_cmp); | |||
| 2030 | ws_assert(eui64_hashtable == NULL)do { if ((1) && !(eui64_hashtable == ((void*)0))) ws_log_fatal_full ("", LOG_LEVEL_ERROR, "epan/addr_resolv.c", 2030, __func__, "assertion failed: %s" , "eui64_hashtable == ((void*)0)"); } while (0); | |||
| 2031 | eui64_hashtable = wmem_map_new(addr_resolv_scope, eui64_addr_hash, eui64_addr_cmp); | |||
| 2032 | ||||
| 2033 | /* Compute the pathname of the ethers file. */ | |||
| 2034 | if (g_ethers_path == NULL((void*)0)) { | |||
| 2035 | g_ethers_path = g_build_filename(get_systemfile_dir(), ENAME_ETHERS"ethers", NULL((void*)0)); | |||
| 2036 | } | |||
| 2037 | ||||
| 2038 | /* Compute the pathname of the personal ethers file. */ | |||
| 2039 | if (g_pethers_path == NULL((void*)0)) { | |||
| 2040 | /* Check profile directory before personal configuration */ | |||
| 2041 | g_pethers_path = get_persconffile_path(ENAME_ETHERS"ethers", true1); | |||
| 2042 | if (!file_exists(g_pethers_path)) { | |||
| 2043 | g_free(g_pethers_path); | |||
| 2044 | g_pethers_path = get_persconffile_path(ENAME_ETHERS"ethers", false0); | |||
| 2045 | } | |||
| 2046 | } | |||
| 2047 | ||||
| 2048 | /* Compute the pathname of the global manuf file */ | |||
| 2049 | if (g_manuf_path == NULL((void*)0)) | |||
| 2050 | g_manuf_path = get_datafile_path(ENAME_MANUF"manuf"); | |||
| 2051 | /* Read it and initialize the hash table */ | |||
| 2052 | if (file_exists(g_manuf_path)) { | |||
| 2053 | set_ethent(g_manuf_path); | |||
| 2054 | while ((eth = get_ethent(&mask, true1))) { | |||
| 2055 | add_manuf_name(eth->addr, mask, eth->name, eth->longname); | |||
| 2056 | } | |||
| 2057 | end_ethent(); | |||
| 2058 | } | |||
| 2059 | ||||
| 2060 | /* Compute the pathname of the personal manuf file */ | |||
| 2061 | if (g_pmanuf_path == NULL((void*)0)) { | |||
| 2062 | /* Check profile directory before personal configuration */ | |||
| 2063 | g_pmanuf_path = get_persconffile_path(ENAME_MANUF"manuf", true1); | |||
| 2064 | if (!file_exists(g_pmanuf_path)) { | |||
| 2065 | g_free(g_pmanuf_path); | |||
| 2066 | g_pmanuf_path = get_persconffile_path(ENAME_MANUF"manuf", false0); | |||
| 2067 | } | |||
| 2068 | } | |||
| 2069 | /* Read it and initialize the hash table */ | |||
| 2070 | if (file_exists(g_pmanuf_path)) { | |||
| 2071 | set_ethent(g_pmanuf_path); | |||
| 2072 | while ((eth = get_ethent(&mask, true1))) { | |||
| 2073 | add_manuf_name(eth->addr, mask, eth->name, eth->longname); | |||
| 2074 | } | |||
| 2075 | end_ethent(); | |||
| 2076 | } | |||
| 2077 | ||||
| 2078 | /* Compute the pathname of the wka file */ | |||
| 2079 | if (g_wka_path == NULL((void*)0)) | |||
| 2080 | g_wka_path = get_datafile_path(ENAME_WKA"wka"); | |||
| 2081 | ||||
| 2082 | /* Read it and initialize the hash table */ | |||
| 2083 | set_ethent(g_wka_path); | |||
| 2084 | while ((eth = get_ethent(&mask, true1))) { | |||
| 2085 | add_manuf_name(eth->addr, mask, eth->name, eth->longname); | |||
| 2086 | } | |||
| 2087 | end_ethent(); | |||
| 2088 | ||||
| 2089 | /* Look at the ethers files last. These are set as static names, | |||
| 2090 | * so they override earlier entries, and the ones we read last | |||
| 2091 | * take precedence. Order of precedence is personal ethers file, | |||
| 2092 | * global ethers file, wka file, personal manuf file, global manuf | |||
| 2093 | * file, and then non-static sources like ARP Eth -> IP hostname | |||
| 2094 | * discovery (if enabled), NRB entries (if wiretap adds support for | |||
| 2095 | * EUI-48 in NRBs), etc. | |||
| 2096 | * XXX: What _is_ the proper order of precedence, and should it | |||
| 2097 | * be configurable? (cf. #18075) */ | |||
| 2098 | set_ethent(g_ethers_path); | |||
| 2099 | while ((eth = get_ethent(&mask, false0))) { | |||
| 2100 | if (mask == 48) { | |||
| 2101 | add_eth_name(eth->addr, eth->name, true1); | |||
| 2102 | } else if (mask == 64) { | |||
| 2103 | add_eui64_name(eth->addr, eth->name, true1); | |||
| 2104 | } | |||
| 2105 | } | |||
| 2106 | end_ethent(); | |||
| 2107 | ||||
| 2108 | if (file_exists(g_pethers_path)) { | |||
| 2109 | set_ethent(g_pethers_path); | |||
| 2110 | while ((eth = get_ethent(&mask, false0))) { | |||
| 2111 | if (mask == 48) { | |||
| 2112 | add_eth_name(eth->addr, eth->name, true1); | |||
| 2113 | } else if (mask == 64) { | |||
| 2114 | add_eui64_name(eth->addr, eth->name, true1); | |||
| 2115 | } | |||
| 2116 | } | |||
| 2117 | end_ethent(); | |||
| 2118 | } | |||
| 2119 | ||||
| 2120 | } /* initialize_ethers */ | |||
| 2121 | ||||
| 2122 | static void | |||
| 2123 | ethers_cleanup(void) | |||
| 2124 | { | |||
| 2125 | wka_hashtable = NULL((void*)0); | |||
| 2126 | manuf_hashtable = NULL((void*)0); | |||
| 2127 | eth_hashtable = NULL((void*)0); | |||
| 2128 | eui64_hashtable = NULL((void*)0); | |||
| 2129 | g_free(g_ethers_path); | |||
| 2130 | g_ethers_path = NULL((void*)0); | |||
| 2131 | g_free(g_pethers_path); | |||
| 2132 | g_pethers_path = NULL((void*)0); | |||
| 2133 | g_free(g_manuf_path); | |||
| 2134 | g_manuf_path = NULL((void*)0); | |||
| 2135 | g_free(g_pmanuf_path); | |||
| 2136 | g_pmanuf_path = NULL((void*)0); | |||
| 2137 | g_free(g_wka_path); | |||
| 2138 | g_wka_path = NULL((void*)0); | |||
| 2139 | } | |||
| 2140 | ||||
| 2141 | static void | |||
| 2142 | eth_resolved_name_fill(hashether_t *tp, const char *name, unsigned mask, const uint8_t *addr) | |||
| 2143 | { | |||
| 2144 | switch (mask) { | |||
| 2145 | case 24: | |||
| 2146 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x", | |||
| 2147 | name, addr[3], addr[4], addr[5]); | |||
| 2148 | break; | |||
| 2149 | case 28: | |||
| 2150 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%01x:%02x:%02x", | |||
| 2151 | name, addr[3] & 0x0F, addr[4], addr[5]); | |||
| 2152 | break; | |||
| 2153 | case 36: | |||
| 2154 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%01x:%02x", | |||
| 2155 | name, addr[4] & 0x0F, addr[5]); | |||
| 2156 | break; | |||
| 2157 | default: // Future-proof generic algorithm | |||
| 2158 | { | |||
| 2159 | unsigned bytes = mask / 8; | |||
| 2160 | unsigned bitmask = mask % 8; | |||
| 2161 | ||||
| 2162 | int pos = snprintf(tp->resolved_name, MAXNAMELEN64, "%s", name); | |||
| 2163 | if (pos >= MAXNAMELEN64) return; | |||
| 2164 | ||||
| 2165 | if (bytes < 6) { | |||
| 2166 | pos += snprintf(tp->resolved_name + pos, MAXNAMELEN64 - pos, | |||
| 2167 | bitmask >= 4 ? "_%01x" : "_%02x", | |||
| 2168 | addr[bytes] & (0xFF >> bitmask)); | |||
| 2169 | bytes++; | |||
| 2170 | } | |||
| 2171 | ||||
| 2172 | while (bytes < 6) { | |||
| 2173 | if (pos >= MAXNAMELEN64) return; | |||
| 2174 | pos += snprintf(tp->resolved_name + pos, MAXNAMELEN64 - pos, ":%02x", | |||
| 2175 | addr[bytes]); | |||
| 2176 | bytes++; | |||
| 2177 | } | |||
| 2178 | } | |||
| 2179 | } | |||
| 2180 | } | |||
| 2181 | ||||
| 2182 | /* Resolve ethernet address */ | |||
| 2183 | static hashether_t * | |||
| 2184 | eth_addr_resolve(hashether_t *tp) { | |||
| 2185 | hashmanuf_t *manuf_value; | |||
| 2186 | const uint8_t *addr = tp->addr; | |||
| 2187 | size_t addr_size = sizeof(tp->addr); | |||
| 2188 | ||||
| 2189 | if (!(tp->flags & NAME_RESOLVED(1U<<1))) { | |||
| 2190 | unsigned mask; | |||
| 2191 | char *name; | |||
| 2192 | address ether_addr; | |||
| 2193 | ||||
| 2194 | /* Unknown name. Try looking for it in the well-known-address | |||
| 2195 | tables for well-known address ranges smaller than 2^24. */ | |||
| 2196 | mask = 7; | |||
| 2197 | do { | |||
| 2198 | /* Only the topmost 5 bytes participate fully */ | |||
| 2199 | if ((name = wka_name_lookup(addr, mask+40)) != NULL((void*)0)) { | |||
| 2200 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x", | |||
| 2201 | name, addr[5] & (0xFF >> mask)); | |||
| 2202 | tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4); | |||
| 2203 | return tp; | |||
| 2204 | } | |||
| 2205 | } while (mask--); | |||
| 2206 | ||||
| 2207 | mask = 7; | |||
| 2208 | do { | |||
| 2209 | /* Only the topmost 4 bytes participate fully */ | |||
| 2210 | if ((name = wka_name_lookup(addr, mask+32)) != NULL((void*)0)) { | |||
| 2211 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x", | |||
| 2212 | name, addr[4] & (0xFF >> mask), addr[5]); | |||
| 2213 | tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4); | |||
| 2214 | return tp; | |||
| 2215 | } | |||
| 2216 | } while (mask--); | |||
| 2217 | ||||
| 2218 | mask = 7; | |||
| 2219 | do { | |||
| 2220 | /* Only the topmost 3 bytes participate fully */ | |||
| 2221 | if ((name = wka_name_lookup(addr, mask+24)) != NULL((void*)0)) { | |||
| 2222 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x", | |||
| 2223 | name, addr[3] & (0xFF >> mask), addr[4], addr[5]); | |||
| 2224 | tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4); | |||
| 2225 | return tp; | |||
| 2226 | } | |||
| 2227 | } while (mask--); | |||
| 2228 | ||||
| 2229 | /* Now try looking in the manufacturer table. */ | |||
| 2230 | manuf_value = manuf_name_lookup(addr, addr_size); | |||
| 2231 | if ((manuf_value != NULL((void*)0)) && ((manuf_value->flags & NAME_RESOLVED(1U<<1)) == NAME_RESOLVED(1U<<1))) { | |||
| 2232 | snprintf(tp->resolved_name, MAXNAMELEN64, "%.*s_%02x:%02x:%02x", | |||
| 2233 | MAXNAMELEN64 - 10, manuf_value->resolved_name, addr[3], addr[4], addr[5]); | |||
| 2234 | tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4); | |||
| 2235 | return tp; | |||
| 2236 | } | |||
| 2237 | ||||
| 2238 | /* Now try looking for it in the well-known-address | |||
| 2239 | tables for well-known address ranges larger than 2^24. */ | |||
| 2240 | mask = 7; | |||
| 2241 | do { | |||
| 2242 | /* Only the topmost 2 bytes participate fully */ | |||
| 2243 | if ((name = wka_name_lookup(addr, mask+16)) != NULL((void*)0)) { | |||
| 2244 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x:%02x", | |||
| 2245 | name, addr[2] & (0xFF >> mask), addr[3], addr[4], | |||
| 2246 | addr[5]); | |||
| 2247 | tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4); | |||
| 2248 | return tp; | |||
| 2249 | } | |||
| 2250 | } while (mask--); | |||
| 2251 | ||||
| 2252 | mask = 7; | |||
| 2253 | do { | |||
| 2254 | /* Only the topmost byte participates fully */ | |||
| 2255 | if ((name = wka_name_lookup(addr, mask+8)) != NULL((void*)0)) { | |||
| 2256 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x:%02x:%02x", | |||
| 2257 | name, addr[1] & (0xFF >> mask), addr[2], addr[3], | |||
| 2258 | addr[4], addr[5]); | |||
| 2259 | tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4); | |||
| 2260 | return tp; | |||
| 2261 | } | |||
| 2262 | } while (mask--); | |||
| 2263 | ||||
| 2264 | mask = 7; | |||
| 2265 | do { | |||
| 2266 | /* Not even the topmost byte participates fully */ | |||
| 2267 | if ((name = wka_name_lookup(addr, mask)) != NULL((void*)0)) { | |||
| 2268 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x:%02x:%02x:%02x", | |||
| 2269 | name, addr[0] & (0xFF >> mask), addr[1], addr[2], | |||
| 2270 | addr[3], addr[4], addr[5]); | |||
| 2271 | tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4); | |||
| 2272 | return tp; | |||
| 2273 | } | |||
| 2274 | } while (--mask); /* Work down to the last bit */ | |||
| 2275 | ||||
| 2276 | /* Now try looking in the global manuf data for a MA-M or MA-S | |||
| 2277 | * match. We do this last so that the other files override this | |||
| 2278 | * result. | |||
| 2279 | */ | |||
| 2280 | const char *short_name, *long_name; | |||
| 2281 | short_name = ws_manuf_lookup(addr, &long_name, &mask); | |||
| 2282 | if (short_name != NULL((void*)0)) { | |||
| 2283 | if (mask == 24) { | |||
| 2284 | /* This shouldn't happen as it should be handled above, | |||
| 2285 | * but it doesn't hurt. | |||
| 2286 | */ | |||
| 2287 | manuf_hash_new_entry(addr, short_name, long_name); | |||
| 2288 | } | |||
| 2289 | eth_resolved_name_fill(tp, short_name, mask, addr); | |||
| 2290 | tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4); | |||
| 2291 | return tp; | |||
| 2292 | } | |||
| 2293 | /* No match whatsoever. */ | |||
| 2294 | set_address(ðer_addr, AT_ETHER, 6, addr); | |||
| 2295 | address_to_str_buf(ðer_addr, tp->resolved_name, MAXNAMELEN64); | |||
| 2296 | return tp; | |||
| 2297 | } | |||
| 2298 | return tp; | |||
| 2299 | } /* eth_addr_resolve */ | |||
| 2300 | ||||
| 2301 | static hashether_t * | |||
| 2302 | eth_hash_new_entry(const uint8_t *addr, const bool_Bool resolve) | |||
| 2303 | { | |||
| 2304 | hashether_t *tp; | |||
| 2305 | char *endp; | |||
| 2306 | ||||
| 2307 | tp = wmem_new(addr_resolv_scope, hashether_t)((hashether_t*)wmem_alloc((addr_resolv_scope), sizeof(hashether_t ))); | |||
| 2308 | memcpy(tp->addr, addr, sizeof(tp->addr)); | |||
| 2309 | tp->flags = 0; | |||
| 2310 | /* Values returned by bytes_to_hexstr_punct() are *not* null-terminated */ | |||
| 2311 | endp = bytes_to_hexstr_punct(tp->hexaddr, addr, sizeof(tp->addr), ':'); | |||
| 2312 | *endp = '\0'; | |||
| 2313 | tp->resolved_name[0] = '\0'; | |||
| 2314 | ||||
| 2315 | if (resolve) | |||
| 2316 | eth_addr_resolve(tp); | |||
| 2317 | ||||
| 2318 | wmem_map_insert(eth_hashtable, tp->addr, tp); | |||
| 2319 | ||||
| 2320 | return tp; | |||
| 2321 | } /* eth_hash_new_entry */ | |||
| 2322 | ||||
| 2323 | static hashether_t * | |||
| 2324 | add_eth_name(const uint8_t *addr, const char *name, bool_Bool static_entry) | |||
| 2325 | { | |||
| 2326 | hashether_t *tp; | |||
| 2327 | ||||
| 2328 | tp = (hashether_t *)wmem_map_lookup(eth_hashtable, addr); | |||
| 2329 | ||||
| 2330 | if (tp == NULL((void*)0)) { | |||
| 2331 | tp = eth_hash_new_entry(addr, false0); | |||
| 2332 | } | |||
| 2333 | ||||
| 2334 | if (strcmp(tp->resolved_name, name) != 0 && (static_entry || !(tp->flags & STATIC_HOSTNAME(1U<<3)))) { | |||
| 2335 | (void) g_strlcpy(tp->resolved_name, name, MAXNAMELEN64); | |||
| 2336 | tp->flags |= NAME_RESOLVED(1U<<1); | |||
| 2337 | if (static_entry) { | |||
| 2338 | tp->flags |= STATIC_HOSTNAME(1U<<3); | |||
| 2339 | } | |||
| 2340 | new_resolved_objects = true1; | |||
| 2341 | } | |||
| 2342 | ||||
| 2343 | return tp; | |||
| 2344 | } /* add_eth_name */ | |||
| 2345 | ||||
| 2346 | static hashether_t * | |||
| 2347 | eth_name_lookup(const uint8_t *addr, const bool_Bool resolve) | |||
| 2348 | { | |||
| 2349 | hashether_t *tp; | |||
| 2350 | ||||
| 2351 | tp = (hashether_t *)wmem_map_lookup(eth_hashtable, addr); | |||
| 2352 | ||||
| 2353 | if (tp == NULL((void*)0)) { | |||
| 2354 | tp = eth_hash_new_entry(addr, resolve); | |||
| 2355 | } else { | |||
| 2356 | if (resolve && !(tp->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)))) { | |||
| 2357 | eth_addr_resolve(tp); /* Found but needs to be resolved */ | |||
| 2358 | } | |||
| 2359 | } | |||
| 2360 | if (resolve) { | |||
| 2361 | tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0); | |||
| 2362 | } | |||
| 2363 | ||||
| 2364 | return tp; | |||
| 2365 | ||||
| 2366 | } /* eth_name_lookup */ | |||
| 2367 | ||||
| 2368 | static void | |||
| 2369 | eui64_resolved_name_fill(hasheui64_t *tp, const char *name, unsigned mask, const uint8_t *addr) | |||
| 2370 | { | |||
| 2371 | switch (mask) { | |||
| 2372 | case 24: | |||
| 2373 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%02x:%02x:%02x:%02x:%02x", | |||
| 2374 | name, addr[3], addr[4], addr[5], addr[6], addr[7]); | |||
| 2375 | break; | |||
| 2376 | case 28: | |||
| 2377 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%01x:%02x:%02x:%02x:%02x", | |||
| 2378 | name, addr[3] & 0x0F, addr[4], addr[5], addr[6], addr[7]); | |||
| 2379 | break; | |||
| 2380 | case 36: | |||
| 2381 | snprintf(tp->resolved_name, MAXNAMELEN64, "%s_%01x:%02x:%02x:%02x", | |||
| 2382 | name, addr[4] & 0x0F, addr[5], addr[6], addr[7]); | |||
| 2383 | break; | |||
| 2384 | default: // Future-proof generic algorithm | |||
| 2385 | { | |||
| 2386 | unsigned bytes = mask / 8; | |||
| 2387 | unsigned bitmask = mask % 8; | |||
| 2388 | ||||
| 2389 | int pos = snprintf(tp->resolved_name, MAXNAMELEN64, "%s", name); | |||
| 2390 | if (pos >= MAXNAMELEN64) return; | |||
| 2391 | ||||
| 2392 | if (bytes < EUI64_ADDR_LEN8) { | |||
| 2393 | pos += snprintf(tp->resolved_name + pos, MAXNAMELEN64 - pos, | |||
| 2394 | bitmask >= 4 ? "_%01x" : "_%02x", | |||
| 2395 | addr[bytes] & (0xFF >> bitmask)); | |||
| 2396 | bytes++; | |||
| 2397 | } | |||
| 2398 | ||||
| 2399 | while (bytes < EUI64_ADDR_LEN8) { | |||
| 2400 | if (pos >= MAXNAMELEN64) return; | |||
| 2401 | pos += snprintf(tp->resolved_name + pos, MAXNAMELEN64 - pos, ":%02x", | |||
| 2402 | addr[bytes]); | |||
| 2403 | bytes++; | |||
| 2404 | } | |||
| 2405 | } | |||
| 2406 | } | |||
| 2407 | } | |||
| 2408 | ||||
| 2409 | /* Resolve EUI-64 address */ | |||
| 2410 | static hasheui64_t * | |||
| 2411 | eui64_addr_resolve(hasheui64_t *tp) | |||
| 2412 | { | |||
| 2413 | hashmanuf_t *manuf_value; | |||
| 2414 | const uint8_t *addr = tp->addr; | |||
| 2415 | size_t addr_size = sizeof(tp->addr); | |||
| 2416 | ||||
| 2417 | if (!(tp->flags & NAME_RESOLVED(1U<<1))) { | |||
| 2418 | unsigned mask; | |||
| 2419 | address eui64_addr; | |||
| 2420 | /* manuf_name_lookup returns a hashmanuf_t* that covers an entire /24, | |||
| 2421 | * so we can't properly use it for MA-M and MA-S. We do want to check | |||
| 2422 | * it first so it also covers the user-defined tables. | |||
| 2423 | */ | |||
| 2424 | manuf_value = manuf_name_lookup(addr, addr_size); | |||
| 2425 | if ((manuf_value != NULL((void*)0)) && ((manuf_value->flags & NAME_RESOLVED(1U<<1)) == NAME_RESOLVED(1U<<1))) { | |||
| 2426 | snprintf(tp->resolved_name, MAXNAMELEN64, "%.*s_%02x:%02x:%02x:%02x:%02x", | |||
| 2427 | MAXNAMELEN64 - 16, manuf_value->resolved_name, addr[3], addr[4], addr[5], addr[6], addr[7]); | |||
| 2428 | tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4); | |||
| 2429 | return tp; | |||
| 2430 | } | |||
| 2431 | ||||
| 2432 | /* Now try looking in the global manuf data for a MA-M or MA-S | |||
| 2433 | * match. We do this last so that the other files override this | |||
| 2434 | * result. | |||
| 2435 | */ | |||
| 2436 | const char *short_name, *long_name; | |||
| 2437 | short_name = ws_manuf_lookup(addr, &long_name, &mask); | |||
| 2438 | if (short_name != NULL((void*)0)) { | |||
| 2439 | if (mask == 24) { | |||
| 2440 | /* This shouldn't happen as it should be handled above, | |||
| 2441 | * but it doesn't hurt. | |||
| 2442 | */ | |||
| 2443 | manuf_hash_new_entry(addr, short_name, long_name); | |||
| 2444 | } | |||
| 2445 | eui64_resolved_name_fill(tp, short_name, mask, addr); | |||
| 2446 | tp->flags |= NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4); | |||
| 2447 | return tp; | |||
| 2448 | } | |||
| 2449 | /* No match whatsoever. */ | |||
| 2450 | set_address(&eui64_addr, AT_EUI64, 8, addr); | |||
| 2451 | address_to_str_buf(&eui64_addr, tp->resolved_name, MAXNAMELEN64); | |||
| 2452 | return tp; | |||
| 2453 | } | |||
| 2454 | ||||
| 2455 | return tp; | |||
| 2456 | } /* eui64_addr_resolve */ | |||
| 2457 | ||||
| 2458 | static hasheui64_t * | |||
| 2459 | eui64_hash_new_entry(const uint8_t *addr, const bool_Bool resolve) | |||
| 2460 | { | |||
| 2461 | hasheui64_t *tp; | |||
| 2462 | char *endp; | |||
| 2463 | ||||
| 2464 | tp = wmem_new(addr_resolv_scope, hasheui64_t)((hasheui64_t*)wmem_alloc((addr_resolv_scope), sizeof(hasheui64_t ))); | |||
| 2465 | memcpy(tp->addr, addr, sizeof(tp->addr)); | |||
| 2466 | tp->flags = 0; | |||
| 2467 | /* Values returned by bytes_to_hexstr_punct() are *not* null-terminated */ | |||
| 2468 | endp = bytes_to_hexstr_punct(tp->hexaddr, addr, sizeof(tp->addr), ':'); | |||
| 2469 | *endp = '\0'; | |||
| 2470 | tp->resolved_name[0] = '\0'; | |||
| 2471 | ||||
| 2472 | if (resolve) | |||
| 2473 | eui64_addr_resolve(tp); | |||
| 2474 | ||||
| 2475 | wmem_map_insert(eui64_hashtable, tp->addr, tp); | |||
| 2476 | ||||
| 2477 | return tp; | |||
| 2478 | } /* eui64_hash_new_entry */ | |||
| 2479 | ||||
| 2480 | static hasheui64_t * | |||
| 2481 | add_eui64_name(const uint8_t *addr, const char *name, bool_Bool static_entry) | |||
| 2482 | { | |||
| 2483 | hasheui64_t *tp; | |||
| 2484 | ||||
| 2485 | tp = (hasheui64_t *)wmem_map_lookup(eui64_hashtable, addr); | |||
| 2486 | ||||
| 2487 | if (tp == NULL((void*)0)) { | |||
| 2488 | tp = eui64_hash_new_entry(addr, false0); | |||
| 2489 | } | |||
| 2490 | ||||
| 2491 | if (strcmp(tp->resolved_name, name) != 0 && (static_entry || !(tp->flags & STATIC_HOSTNAME(1U<<3)))) { | |||
| 2492 | (void) g_strlcpy(tp->resolved_name, name, MAXNAMELEN64); | |||
| 2493 | tp->flags |= NAME_RESOLVED(1U<<1); | |||
| 2494 | if (static_entry) { | |||
| 2495 | tp->flags |= STATIC_HOSTNAME(1U<<3); | |||
| 2496 | } | |||
| 2497 | new_resolved_objects = true1; | |||
| 2498 | } | |||
| 2499 | ||||
| 2500 | return tp; | |||
| 2501 | } /* add_eui64_name */ | |||
| 2502 | ||||
| 2503 | static hasheui64_t * | |||
| 2504 | eui64_name_lookup(const uint8_t *addr, const bool_Bool resolve) | |||
| 2505 | { | |||
| 2506 | hasheui64_t *tp; | |||
| 2507 | ||||
| 2508 | tp = (hasheui64_t *)wmem_map_lookup(eui64_hashtable, addr); | |||
| 2509 | ||||
| 2510 | if (tp == NULL((void*)0)) { | |||
| 2511 | tp = eui64_hash_new_entry(addr, resolve); | |||
| 2512 | } else { | |||
| 2513 | if (resolve && !(tp->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1)))) { | |||
| 2514 | eui64_addr_resolve(tp); /* Found but needs to be resolved */ | |||
| 2515 | } | |||
| 2516 | } | |||
| 2517 | if (resolve) { | |||
| 2518 | tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0); | |||
| 2519 | } | |||
| 2520 | ||||
| 2521 | return tp; | |||
| 2522 | ||||
| 2523 | } /* eui64_name_lookup */ | |||
| 2524 | ||||
| 2525 | /* IPXNETS */ | |||
| 2526 | static int | |||
| 2527 | parse_ipxnets_line(char *line, ipxnet_t *ipxnet) | |||
| 2528 | { | |||
| 2529 | /* | |||
| 2530 | * We allow three address separators (':', '-', and '.'), | |||
| 2531 | * as well as no separators | |||
| 2532 | */ | |||
| 2533 | ||||
| 2534 | char *cp; | |||
| 2535 | uint32_t a, a0, a1, a2, a3; | |||
| 2536 | bool_Bool found_single_number = false0; | |||
| 2537 | ||||
| 2538 | if ((cp = strchr(line, '#'))) | |||
| 2539 | *cp = '\0'; | |||
| 2540 | ||||
| 2541 | if ((cp = strtok(line, " \t\n")) == NULL((void*)0)) | |||
| 2542 | return -1; | |||
| 2543 | ||||
| 2544 | /* Either fill a0,a1,a2,a3 and found_single_number is false, | |||
| 2545 | * fill a and found_single_number is true, | |||
| 2546 | * or return -1 | |||
| 2547 | */ | |||
| 2548 | if (sscanf(cp, "%x:%x:%x:%x", &a0, &a1, &a2, &a3) != 4) { | |||
| 2549 | if (sscanf(cp, "%x-%x-%x-%x", &a0, &a1, &a2, &a3) != 4) { | |||
| 2550 | if (sscanf(cp, "%x.%x.%x.%x", &a0, &a1, &a2, &a3) != 4) { | |||
| 2551 | if (sscanf(cp, "%x", &a) == 1) { | |||
| 2552 | found_single_number = true1; | |||
| 2553 | } | |||
| 2554 | else { | |||
| 2555 | return -1; | |||
| 2556 | } | |||
| 2557 | } | |||
| 2558 | } | |||
| 2559 | } | |||
| 2560 | ||||
| 2561 | if ((cp = strtok(NULL((void*)0), " \t\n")) == NULL((void*)0)) | |||
| 2562 | return -1; | |||
| 2563 | ||||
| 2564 | if (found_single_number) { | |||
| 2565 | ipxnet->addr = a; | |||
| 2566 | } | |||
| 2567 | else { | |||
| 2568 | ipxnet->addr = (a0 << 24) | (a1 << 16) | (a2 << 8) | a3; | |||
| 2569 | } | |||
| 2570 | ||||
| 2571 | (void) g_strlcpy(ipxnet->name, cp, MAXNAMELEN64); | |||
| 2572 | ||||
| 2573 | return 0; | |||
| 2574 | ||||
| 2575 | } /* parse_ipxnets_line */ | |||
| 2576 | ||||
| 2577 | static FILE *ipxnet_p; | |||
| 2578 | ||||
| 2579 | static void | |||
| 2580 | set_ipxnetent(char *path) | |||
| 2581 | { | |||
| 2582 | if (ipxnet_p) | |||
| 2583 | rewind(ipxnet_p); | |||
| 2584 | else | |||
| 2585 | ipxnet_p = ws_fopenfopen(path, "r"); | |||
| 2586 | } | |||
| 2587 | ||||
| 2588 | static void | |||
| 2589 | end_ipxnetent(void) | |||
| 2590 | { | |||
| 2591 | if (ipxnet_p) { | |||
| 2592 | fclose(ipxnet_p); | |||
| 2593 | ipxnet_p = NULL((void*)0); | |||
| 2594 | } | |||
| 2595 | } | |||
| 2596 | ||||
| 2597 | static ipxnet_t * | |||
| 2598 | get_ipxnetent(void) | |||
| 2599 | { | |||
| 2600 | ||||
| 2601 | static ipxnet_t ipxnet; | |||
| 2602 | char buf[MAX_LINELEN1024]; | |||
| 2603 | ||||
| 2604 | if (ipxnet_p == NULL((void*)0)) | |||
| 2605 | return NULL((void*)0); | |||
| 2606 | ||||
| 2607 | while (fgetline(buf, sizeof(buf), ipxnet_p) >= 0) { | |||
| 2608 | if (parse_ipxnets_line(buf, &ipxnet) == 0) { | |||
| 2609 | return &ipxnet; | |||
| 2610 | } | |||
| 2611 | } | |||
| 2612 | ||||
| 2613 | return NULL((void*)0); | |||
| 2614 | ||||
| 2615 | } /* get_ipxnetent */ | |||
| 2616 | ||||
| 2617 | static ipxnet_t * | |||
| 2618 | get_ipxnetbyaddr(uint32_t addr) | |||
| 2619 | { | |||
| 2620 | ipxnet_t *ipxnet; | |||
| 2621 | ||||
| 2622 | set_ipxnetent(g_ipxnets_path); | |||
| 2623 | ||||
| 2624 | while (((ipxnet = get_ipxnetent()) != NULL((void*)0)) && (addr != ipxnet->addr) ) ; | |||
| 2625 | ||||
| 2626 | if (ipxnet == NULL((void*)0)) { | |||
| 2627 | end_ipxnetent(); | |||
| 2628 | ||||
| 2629 | set_ipxnetent(g_pipxnets_path); | |||
| 2630 | ||||
| 2631 | while (((ipxnet = get_ipxnetent()) != NULL((void*)0)) && (addr != ipxnet->addr) ) | |||
| 2632 | ; | |||
| 2633 | ||||
| 2634 | end_ipxnetent(); | |||
| 2635 | } | |||
| 2636 | ||||
| 2637 | return ipxnet; | |||
| 2638 | ||||
| 2639 | } /* get_ipxnetbyaddr */ | |||
| 2640 | ||||
| 2641 | static void | |||
| 2642 | initialize_ipxnets(void) | |||
| 2643 | { | |||
| 2644 | /* Compute the pathname of the ipxnets file. | |||
| 2645 | * | |||
| 2646 | * XXX - is there a notion of an "ipxnets file" in any flavor of | |||
| 2647 | * UNIX, or with any add-on Netware package for UNIX? If not, | |||
| 2648 | * should the UNIX version of the ipxnets file be in the datafile | |||
| 2649 | * directory as well? | |||
| 2650 | */ | |||
| 2651 | if (g_ipxnets_path == NULL((void*)0)) { | |||
| 2652 | g_ipxnets_path = wmem_strdup_printf(addr_resolv_scope, "%s" G_DIR_SEPARATOR_S"/" "%s", | |||
| 2653 | get_systemfile_dir(), ENAME_IPXNETS"ipxnets"); | |||
| 2654 | } | |||
| 2655 | ||||
| 2656 | /* Set g_pipxnets_path here, but don't actually do anything | |||
| 2657 | * with it. It's used in get_ipxnetbyaddr(). | |||
| 2658 | */ | |||
| 2659 | if (g_pipxnets_path == NULL((void*)0)) { | |||
| 2660 | /* Check profile directory before personal configuration */ | |||
| 2661 | g_pipxnets_path = get_persconffile_path(ENAME_IPXNETS"ipxnets", true1); | |||
| 2662 | if (!file_exists(g_pipxnets_path)) { | |||
| 2663 | g_free(g_pipxnets_path); | |||
| 2664 | g_pipxnets_path = get_persconffile_path(ENAME_IPXNETS"ipxnets", false0); | |||
| 2665 | } | |||
| 2666 | } | |||
| 2667 | ||||
| 2668 | } /* initialize_ipxnets */ | |||
| 2669 | ||||
| 2670 | static void | |||
| 2671 | ipx_name_lookup_cleanup(void) | |||
| 2672 | { | |||
| 2673 | g_ipxnets_path = NULL((void*)0); | |||
| 2674 | g_free(g_pipxnets_path); | |||
| 2675 | g_pipxnets_path = NULL((void*)0); | |||
| 2676 | } | |||
| 2677 | ||||
| 2678 | static char * | |||
| 2679 | ipxnet_name_lookup(wmem_allocator_t *allocator, const unsigned addr) | |||
| 2680 | { | |||
| 2681 | hashipxnet_t *tp; | |||
| 2682 | ipxnet_t *ipxnet; | |||
| 2683 | ||||
| 2684 | tp = (hashipxnet_t *)wmem_map_lookup(ipxnet_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr))); | |||
| 2685 | if (tp == NULL((void*)0)) { | |||
| 2686 | tp = wmem_new(addr_resolv_scope, hashipxnet_t)((hashipxnet_t*)wmem_alloc((addr_resolv_scope), sizeof(hashipxnet_t ))); | |||
| 2687 | wmem_map_insert(ipxnet_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr)), tp); | |||
| 2688 | } else { | |||
| 2689 | return wmem_strdup(allocator, tp->name); | |||
| 2690 | } | |||
| 2691 | ||||
| 2692 | /* fill in a new entry */ | |||
| 2693 | ||||
| 2694 | tp->addr = addr; | |||
| 2695 | ||||
| 2696 | if ( (ipxnet = get_ipxnetbyaddr(addr)) == NULL((void*)0)) { | |||
| 2697 | /* unknown name */ | |||
| 2698 | snprintf(tp->name, MAXNAMELEN64, "%X", addr); | |||
| 2699 | ||||
| 2700 | } else { | |||
| 2701 | (void) g_strlcpy(tp->name, ipxnet->name, MAXNAMELEN64); | |||
| 2702 | } | |||
| 2703 | ||||
| 2704 | return wmem_strdup(allocator, tp->name); | |||
| 2705 | ||||
| 2706 | } /* ipxnet_name_lookup */ | |||
| 2707 | ||||
| 2708 | /* VLANS */ | |||
| 2709 | static int | |||
| 2710 | parse_vlan_line(char *line, vlan_t *vlan) | |||
| 2711 | { | |||
| 2712 | char *cp; | |||
| 2713 | uint16_t id; | |||
| 2714 | ||||
| 2715 | if ((cp = strchr(line, '#'))) | |||
| 2716 | *cp = '\0'; | |||
| 2717 | ||||
| 2718 | if ((cp = strtok(line, " \t\n")) == NULL((void*)0)) | |||
| 2719 | return -1; | |||
| 2720 | ||||
| 2721 | if (sscanf(cp, "%" SCNu16"hu", &id) == 1) { | |||
| 2722 | vlan->id = id; | |||
| 2723 | } | |||
| 2724 | else { | |||
| 2725 | return -1; | |||
| 2726 | } | |||
| 2727 | ||||
| 2728 | if ((cp = strtok(NULL((void*)0), "\t\n")) == NULL((void*)0)) | |||
| 2729 | return -1; | |||
| 2730 | ||||
| 2731 | (void) g_strlcpy(vlan->name, cp, MAXVLANNAMELEN128); | |||
| 2732 | ||||
| 2733 | return 0; | |||
| 2734 | ||||
| 2735 | } /* parse_vlan_line */ | |||
| 2736 | ||||
| 2737 | static FILE *vlan_p; | |||
| 2738 | ||||
| 2739 | static void | |||
| 2740 | set_vlanent(char *path) | |||
| 2741 | { | |||
| 2742 | if (vlan_p) | |||
| 2743 | rewind(vlan_p); | |||
| 2744 | else | |||
| 2745 | vlan_p = ws_fopenfopen(path, "r"); | |||
| 2746 | } | |||
| 2747 | ||||
| 2748 | static void | |||
| 2749 | end_vlanent(void) | |||
| 2750 | { | |||
| 2751 | if (vlan_p) { | |||
| 2752 | fclose(vlan_p); | |||
| 2753 | vlan_p = NULL((void*)0); | |||
| 2754 | } | |||
| 2755 | } | |||
| 2756 | ||||
| 2757 | static vlan_t * | |||
| 2758 | get_vlanent(void) | |||
| 2759 | { | |||
| 2760 | ||||
| 2761 | static vlan_t vlan; | |||
| 2762 | char buf[MAX_LINELEN1024]; | |||
| 2763 | ||||
| 2764 | if (vlan_p == NULL((void*)0)) | |||
| 2765 | return NULL((void*)0); | |||
| 2766 | ||||
| 2767 | while (fgetline(buf, sizeof(buf), vlan_p) >= 0) { | |||
| 2768 | if (parse_vlan_line(buf, &vlan) == 0) { | |||
| 2769 | return &vlan; | |||
| 2770 | } | |||
| 2771 | } | |||
| 2772 | ||||
| 2773 | return NULL((void*)0); | |||
| 2774 | ||||
| 2775 | } /* get_vlanent */ | |||
| 2776 | ||||
| 2777 | static vlan_t * | |||
| 2778 | get_vlannamebyid(uint16_t id) | |||
| 2779 | { | |||
| 2780 | vlan_t *vlan; | |||
| 2781 | ||||
| 2782 | set_vlanent(g_pvlan_path); | |||
| 2783 | ||||
| 2784 | while (((vlan = get_vlanent()) != NULL((void*)0)) && (id != vlan->id) ) ; | |||
| 2785 | ||||
| 2786 | if (vlan == NULL((void*)0)) { | |||
| 2787 | end_vlanent(); | |||
| 2788 | ||||
| 2789 | } | |||
| 2790 | ||||
| 2791 | return vlan; | |||
| 2792 | ||||
| 2793 | } /* get_vlannamebyid */ | |||
| 2794 | ||||
| 2795 | static void | |||
| 2796 | initialize_vlans(void) | |||
| 2797 | { | |||
| 2798 | 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", 2798, __func__, "assertion failed: %s" , "vlan_hash_table == ((void*)0)"); } while (0); | |||
| 2799 | vlan_hash_table = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal); | |||
| 2800 | ||||
| 2801 | /* Set g_pvlan_path here, but don't actually do anything | |||
| 2802 | * with it. It's used in get_vlannamebyid() | |||
| 2803 | */ | |||
| 2804 | if (g_pvlan_path == NULL((void*)0)) { | |||
| 2805 | /* Check profile directory before personal configuration */ | |||
| 2806 | g_pvlan_path = get_persconffile_path(ENAME_VLANS"vlans", true1); | |||
| 2807 | if (!file_exists(g_pvlan_path)) { | |||
| 2808 | g_free(g_pvlan_path); | |||
| 2809 | g_pvlan_path = get_persconffile_path(ENAME_VLANS"vlans", false0); | |||
| 2810 | } | |||
| 2811 | } | |||
| 2812 | } /* initialize_vlans */ | |||
| 2813 | ||||
| 2814 | static void | |||
| 2815 | vlan_name_lookup_cleanup(void) | |||
| 2816 | { | |||
| 2817 | end_vlanent(); | |||
| 2818 | vlan_hash_table = NULL((void*)0); | |||
| 2819 | g_free(g_pvlan_path); | |||
| 2820 | g_pvlan_path = NULL((void*)0); | |||
| 2821 | } | |||
| 2822 | ||||
| 2823 | static const char * | |||
| 2824 | vlan_name_lookup(const unsigned id) | |||
| 2825 | { | |||
| 2826 | hashvlan_t *tp; | |||
| 2827 | vlan_t *vlan; | |||
| 2828 | ||||
| 2829 | tp = (hashvlan_t *)wmem_map_lookup(vlan_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id))); | |||
| 2830 | if (tp == NULL((void*)0)) { | |||
| 2831 | tp = wmem_new(addr_resolv_scope, hashvlan_t)((hashvlan_t*)wmem_alloc((addr_resolv_scope), sizeof(hashvlan_t ))); | |||
| 2832 | wmem_map_insert(vlan_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)), tp); | |||
| 2833 | } else { | |||
| 2834 | return tp->name; | |||
| 2835 | } | |||
| 2836 | ||||
| 2837 | /* fill in a new entry */ | |||
| 2838 | ||||
| 2839 | tp->id = id; | |||
| 2840 | ||||
| 2841 | if ( (vlan = get_vlannamebyid(id)) == NULL((void*)0)) { | |||
| 2842 | /* unknown name */ | |||
| 2843 | snprintf(tp->name, MAXVLANNAMELEN128, "<%u>", id); | |||
| 2844 | ||||
| 2845 | } else { | |||
| 2846 | (void) g_strlcpy(tp->name, vlan->name, MAXVLANNAMELEN128); | |||
| 2847 | } | |||
| 2848 | ||||
| 2849 | return tp->name; | |||
| 2850 | ||||
| 2851 | } /* vlan_name_lookup */ | |||
| 2852 | /* VLAN END */ | |||
| 2853 | ||||
| 2854 | static bool_Bool | |||
| 2855 | read_hosts_file (const char *hostspath, bool_Bool store_entries) | |||
| 2856 | { | |||
| 2857 | FILE *hf; | |||
| 2858 | char line[MAX_LINELEN1024]; | |||
| 2859 | char *cp; | |||
| 2860 | union { | |||
| 2861 | uint32_t ip4_addr; | |||
| 2862 | ws_in6_addr ip6_addr; | |||
| 2863 | } host_addr; | |||
| 2864 | bool_Bool is_ipv6, entry_found = false0; | |||
| 2865 | ||||
| 2866 | /* | |||
| 2867 | * See the hosts(4) or hosts(5) man page for hosts file format | |||
| 2868 | * (not available on all systems). | |||
| 2869 | */ | |||
| 2870 | if ((hf = ws_fopenfopen(hostspath, "r")) == NULL((void*)0)) | |||
| 2871 | return false0; | |||
| 2872 | ||||
| 2873 | while (fgetline(line, sizeof(line), hf) >= 0) { | |||
| 2874 | if ((cp = strchr(line, '#'))) | |||
| 2875 | *cp = '\0'; | |||
| 2876 | ||||
| 2877 | if ((cp = strtok(line, " \t")) == NULL((void*)0)) | |||
| 2878 | continue; /* no tokens in the line */ | |||
| 2879 | ||||
| 2880 | if (ws_inet_pton6(cp, &host_addr.ip6_addr)) { | |||
| 2881 | /* Valid IPv6 */ | |||
| 2882 | is_ipv6 = true1; | |||
| 2883 | } else if (ws_inet_pton4(cp, &host_addr.ip4_addr)) { | |||
| 2884 | /* Valid IPv4 */ | |||
| 2885 | is_ipv6 = false0; | |||
| 2886 | } else { | |||
| 2887 | continue; | |||
| 2888 | } | |||
| 2889 | ||||
| 2890 | if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0)) | |||
| 2891 | continue; /* no host name */ | |||
| 2892 | ||||
| 2893 | entry_found = true1; | |||
| 2894 | if (store_entries) { | |||
| 2895 | if (is_ipv6) { | |||
| 2896 | add_ipv6_name(&host_addr.ip6_addr, cp, true1); | |||
| 2897 | } else { | |||
| 2898 | add_ipv4_name(host_addr.ip4_addr, cp, true1); | |||
| 2899 | } | |||
| 2900 | } | |||
| 2901 | } | |||
| 2902 | ||||
| 2903 | fclose(hf); | |||
| 2904 | return entry_found
| |||
| 2905 | } /* read_hosts_file */ | |||
| 2906 | ||||
| 2907 | bool_Bool | |||
| 2908 | add_hosts_file (const char *hosts_file) | |||
| 2909 | { | |||
| 2910 | bool_Bool found = false0; | |||
| 2911 | unsigned i; | |||
| 2912 | ||||
| 2913 | if (!hosts_file) | |||
| 2914 | return false0; | |||
| 2915 | ||||
| 2916 | if (!extra_hosts_files) | |||
| 2917 | extra_hosts_files = g_ptr_array_new(); | |||
| 2918 | ||||
| 2919 | for (i = 0; i < extra_hosts_files->len; i++) { | |||
| 2920 | if (strcmp(hosts_file, (const char *) g_ptr_array_index(extra_hosts_files, i)((extra_hosts_files)->pdata)[i]) == 0) | |||
| 2921 | found = true1; | |||
| 2922 | } | |||
| 2923 | ||||
| 2924 | if (!found) { | |||
| 2925 | g_ptr_array_add(extra_hosts_files, wmem_strdup(wmem_epan_scope(), hosts_file)); | |||
| 2926 | return read_hosts_file (hosts_file, false0); | |||
| 2927 | } | |||
| 2928 | return true1; | |||
| 2929 | } | |||
| 2930 | ||||
| 2931 | bool_Bool | |||
| 2932 | add_ip_name_from_string (const char *addr, const char *name) | |||
| 2933 | { | |||
| 2934 | union { | |||
| 2935 | uint32_t ip4_addr; | |||
| 2936 | ws_in6_addr ip6_addr; | |||
| 2937 | } host_addr; | |||
| 2938 | bool_Bool is_ipv6; | |||
| 2939 | resolved_name_t *resolved_entry; | |||
| 2940 | ||||
| 2941 | if (ws_inet_pton6(addr, &host_addr.ip6_addr)) { | |||
| 2942 | is_ipv6 = true1; | |||
| 2943 | } else if (ws_inet_pton4(addr, &host_addr.ip4_addr)) { | |||
| 2944 | is_ipv6 = false0; | |||
| 2945 | } else { | |||
| 2946 | return false0; | |||
| 2947 | } | |||
| 2948 | ||||
| 2949 | if (is_ipv6) { | |||
| 2950 | resolved_entry = (resolved_name_t*)wmem_map_lookup(manually_resolved_ipv6_list, &host_addr.ip6_addr); | |||
| 2951 | if (resolved_entry) | |||
| 2952 | { | |||
| 2953 | // If we found a previous matching key (IP address), then just update the value (custom hostname); | |||
| 2954 | (void) g_strlcpy(resolved_entry->name, name, MAXDNSNAMELEN256); | |||
| 2955 | } | |||
| 2956 | else | |||
| 2957 | { | |||
| 2958 | // Add a new mapping entry, if this IP address isn't already in the list. | |||
| 2959 | 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 ))); | |||
| 2960 | memcpy(addr_key, &host_addr.ip6_addr, sizeof(ws_in6_addr)); | |||
| 2961 | ||||
| 2962 | resolved_entry = wmem_new(wmem_epan_scope(), resolved_name_t)((resolved_name_t*)wmem_alloc((wmem_epan_scope()), sizeof(resolved_name_t ))); | |||
| 2963 | (void) g_strlcpy(resolved_entry->name, name, MAXDNSNAMELEN256); | |||
| 2964 | ||||
| 2965 | wmem_map_insert(manually_resolved_ipv6_list, addr_key, resolved_entry); | |||
| 2966 | } | |||
| 2967 | } else { | |||
| 2968 | 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))); | |||
| 2969 | if (resolved_entry) | |||
| 2970 | { | |||
| 2971 | // If we found a previous matching key (IP address), then just update the value (custom hostname); | |||
| 2972 | (void) g_strlcpy(resolved_entry->name, name, MAXDNSNAMELEN256); | |||
| 2973 | } | |||
| 2974 | else | |||
| 2975 | { | |||
| 2976 | // Add a new mapping entry, if this IP address isn't already in the list. | |||
| 2977 | resolved_entry = wmem_new(wmem_epan_scope(), resolved_name_t)((resolved_name_t*)wmem_alloc((wmem_epan_scope()), sizeof(resolved_name_t ))); | |||
| 2978 | (void) g_strlcpy(resolved_entry->name, name, MAXDNSNAMELEN256); | |||
| 2979 | ||||
| 2980 | wmem_map_insert(manually_resolved_ipv4_list, GUINT_TO_POINTER(host_addr.ip4_addr)((gpointer) (gulong) (host_addr.ip4_addr)), resolved_entry); | |||
| 2981 | } | |||
| 2982 | } | |||
| 2983 | ||||
| 2984 | return true1; | |||
| 2985 | } /* add_ip_name_from_string */ | |||
| 2986 | ||||
| 2987 | extern resolved_name_t* get_edited_resolved_name(const char* addr) | |||
| 2988 | { | |||
| 2989 | uint32_t ip4_addr; | |||
| 2990 | ws_in6_addr ip6_addr; | |||
| 2991 | resolved_name_t* resolved_entry = NULL((void*)0); | |||
| 2992 | ||||
| 2993 | if (ws_inet_pton6(addr, &ip6_addr)) { | |||
| 2994 | resolved_entry = (resolved_name_t*)wmem_map_lookup(manually_resolved_ipv6_list, &ip6_addr); | |||
| 2995 | } | |||
| 2996 | else if (ws_inet_pton4(addr, &ip4_addr)) { | |||
| 2997 | resolved_entry = (resolved_name_t*)wmem_map_lookup(manually_resolved_ipv4_list, GUINT_TO_POINTER(ip4_addr)((gpointer) (gulong) (ip4_addr))); | |||
| 2998 | } | |||
| 2999 | ||||
| 3000 | return resolved_entry; | |||
| 3001 | } | |||
| 3002 | ||||
| 3003 | /* | |||
| 3004 | * Add the resolved addresses that are in use to the list used to create the pcapng NRB | |||
| 3005 | */ | |||
| 3006 | static void | |||
| 3007 | ipv4_hash_table_resolved_to_list(void *key _U___attribute__((unused)), void *value, void *user_data) | |||
| 3008 | { | |||
| 3009 | addrinfo_lists_t *lists = (addrinfo_lists_t *)user_data; | |||
| 3010 | hashipv4_t *ipv4_hash_table_entry = (hashipv4_t *)value; | |||
| 3011 | ||||
| 3012 | if ((ipv4_hash_table_entry->flags & USED_AND_RESOLVED_MASK((1U<<1) | (1U<<2))) == USED_AND_RESOLVED_MASK((1U<<1) | (1U<<2))) { | |||
| 3013 | lists->ipv4_addr_list = g_list_prepend(lists->ipv4_addr_list, ipv4_hash_table_entry); | |||
| 3014 | } | |||
| 3015 | } | |||
| 3016 | ||||
| 3017 | /* | |||
| 3018 | * Add the resolved addresses that are in use to the list used to create the pcapng NRB | |||
| 3019 | */ | |||
| 3020 | static void | |||
| 3021 | ipv6_hash_table_resolved_to_list(void *key _U___attribute__((unused)), void *value, void *user_data) | |||
| 3022 | { | |||
| 3023 | addrinfo_lists_t *lists = (addrinfo_lists_t *)user_data; | |||
| 3024 | hashipv6_t *ipv6_hash_table_entry = (hashipv6_t *)value; | |||
| 3025 | ||||
| 3026 | if ((ipv6_hash_table_entry->flags & USED_AND_RESOLVED_MASK((1U<<1) | (1U<<2))) == USED_AND_RESOLVED_MASK((1U<<1) | (1U<<2))) { | |||
| 3027 | lists->ipv6_addr_list = g_list_prepend(lists->ipv6_addr_list, ipv6_hash_table_entry); | |||
| 3028 | } | |||
| 3029 | } | |||
| 3030 | ||||
| 3031 | addrinfo_lists_t * | |||
| 3032 | get_addrinfo_list(void) | |||
| 3033 | { | |||
| 3034 | if (ipv4_hash_table) { | |||
| 3035 | wmem_map_foreach(ipv4_hash_table, ipv4_hash_table_resolved_to_list, &addrinfo_lists); | |||
| 3036 | } | |||
| 3037 | ||||
| 3038 | if (ipv6_hash_table) { | |||
| 3039 | wmem_map_foreach(ipv6_hash_table, ipv6_hash_table_resolved_to_list, &addrinfo_lists); | |||
| 3040 | } | |||
| 3041 | ||||
| 3042 | return &addrinfo_lists; | |||
| 3043 | } | |||
| 3044 | ||||
| 3045 | /* Read in a list of subnet definition - name pairs. | |||
| 3046 | * <line> = <comment> | <entry> | <whitespace> | |||
| 3047 | * <comment> = <whitespace>#<any> | |||
| 3048 | * <entry> = <subnet_definition> <whitespace> <subnet_name> [<comment>|<whitespace><any>] | |||
| 3049 | * <subnet_definition> = <ipv4_address> / <subnet_mask_length> | |||
| 3050 | * <ipv4_address> is a full address; it will be masked to get the subnet-ID. | |||
| 3051 | * <subnet_mask_length> is a decimal 1-31 | |||
| 3052 | * <subnet_name> is a string containing no whitespace. | |||
| 3053 | * <whitespace> = (space | tab)+ | |||
| 3054 | * Any malformed entries are ignored. | |||
| 3055 | * Any trailing data after the subnet_name is ignored. | |||
| 3056 | * | |||
| 3057 | * XXX Support IPv6 | |||
| 3058 | */ | |||
| 3059 | static bool_Bool | |||
| 3060 | read_subnets_file (const char *subnetspath) | |||
| 3061 | { | |||
| 3062 | FILE *hf; | |||
| 3063 | char line[MAX_LINELEN1024]; | |||
| 3064 | char *cp, *cp2; | |||
| 3065 | uint32_t host_addr; /* IPv4 ONLY */ | |||
| 3066 | uint8_t mask_length; | |||
| 3067 | ||||
| 3068 | if ((hf = ws_fopenfopen(subnetspath, "r")) == NULL((void*)0)) | |||
| 3069 | return false0; | |||
| 3070 | ||||
| 3071 | while (fgetline(line, sizeof(line), hf) >= 0) { | |||
| 3072 | if ((cp = strchr(line, '#'))) | |||
| 3073 | *cp = '\0'; | |||
| 3074 | ||||
| 3075 | if ((cp = strtok(line, " \t")) == NULL((void*)0)) | |||
| 3076 | continue; /* no tokens in the line */ | |||
| 3077 | ||||
| 3078 | ||||
| 3079 | /* Expected format is <IP4 address>/<subnet length> */ | |||
| 3080 | cp2 = strchr(cp, '/'); | |||
| 3081 | if (NULL((void*)0) == cp2) { | |||
| 3082 | /* No length */ | |||
| 3083 | continue; | |||
| 3084 | } | |||
| 3085 | *cp2 = '\0'; /* Cut token */ | |||
| 3086 | ++cp2 ; | |||
| 3087 | ||||
| 3088 | /* Check if this is a valid IPv4 address */ | |||
| 3089 | if (!str_to_ip(cp, &host_addr)) { | |||
| 3090 | continue; /* no */ | |||
| 3091 | } | |||
| 3092 | ||||
| 3093 | if (!ws_strtou8(cp2, NULL((void*)0), &mask_length) || mask_length == 0 || mask_length > 32) { | |||
| 3094 | continue; /* invalid mask length */ | |||
| 3095 | } | |||
| 3096 | ||||
| 3097 | if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0)) | |||
| 3098 | continue; /* no subnet name */ | |||
| 3099 | ||||
| 3100 | subnet_entry_set(host_addr, mask_length, cp); | |||
| 3101 | } | |||
| 3102 | ||||
| 3103 | fclose(hf); | |||
| 3104 | return true1; | |||
| 3105 | } /* read_subnets_file */ | |||
| 3106 | ||||
| 3107 | static subnet_entry_t | |||
| 3108 | subnet_lookup(const uint32_t addr) | |||
| 3109 | { | |||
| 3110 | subnet_entry_t subnet_entry; | |||
| 3111 | uint32_t i; | |||
| 3112 | ||||
| 3113 | /* Search mask lengths linearly, longest first */ | |||
| 3114 | ||||
| 3115 | i = SUBNETLENGTHSIZE32; | |||
| 3116 | while(have_subnet_entry && i > 0) { | |||
| 3117 | uint32_t masked_addr; | |||
| 3118 | subnet_length_entry_t* length_entry; | |||
| 3119 | ||||
| 3120 | /* Note that we run from 31 (length 32) to 0 (length 1) */ | |||
| 3121 | --i; | |||
| 3122 | ws_assert(i < SUBNETLENGTHSIZE)do { if ((1) && !(i < 32)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/addr_resolv.c", 3122, __func__, "assertion failed: %s" , "i < 32"); } while (0); | |||
| 3123 | ||||
| 3124 | ||||
| 3125 | length_entry = &subnet_length_entries[i]; | |||
| 3126 | ||||
| 3127 | if (NULL((void*)0) != length_entry->subnet_addresses) { | |||
| 3128 | sub_net_hashipv4_t * tp; | |||
| 3129 | uint32_t hash_idx; | |||
| 3130 | ||||
| 3131 | masked_addr = addr & length_entry->mask; | |||
| 3132 | 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)); | |||
| 3133 | ||||
| 3134 | tp = length_entry->subnet_addresses[hash_idx]; | |||
| 3135 | while(tp != NULL((void*)0) && tp->addr != masked_addr) { | |||
| 3136 | tp = tp->next; | |||
| 3137 | } | |||
| 3138 | ||||
| 3139 | if (NULL((void*)0) != tp) { | |||
| 3140 | subnet_entry.mask = length_entry->mask; | |||
| 3141 | subnet_entry.mask_length = i + 1; /* Length is offset + 1 */ | |||
| 3142 | subnet_entry.name = tp->name; | |||
| 3143 | return subnet_entry; | |||
| 3144 | } | |||
| 3145 | } | |||
| 3146 | } | |||
| 3147 | ||||
| 3148 | subnet_entry.mask = 0; | |||
| 3149 | subnet_entry.mask_length = 0; | |||
| 3150 | subnet_entry.name = NULL((void*)0); | |||
| 3151 | ||||
| 3152 | return subnet_entry; | |||
| 3153 | } | |||
| 3154 | ||||
| 3155 | /* Add a subnet-definition - name pair to the set. | |||
| 3156 | * The definition is taken by masking the address passed in with the mask of the | |||
| 3157 | * given length. | |||
| 3158 | */ | |||
| 3159 | static void | |||
| 3160 | subnet_entry_set(uint32_t subnet_addr, const uint8_t mask_length, const char* name) | |||
| 3161 | { | |||
| 3162 | subnet_length_entry_t* entry; | |||
| 3163 | sub_net_hashipv4_t * tp; | |||
| 3164 | size_t hash_idx; | |||
| 3165 | ||||
| 3166 | 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" , 3166, __func__, "assertion failed: %s", "mask_length > 0 && mask_length <= 32" ); } while (0); | |||
| 3167 | ||||
| 3168 | entry = &subnet_length_entries[mask_length - 1]; | |||
| 3169 | ||||
| 3170 | subnet_addr &= entry->mask; | |||
| 3171 | ||||
| 3172 | 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)); | |||
| 3173 | ||||
| 3174 | if (NULL((void*)0) == entry->subnet_addresses) { | |||
| 3175 | entry->subnet_addresses = (sub_net_hashipv4_t**)wmem_alloc0(addr_resolv_scope, sizeof(sub_net_hashipv4_t*) * HASHHOSTSIZE2048); | |||
| 3176 | } | |||
| 3177 | ||||
| 3178 | if (NULL((void*)0) != (tp = entry->subnet_addresses[hash_idx])) { | |||
| 3179 | sub_net_hashipv4_t * new_tp; | |||
| 3180 | ||||
| 3181 | while (tp->next) { | |||
| 3182 | if (tp->addr == subnet_addr) { | |||
| 3183 | return; /* XXX provide warning that an address was repeated? */ | |||
| 3184 | } else { | |||
| 3185 | tp = tp->next; | |||
| 3186 | } | |||
| 3187 | } | |||
| 3188 | ||||
| 3189 | 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))); | |||
| 3190 | tp->next = new_tp; | |||
| 3191 | tp = new_tp; | |||
| 3192 | } else { | |||
| 3193 | 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))); | |||
| 3194 | } | |||
| 3195 | ||||
| 3196 | tp->next = NULL((void*)0); | |||
| 3197 | tp->addr = subnet_addr; | |||
| 3198 | (void) g_strlcpy(tp->name, name, MAXNAMELEN64); /* This is longer than subnet names can actually be */ | |||
| 3199 | have_subnet_entry = true1; | |||
| 3200 | } | |||
| 3201 | ||||
| 3202 | static void | |||
| 3203 | subnet_name_lookup_init(void) | |||
| 3204 | { | |||
| 3205 | char* subnetspath; | |||
| 3206 | uint32_t i; | |||
| 3207 | ||||
| 3208 | for(i = 0; i < SUBNETLENGTHSIZE32; ++i) { | |||
| 3209 | uint32_t length = i + 1; | |||
| 3210 | ||||
| 3211 | subnet_length_entries[i].subnet_addresses = NULL((void*)0); | |||
| 3212 | subnet_length_entries[i].mask_length = length; | |||
| 3213 | 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)))))); | |||
| 3214 | } | |||
| 3215 | ||||
| 3216 | /* Check profile directory before personal configuration */ | |||
| 3217 | subnetspath = get_persconffile_path(ENAME_SUBNETS"subnets", true1); | |||
| 3218 | if (!read_subnets_file(subnetspath)) { | |||
| 3219 | if (errno(*__errno_location ()) != ENOENT2) { | |||
| 3220 | report_open_failure(subnetspath, errno(*__errno_location ()), false0); | |||
| 3221 | } | |||
| 3222 | ||||
| 3223 | g_free(subnetspath); | |||
| 3224 | subnetspath = get_persconffile_path(ENAME_SUBNETS"subnets", false0); | |||
| 3225 | if (!read_subnets_file(subnetspath) && errno(*__errno_location ()) != ENOENT2) { | |||
| 3226 | report_open_failure(subnetspath, errno(*__errno_location ()), false0); | |||
| 3227 | } | |||
| 3228 | } | |||
| 3229 | g_free(subnetspath); | |||
| 3230 | ||||
| 3231 | /* | |||
| 3232 | * Load the global subnets file, if we have one. | |||
| 3233 | */ | |||
| 3234 | subnetspath = get_datafile_path(ENAME_SUBNETS"subnets"); | |||
| 3235 | if (!read_subnets_file(subnetspath) && errno(*__errno_location ()) != ENOENT2) { | |||
| 3236 | report_open_failure(subnetspath, errno(*__errno_location ()), false0); | |||
| 3237 | } | |||
| 3238 | g_free(subnetspath); | |||
| 3239 | } | |||
| 3240 | ||||
| 3241 | /* SS7 PC Name Resolution Portion */ | |||
| 3242 | static hashss7pc_t * | |||
| 3243 | new_ss7pc(const uint8_t ni, const uint32_t pc) | |||
| 3244 | { | |||
| 3245 | hashss7pc_t *tp = wmem_new(addr_resolv_scope, hashss7pc_t)((hashss7pc_t*)wmem_alloc((addr_resolv_scope), sizeof(hashss7pc_t ))); | |||
| 3246 | tp->id = (ni<<24) + (pc&0xffffff); | |||
| 3247 | tp->pc_addr[0] = '\0'; | |||
| 3248 | tp->name[0] = '\0'; | |||
| 3249 | ||||
| 3250 | return tp; | |||
| 3251 | } | |||
| 3252 | ||||
| 3253 | static hashss7pc_t * | |||
| 3254 | host_lookup_ss7pc(const uint8_t ni, const uint32_t pc) | |||
| 3255 | { | |||
| 3256 | hashss7pc_t * volatile tp; | |||
| 3257 | uint32_t id; | |||
| 3258 | ||||
| 3259 | id = (ni<<24) + (pc&0xffffff); | |||
| 3260 | ||||
| 3261 | tp = (hashss7pc_t *)wmem_map_lookup(ss7pc_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id))); | |||
| 3262 | if (tp == NULL((void*)0)) { | |||
| 3263 | tp = new_ss7pc(ni, pc); | |||
| 3264 | wmem_map_insert(ss7pc_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)), tp); | |||
| 3265 | } | |||
| 3266 | ||||
| 3267 | return tp; | |||
| 3268 | } | |||
| 3269 | ||||
| 3270 | void fill_unresolved_ss7pc(const char * pc_addr, const uint8_t ni, const uint32_t pc) | |||
| 3271 | { | |||
| 3272 | hashss7pc_t *tp = host_lookup_ss7pc(ni, pc); | |||
| 3273 | ||||
| 3274 | (void) g_strlcpy(tp->pc_addr, pc_addr, MAXNAMELEN64); | |||
| 3275 | } | |||
| 3276 | ||||
| 3277 | const char * | |||
| 3278 | get_hostname_ss7pc(const uint8_t ni, const uint32_t pc) | |||
| 3279 | { | |||
| 3280 | hashss7pc_t *tp = host_lookup_ss7pc(ni, pc); | |||
| 3281 | ||||
| 3282 | /* never resolved yet*/ | |||
| 3283 | if (tp->pc_addr[0] == '\0') | |||
| 3284 | return tp->pc_addr; | |||
| 3285 | ||||
| 3286 | /* Don't have name in file */ | |||
| 3287 | if (tp->name[0] == '\0') | |||
| 3288 | return tp->pc_addr; | |||
| 3289 | ||||
| 3290 | if (!gbl_resolv_flags.ss7pc_name) | |||
| 3291 | return tp->pc_addr; | |||
| 3292 | ||||
| 3293 | return tp->name; | |||
| 3294 | } | |||
| 3295 | ||||
| 3296 | static void | |||
| 3297 | add_ss7pc_name(const uint8_t ni, uint32_t pc, const char *name) | |||
| 3298 | { | |||
| 3299 | hashss7pc_t *tp; | |||
| 3300 | uint32_t id; | |||
| 3301 | ||||
| 3302 | if (!name || name[0] == '\0') | |||
| 3303 | return; | |||
| 3304 | ||||
| 3305 | id = (ni<<24) + (pc&0xffffff); | |||
| 3306 | tp = (hashss7pc_t *)wmem_map_lookup(ss7pc_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id))); | |||
| 3307 | if (!tp) { | |||
| 3308 | tp = new_ss7pc(ni, pc); | |||
| 3309 | wmem_map_insert(ss7pc_hash_table, GUINT_TO_POINTER(id)((gpointer) (gulong) (id)), tp); | |||
| 3310 | } | |||
| 3311 | ||||
| 3312 | if (g_ascii_strcasecmp(tp->name, name)) { | |||
| 3313 | (void) g_strlcpy(tp->name, name, MAXNAMELEN64); | |||
| 3314 | } | |||
| 3315 | } | |||
| 3316 | ||||
| 3317 | static bool_Bool | |||
| 3318 | read_ss7pcs_file(const char *ss7pcspath) | |||
| 3319 | { | |||
| 3320 | FILE *hf; | |||
| 3321 | char line[MAX_LINELEN1024]; | |||
| 3322 | char *cp; | |||
| 3323 | uint8_t ni; | |||
| 3324 | uint32_t pc; | |||
| 3325 | bool_Bool entry_found = false0; | |||
| 3326 | ||||
| 3327 | /* | |||
| 3328 | * File format is Network Indicator (decimal)<dash>Point Code (Decimal)<tab/space>Hostname | |||
| 3329 | */ | |||
| 3330 | if ((hf = ws_fopenfopen(ss7pcspath, "r")) == NULL((void*)0)) | |||
| 3331 | return false0; | |||
| 3332 | ||||
| 3333 | while (fgetline(line, sizeof(line), hf) >= 0) { | |||
| 3334 | if ((cp = strchr(line, '#'))) | |||
| 3335 | *cp = '\0'; | |||
| 3336 | ||||
| 3337 | if ((cp = strtok(line, "-")) == NULL((void*)0)) | |||
| 3338 | continue; /*no ni-pc separator*/ | |||
| 3339 | if (!ws_strtou8(cp, NULL((void*)0), &ni)) | |||
| 3340 | continue; | |||
| 3341 | if (ni > 3) | |||
| 3342 | continue; | |||
| 3343 | ||||
| 3344 | if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0)) | |||
| 3345 | continue; /* no tokens for pc and name */ | |||
| 3346 | if (!ws_strtou32(cp, NULL((void*)0), &pc)) | |||
| 3347 | continue; | |||
| 3348 | if (pc >> 24 > 0) | |||
| 3349 | continue; | |||
| 3350 | ||||
| 3351 | if ((cp = strtok(NULL((void*)0), " \t")) == NULL((void*)0)) | |||
| 3352 | continue; /* no host name */ | |||
| 3353 | ||||
| 3354 | entry_found = true1; | |||
| 3355 | add_ss7pc_name(ni, pc, cp); | |||
| 3356 | } | |||
| 3357 | ||||
| 3358 | fclose(hf); | |||
| 3359 | return entry_found ? true1 : false0; | |||
| 3360 | } | |||
| 3361 | ||||
| 3362 | static void | |||
| 3363 | ss7pc_name_lookup_init(void) | |||
| 3364 | { | |||
| 3365 | char *ss7pcspath; | |||
| 3366 | ||||
| 3367 | 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", 3367, __func__, "assertion failed: %s" , "ss7pc_hash_table == ((void*)0)"); } while (0); | |||
| 3368 | ||||
| 3369 | ss7pc_hash_table = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal); | |||
| 3370 | ||||
| 3371 | /* | |||
| 3372 | * Load the user's ss7pcs file | |||
| 3373 | */ | |||
| 3374 | ss7pcspath = get_persconffile_path(ENAME_SS7PCS"ss7pcs", true1); | |||
| 3375 | if (!read_ss7pcs_file(ss7pcspath) && errno(*__errno_location ()) != ENOENT2) { | |||
| 3376 | report_open_failure(ss7pcspath, errno(*__errno_location ()), false0); | |||
| 3377 | } | |||
| 3378 | g_free(ss7pcspath); | |||
| 3379 | } | |||
| 3380 | ||||
| 3381 | /* SS7PC Name Resolution End*/ | |||
| 3382 | ||||
| 3383 | ||||
| 3384 | /* | |||
| 3385 | * External Functions | |||
| 3386 | */ | |||
| 3387 | ||||
| 3388 | void | |||
| 3389 | addr_resolve_pref_init(module_t *nameres) | |||
| 3390 | { | |||
| 3391 | prefs_register_bool_preference(nameres, "mac_name", | |||
| 3392 | "Resolve MAC addresses", | |||
| 3393 | "Resolve Ethernet MAC addresses to host names from the preferences" | |||
| 3394 | " or system's Ethers file, or to a manufacturer based name.", | |||
| 3395 | &gbl_resolv_flags.mac_name); | |||
| 3396 | ||||
| 3397 | prefs_register_bool_preference(nameres, "transport_name", | |||
| 3398 | "Resolve transport names", | |||
| 3399 | "Resolve TCP/UDP ports into service names", | |||
| 3400 | &gbl_resolv_flags.transport_name); | |||
| 3401 | ||||
| 3402 | prefs_register_bool_preference(nameres, "network_name", | |||
| 3403 | "Resolve network (IP) addresses", | |||
| 3404 | "Resolve IPv4, IPv6, and IPX addresses into host names." | |||
| 3405 | " The next set of check boxes determines how name resolution should be performed." | |||
| 3406 | " If no other options are checked name resolution is made from Wireshark's host file" | |||
| 3407 | " and capture file name resolution blocks.", | |||
| 3408 | &gbl_resolv_flags.network_name); | |||
| 3409 | ||||
| 3410 | prefs_register_bool_preference(nameres, "dns_pkt_addr_resolution", | |||
| 3411 | "Use captured DNS packet data for name resolution", | |||
| 3412 | "Use address/name pairs found in captured DNS packets for name resolution.", | |||
| 3413 | &gbl_resolv_flags.dns_pkt_addr_resolution); | |||
| 3414 | ||||
| 3415 | prefs_register_bool_preference(nameres, "handshake_sni_addr_resolution", | |||
| 3416 | "Use SNI information from captured handshake packets", | |||
| 3417 | "Use the Server Name Indication found in TLS handshakes for name resolution.", | |||
| 3418 | &gbl_resolv_flags.handshake_sni_addr_resolution); | |||
| 3419 | ||||
| 3420 | prefs_register_bool_preference(nameres, "use_external_name_resolver", | |||
| 3421 | "Use your system's DNS settings for name resolution", | |||
| 3422 | "Use your system's configured name resolver" | |||
| 3423 | " (usually DNS) to resolve network names." | |||
| 3424 | " Only applies when network name resolution" | |||
| 3425 | " is enabled.", | |||
| 3426 | &gbl_resolv_flags.use_external_net_name_resolver); | |||
| 3427 | ||||
| 3428 | prefs_register_bool_preference(nameres, "use_custom_dns_servers", | |||
| 3429 | "Use a custom list of DNS servers for name resolution", | |||
| 3430 | "Use a DNS Servers list to resolve network names if true. If false, default information is used", | |||
| 3431 | &use_custom_dns_server_list); | |||
| 3432 | ||||
| 3433 | static uat_field_t dns_server_uats_flds[] = { | |||
| 3434 | 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)}, | |||
| 3435 | 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)}, | |||
| 3436 | 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)}, | |||
| 3437 | UAT_END_FIELDS{((void*)0),((void*)0),PT_TXTMOD_NONE,{0,0,0},{0,0,0},0,0,((void *)0)} | |||
| 3438 | }; | |||
| 3439 | ||||
| 3440 | dnsserver_uat = uat_new("DNS Servers", | |||
| 3441 | sizeof(struct dns_server_data), | |||
| 3442 | "addr_resolve_dns_servers", /* filename */ | |||
| 3443 | true1, /* from_profile */ | |||
| 3444 | &dnsserverlist_uats, /* data_ptr */ | |||
| 3445 | &ndnsservers, /* numitems_ptr */ | |||
| 3446 | UAT_AFFECTS_DISSECTION0x00000001, | |||
| 3447 | NULL((void*)0), | |||
| 3448 | dns_server_copy_cb, | |||
| 3449 | NULL((void*)0), | |||
| 3450 | dns_server_free_cb, | |||
| 3451 | c_ares_set_dns_servers, | |||
| 3452 | NULL((void*)0), | |||
| 3453 | dns_server_uats_flds); | |||
| 3454 | static const char *dnsserver_uat_defaults[] = { NULL((void*)0), "53", "53" }; | |||
| 3455 | uat_set_default_values(dnsserver_uat, dnsserver_uat_defaults); | |||
| 3456 | prefs_register_uat_preference(nameres, "dns_servers", | |||
| 3457 | "DNS Servers", | |||
| 3458 | "A table of IPv4 and IPv6 addresses of DNS servers to be used to resolve IP names and addresses", | |||
| 3459 | dnsserver_uat); | |||
| 3460 | ||||
| 3461 | prefs_register_obsolete_preference(nameres, "concurrent_dns"); | |||
| 3462 | ||||
| 3463 | prefs_register_uint_preference(nameres, "name_resolve_concurrency", | |||
| 3464 | "Maximum concurrent requests", | |||
| 3465 | "The maximum number of DNS requests that may" | |||
| 3466 | " be active at any time. A large value (many" | |||
| 3467 | " thousands) might overload the network or make" | |||
| 3468 | " your DNS server behave badly.", | |||
| 3469 | 10, | |||
| 3470 | &name_resolve_concurrency); | |||
| 3471 | ||||
| 3472 | prefs_register_obsolete_preference(nameres, "hosts_file_handling"); | |||
| 3473 | ||||
| 3474 | prefs_register_bool_preference(nameres, "vlan_name", | |||
| 3475 | "Resolve VLAN IDs", | |||
| 3476 | "Resolve VLAN IDs to network names from the preferences \"vlans\" file." | |||
| 3477 | " Format of the file is: \"ID<Tab>Name\"." | |||
| 3478 | " One line per VLAN, e.g.: 1 Management", | |||
| 3479 | &gbl_resolv_flags.vlan_name); | |||
| 3480 | ||||
| 3481 | prefs_register_bool_preference(nameres, "ss7_pc_name", | |||
| 3482 | "Resolve SS7 PCs", | |||
| 3483 | "Resolve SS7 Point Codes to node names from the profiles \"ss7pcs\" file." | |||
| 3484 | " Format of the file is: \"Network_Indicator<Dash>PC_Decimal<Tab>Name\"." | |||
| 3485 | " One line per Point Code, e.g.: 2-1234 MyPointCode1", | |||
| 3486 | &gbl_resolv_flags.ss7pc_name); | |||
| 3487 | ||||
| 3488 | } | |||
| 3489 | ||||
| 3490 | void addr_resolve_pref_apply(void) | |||
| 3491 | { | |||
| 3492 | c_ares_set_dns_servers(); | |||
| 3493 | maxmind_db_pref_apply(); | |||
| 3494 | } | |||
| 3495 | ||||
| 3496 | void | |||
| 3497 | disable_name_resolution(void) { | |||
| 3498 | gbl_resolv_flags.mac_name = false0; | |||
| 3499 | gbl_resolv_flags.network_name = false0; | |||
| 3500 | gbl_resolv_flags.transport_name = false0; | |||
| 3501 | gbl_resolv_flags.dns_pkt_addr_resolution = false0; | |||
| 3502 | gbl_resolv_flags.handshake_sni_addr_resolution = false0; | |||
| 3503 | gbl_resolv_flags.use_external_net_name_resolver = false0; | |||
| 3504 | gbl_resolv_flags.vlan_name = false0; | |||
| 3505 | gbl_resolv_flags.ss7pc_name = false0; | |||
| 3506 | gbl_resolv_flags.maxmind_geoip = false0; | |||
| 3507 | } | |||
| 3508 | ||||
| 3509 | bool_Bool | |||
| 3510 | host_name_lookup_process(void) { | |||
| 3511 | struct timeval tv = { 0, 0 }; | |||
| 3512 | int nfds; | |||
| 3513 | fd_set rfds, wfds; | |||
| 3514 | bool_Bool nro = new_resolved_objects; | |||
| 3515 | ||||
| 3516 | new_resolved_objects = false0; | |||
| 3517 | nro |= maxmind_db_lookup_process(); | |||
| 3518 | ||||
| 3519 | if (!async_dns_initialized) | |||
| 3520 | /* c-ares not initialized. Bail out and cancel timers. */ | |||
| 3521 | return nro; | |||
| 3522 | ||||
| 3523 | process_async_dns_queue(); | |||
| 3524 | ||||
| 3525 | 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); | |||
| 3526 | 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); | |||
| 3527 | nfds = ares_fds(ghba_chan, &rfds, &wfds); | |||
| 3528 | if (nfds > 0) { | |||
| 3529 | if (select(nfds, &rfds, &wfds, NULL((void*)0), &tv) == -1) { /* call to select() failed */ | |||
| 3530 | /* If it's interrupted by a signal, no need to put out a message */ | |||
| 3531 | if (errno(*__errno_location ()) != EINTR4) | |||
| 3532 | fprintf(stderrstderr, "Warning: call to select() failed, error is %s\n", g_strerror(errno(*__errno_location ()))); | |||
| 3533 | return nro; | |||
| 3534 | } | |||
| 3535 | ares_process(ghba_chan, &rfds, &wfds); | |||
| 3536 | } | |||
| 3537 | ||||
| 3538 | /* Any new entries? */ | |||
| 3539 | return nro; | |||
| 3540 | } | |||
| 3541 | ||||
| 3542 | static void | |||
| 3543 | _host_name_lookup_cleanup(void) { | |||
| 3544 | async_dns_queue_head = NULL((void*)0); | |||
| 3545 | ||||
| 3546 | if (async_dns_initialized) { | |||
| 3547 | ares_destroy(ghba_chan); | |||
| 3548 | ares_destroy(ghbn_chan); | |||
| 3549 | } | |||
| 3550 | #ifdef CARES_HAVE_ARES_LIBRARY_INIT1 | |||
| 3551 | ares_library_cleanup(); | |||
| 3552 | #endif | |||
| 3553 | async_dns_initialized = false0; | |||
| 3554 | } | |||
| 3555 | ||||
| 3556 | const char * | |||
| 3557 | get_hostname(const unsigned addr) | |||
| 3558 | { | |||
| 3559 | /* XXX why do we call this if we're not resolving? To create hash entries? | |||
| 3560 | * Why? So that we can return a const char*? | |||
| 3561 | * | |||
| 3562 | * Note the returned string is in addr_resolv_scope, which has a similar | |||
| 3563 | * life to the global file scope (slightly larger, in that the resolved | |||
| 3564 | * addresses need to be available during dissector registration, e.g. | |||
| 3565 | * for RADIUS and enterprises), so if not copied it is possible to use | |||
| 3566 | * it after freeing. | |||
| 3567 | * | |||
| 3568 | * Should this be deprecated in favor of get_hostname_wmem so that | |||
| 3569 | * host name lookups don't increase persistent memory usage even when | |||
| 3570 | * hostname lookups are disabled? (An alternative would be to return | |||
| 3571 | * NULL when lookups are disabled, but callers don't expect that.) | |||
| 3572 | */ | |||
| 3573 | hashipv4_t *tp = host_lookup(addr); | |||
| 3574 | ||||
| 3575 | if (!gbl_resolv_flags.network_name) | |||
| 3576 | return tp->ip; | |||
| 3577 | ||||
| 3578 | tp->flags |= RESOLVED_ADDRESS_USED(1U<<2); | |||
| 3579 | ||||
| 3580 | return tp->name; | |||
| 3581 | } | |||
| 3582 | ||||
| 3583 | char * | |||
| 3584 | get_hostname_wmem(wmem_allocator_t *allocator, const unsigned addr) | |||
| 3585 | { | |||
| 3586 | if (!gbl_resolv_flags.network_name) | |||
| 3587 | return ip_addr_to_str(allocator, &addr); | |||
| 3588 | ||||
| 3589 | hashipv4_t *tp = host_lookup(addr); | |||
| 3590 | ||||
| 3591 | tp->flags |= RESOLVED_ADDRESS_USED(1U<<2); | |||
| 3592 | ||||
| 3593 | return wmem_strdup(allocator, tp->name); | |||
| 3594 | } | |||
| 3595 | /* -------------------------- */ | |||
| 3596 | ||||
| 3597 | const char * | |||
| 3598 | get_hostname6(const ws_in6_addr *addr) | |||
| 3599 | { | |||
| 3600 | /* XXX why do we call this if we're not resolving? To create hash entries? | |||
| 3601 | * Why? The same comments as get_hostname above apply. | |||
| 3602 | */ | |||
| 3603 | hashipv6_t *tp = host_lookup6(addr); | |||
| 3604 | ||||
| 3605 | if (!gbl_resolv_flags.network_name) | |||
| 3606 | return tp->ip6; | |||
| 3607 | ||||
| 3608 | tp->flags |= RESOLVED_ADDRESS_USED(1U<<2); | |||
| 3609 | ||||
| 3610 | return tp->name; | |||
| 3611 | } | |||
| 3612 | ||||
| 3613 | char * | |||
| 3614 | get_hostname6_wmem(wmem_allocator_t *allocator, const ws_in6_addr *addr) | |||
| 3615 | { | |||
| 3616 | if (!gbl_resolv_flags.network_name) | |||
| 3617 | return ip6_to_str(allocator, addr); | |||
| 3618 | ||||
| 3619 | hashipv6_t *tp = host_lookup6(addr); | |||
| 3620 | ||||
| 3621 | tp->flags |= RESOLVED_ADDRESS_USED(1U<<2); | |||
| 3622 | ||||
| 3623 | return wmem_strdup(allocator, tp->name); | |||
| 3624 | } | |||
| 3625 | /* -------------------------- */ | |||
| 3626 | void | |||
| 3627 | add_ipv4_name(const unsigned addr, const char *name, bool_Bool static_entry) | |||
| 3628 | { | |||
| 3629 | hashipv4_t *tp; | |||
| 3630 | ||||
| 3631 | /* | |||
| 3632 | * Don't add zero-length names; apparently, some resolvers will return | |||
| 3633 | * them if they get them from DNS. | |||
| 3634 | */ | |||
| 3635 | if (!name || name[0] == '\0') | |||
| 3636 | return; | |||
| 3637 | ||||
| 3638 | tp = (hashipv4_t *)wmem_map_lookup(ipv4_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr))); | |||
| 3639 | if (!tp) { | |||
| 3640 | tp = new_ipv4(addr); | |||
| 3641 | wmem_map_insert(ipv4_hash_table, GUINT_TO_POINTER(addr)((gpointer) (gulong) (addr)), tp); | |||
| 3642 | } | |||
| 3643 | ||||
| 3644 | if (g_ascii_strcasecmp(tp->name, name) && (static_entry || !(tp->flags & STATIC_HOSTNAME(1U<<3)))) { | |||
| 3645 | (void) g_strlcpy(tp->name, name, MAXDNSNAMELEN256); | |||
| 3646 | new_resolved_objects = true1; | |||
| 3647 | if (static_entry) | |||
| 3648 | tp->flags |= STATIC_HOSTNAME(1U<<3); | |||
| 3649 | } | |||
| 3650 | tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0)|NAME_RESOLVED(1U<<1); | |||
| 3651 | } /* add_ipv4_name */ | |||
| 3652 | ||||
| 3653 | /* -------------------------- */ | |||
| 3654 | void | |||
| 3655 | add_ipv6_name(const ws_in6_addr *addrp, const char *name, const bool_Bool static_entry) | |||
| 3656 | { | |||
| 3657 | hashipv6_t *tp; | |||
| 3658 | ||||
| 3659 | /* | |||
| 3660 | * Don't add zero-length names; apparently, some resolvers will return | |||
| 3661 | * them if they get them from DNS. | |||
| 3662 | */ | |||
| 3663 | if (!name || name[0] == '\0') | |||
| 3664 | return; | |||
| 3665 | ||||
| 3666 | tp = (hashipv6_t *)wmem_map_lookup(ipv6_hash_table, addrp); | |||
| 3667 | if (!tp) { | |||
| 3668 | ws_in6_addr *addr_key; | |||
| 3669 | ||||
| 3670 | addr_key = wmem_new(addr_resolv_scope, ws_in6_addr)((ws_in6_addr*)wmem_alloc((addr_resolv_scope), sizeof(ws_in6_addr ))); | |||
| 3671 | tp = new_ipv6(addrp); | |||
| 3672 | memcpy(addr_key, addrp, 16); | |||
| 3673 | wmem_map_insert(ipv6_hash_table, addr_key, tp); | |||
| 3674 | } | |||
| 3675 | ||||
| 3676 | if (g_ascii_strcasecmp(tp->name, name) && (static_entry || !(tp->flags & STATIC_HOSTNAME(1U<<3)))) { | |||
| 3677 | (void) g_strlcpy(tp->name, name, MAXDNSNAMELEN256); | |||
| 3678 | new_resolved_objects = true1; | |||
| 3679 | if (static_entry) | |||
| 3680 | tp->flags |= STATIC_HOSTNAME(1U<<3); | |||
| 3681 | } | |||
| 3682 | tp->flags |= TRIED_RESOLVE_ADDRESS(1U<<0)|NAME_RESOLVED(1U<<1); | |||
| 3683 | } /* add_ipv6_name */ | |||
| 3684 | ||||
| 3685 | static void | |||
| 3686 | add_manually_resolved_ipv4(void *key, void *value, void *user_data _U___attribute__((unused))) | |||
| 3687 | { | |||
| 3688 | resolved_name_t *resolved_ipv4_entry = (resolved_name_t*)value; | |||
| 3689 | add_ipv4_name(GPOINTER_TO_UINT(key)((guint) (gulong) (key)), resolved_ipv4_entry->name, true1); | |||
| 3690 | } | |||
| 3691 | ||||
| 3692 | static void | |||
| 3693 | add_manually_resolved_ipv6(void *key, void *value, void *user_data _U___attribute__((unused))) | |||
| 3694 | { | |||
| 3695 | resolved_name_t *resolved_ipv6_entry = (resolved_name_t*)value; | |||
| 3696 | add_ipv6_name((ws_in6_addr*)key, resolved_ipv6_entry->name, true1); | |||
| 3697 | } | |||
| 3698 | ||||
| 3699 | static void | |||
| 3700 | add_manually_resolved(void) | |||
| 3701 | { | |||
| 3702 | if (manually_resolved_ipv4_list) { | |||
| 3703 | wmem_map_foreach(manually_resolved_ipv4_list, add_manually_resolved_ipv4, NULL((void*)0)); | |||
| 3704 | } | |||
| 3705 | ||||
| 3706 | if (manually_resolved_ipv6_list) { | |||
| 3707 | wmem_map_foreach(manually_resolved_ipv6_list, add_manually_resolved_ipv6, NULL((void*)0)); | |||
| 3708 | } | |||
| 3709 | } | |||
| 3710 | ||||
| 3711 | static void | |||
| 3712 | host_name_lookup_init(void) | |||
| 3713 | { | |||
| 3714 | char *hostspath; | |||
| 3715 | unsigned i; | |||
| 3716 | ||||
| 3717 | 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", 3717, __func__, "assertion failed: %s" , "ipxnet_hash_table == ((void*)0)"); } while (0); | |||
| 3718 | ipxnet_hash_table = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal); | |||
| 3719 | ||||
| 3720 | 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", 3720, __func__, "assertion failed: %s" , "ipv4_hash_table == ((void*)0)"); } while (0); | |||
| 3721 | ipv4_hash_table = wmem_map_new(addr_resolv_scope, g_direct_hash, g_direct_equal); | |||
| 3722 | ||||
| 3723 | 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", 3723, __func__, "assertion failed: %s" , "ipv6_hash_table == ((void*)0)"); } while (0); | |||
| 3724 | ipv6_hash_table = wmem_map_new(addr_resolv_scope, ipv6_oat_hash, ipv6_equal); | |||
| 3725 | ||||
| 3726 | 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" , 3726, __func__, "assertion failed: %s", "async_dns_queue_head == ((void*)0)" ); } while (0); | |||
| 3727 | async_dns_queue_head = wmem_list_new(addr_resolv_scope); | |||
| 3728 | ||||
| 3729 | /* | |||
| 3730 | * The manually resolved lists are the only address resolution maps | |||
| 3731 | * that are not reset by addr_resolv_cleanup(), because they are | |||
| 3732 | * the only ones that do not have entries from personal configuration | |||
| 3733 | * files that can change when changing configurations. All their | |||
| 3734 | * entries must also be in epan scope. | |||
| 3735 | */ | |||
| 3736 | if (manually_resolved_ipv4_list == NULL((void*)0)) | |||
| 3737 | manually_resolved_ipv4_list = wmem_map_new(wmem_epan_scope(), g_direct_hash, g_direct_equal); | |||
| 3738 | ||||
| 3739 | if (manually_resolved_ipv6_list == NULL((void*)0)) | |||
| 3740 | manually_resolved_ipv6_list = wmem_map_new(wmem_epan_scope(), ipv6_oat_hash, ipv6_equal); | |||
| 3741 | ||||
| 3742 | /* | |||
| 3743 | * Load the global hosts file, if we have one. | |||
| 3744 | */ | |||
| 3745 | hostspath = get_datafile_path(ENAME_HOSTS"hosts"); | |||
| 3746 | if (!read_hosts_file(hostspath, true1) && errno(*__errno_location ()) != ENOENT2) { | |||
| ||||
| 3747 | report_open_failure(hostspath, errno(*__errno_location ()), false0); | |||
| 3748 | } | |||
| 3749 | g_free(hostspath); | |||
| 3750 | /* | |||
| 3751 | * Load the user's hosts file no matter what, if they have one. | |||
| 3752 | */ | |||
| 3753 | hostspath = get_persconffile_path(ENAME_HOSTS"hosts", true1); | |||
| 3754 | if (!read_hosts_file(hostspath, true1) && errno(*__errno_location ()) != ENOENT2) { | |||
| 3755 | report_open_failure(hostspath, errno(*__errno_location ()), false0); | |||
| 3756 | } | |||
| 3757 | g_free(hostspath); | |||
| 3758 | #ifdef CARES_HAVE_ARES_LIBRARY_INIT1 | |||
| 3759 | if (ares_library_init(ARES_LIB_INIT_ALL((1 << 0))) == ARES_SUCCESS) { | |||
| 3760 | #endif | |||
| 3761 | /* XXX - Check which options we should set */ | |||
| 3762 | if (ares_init_options(&ghba_chan, NULL((void*)0), 0) == ARES_SUCCESS && ares_init_options(&ghbn_chan, NULL((void*)0), 0) == ARES_SUCCESS) { | |||
| 3763 | async_dns_initialized = true1; | |||
| 3764 | c_ares_set_dns_servers(); | |||
| 3765 | } | |||
| 3766 | #ifdef CARES_HAVE_ARES_LIBRARY_INIT1 | |||
| 3767 | } | |||
| 3768 | #endif | |||
| 3769 | ||||
| 3770 | if (extra_hosts_files) { | |||
| 3771 | for (i = 0; i < extra_hosts_files->len; i++) { | |||
| 3772 | read_hosts_file((const char *) g_ptr_array_index(extra_hosts_files, i)((extra_hosts_files)->pdata)[i], true1); | |||
| 3773 | } | |||
| 3774 | } | |||
| 3775 | ||||
| 3776 | subnet_name_lookup_init(); | |||
| 3777 | ||||
| 3778 | add_manually_resolved(); | |||
| 3779 | ||||
| 3780 | ss7pc_name_lookup_init(); | |||
| 3781 | } | |||
| 3782 | ||||
| 3783 | static void | |||
| 3784 | host_name_lookup_cleanup(void) | |||
| 3785 | { | |||
| 3786 | uint32_t i, j; | |||
| 3787 | sub_net_hashipv4_t *entry, *next_entry; | |||
| 3788 | ||||
| 3789 | _host_name_lookup_cleanup(); | |||
| 3790 | ||||
| 3791 | ipxnet_hash_table = NULL((void*)0); | |||
| 3792 | ipv4_hash_table = NULL((void*)0); | |||
| 3793 | ipv6_hash_table = NULL((void*)0); | |||
| 3794 | ss7pc_hash_table = NULL((void*)0); | |||
| 3795 | ||||
| 3796 | for(i = 0; i < SUBNETLENGTHSIZE32; ++i) { | |||
| 3797 | if (subnet_length_entries[i].subnet_addresses != NULL((void*)0)) { | |||
| 3798 | for (j = 0; j < HASHHOSTSIZE2048; j++) { | |||
| 3799 | for (entry = subnet_length_entries[i].subnet_addresses[j]; | |||
| 3800 | entry != NULL((void*)0); entry = next_entry) { | |||
| 3801 | next_entry = entry->next; | |||
| 3802 | wmem_free(addr_resolv_scope, entry); | |||
| 3803 | } | |||
| 3804 | } | |||
| 3805 | wmem_free(addr_resolv_scope, subnet_length_entries[i].subnet_addresses); | |||
| 3806 | subnet_length_entries[i].subnet_addresses = NULL((void*)0); | |||
| 3807 | } | |||
| 3808 | } | |||
| 3809 | ||||
| 3810 | have_subnet_entry = false0; | |||
| 3811 | new_resolved_objects = false0; | |||
| 3812 | } | |||
| 3813 | ||||
| 3814 | ||||
| 3815 | void host_name_lookup_reset(void) | |||
| 3816 | { | |||
| 3817 | addr_resolv_cleanup(); | |||
| 3818 | addr_resolv_init(); | |||
| ||||
| 3819 | } | |||
| 3820 | ||||
| 3821 | char * | |||
| 3822 | udp_port_to_display(wmem_allocator_t *allocator, unsigned port) | |||
| 3823 | { | |||
| 3824 | ||||
| 3825 | if (!gbl_resolv_flags.transport_name) { | |||
| 3826 | return wmem_utoa(allocator, port); | |||
| 3827 | } | |||
| 3828 | ||||
| 3829 | return wmem_strdup(allocator, serv_name_lookup(PT_UDP, port)); | |||
| 3830 | ||||
| 3831 | } /* udp_port_to_display */ | |||
| 3832 | ||||
| 3833 | char * | |||
| 3834 | dccp_port_to_display(wmem_allocator_t *allocator, unsigned port) | |||
| 3835 | { | |||
| 3836 | ||||
| 3837 | if (!gbl_resolv_flags.transport_name) { | |||
| 3838 | return wmem_utoa(allocator, port); | |||
| 3839 | } | |||
| 3840 | ||||
| 3841 | return wmem_strdup(allocator, serv_name_lookup(PT_DCCP, port)); | |||
| 3842 | ||||
| 3843 | } /* dccp_port_to_display */ | |||
| 3844 | ||||
| 3845 | char * | |||
| 3846 | tcp_port_to_display(wmem_allocator_t *allocator, unsigned port) | |||
| 3847 | { | |||
| 3848 | ||||
| 3849 | if (!gbl_resolv_flags.transport_name) { | |||
| 3850 | return wmem_utoa(allocator, port); | |||
| 3851 | } | |||
| 3852 | ||||
| 3853 | return wmem_strdup(allocator, serv_name_lookup(PT_TCP, port)); | |||
| 3854 | ||||
| 3855 | } /* tcp_port_to_display */ | |||
| 3856 | ||||
| 3857 | char * | |||
| 3858 | sctp_port_to_display(wmem_allocator_t *allocator, unsigned port) | |||
| 3859 | { | |||
| 3860 | ||||
| 3861 | if (!gbl_resolv_flags.transport_name) { | |||
| 3862 | return wmem_utoa(allocator, port); | |||
| 3863 | } | |||
| 3864 | ||||
| 3865 | return wmem_strdup(allocator, serv_name_lookup(PT_SCTP, port)); | |||
| 3866 | ||||
| 3867 | } /* sctp_port_to_display */ | |||
| 3868 | ||||
| 3869 | char * | |||
| 3870 | port_with_resolution_to_str(wmem_allocator_t *scope, port_type proto, unsigned port) | |||
| 3871 | { | |||
| 3872 | const char *port_str; | |||
| 3873 | ||||
| 3874 | if (!gbl_resolv_flags.transport_name || (proto == PT_NONE)) { | |||
| 3875 | /* No name resolution support, just return port string */ | |||
| 3876 | return wmem_strdup_printf(scope, "%u", port); | |||
| 3877 | } | |||
| 3878 | port_str = serv_name_lookup(proto, port); | |||
| 3879 | ws_assert(port_str)do { if ((1) && !(port_str)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/addr_resolv.c", 3879, __func__, "assertion failed: %s" , "port_str"); } while (0); | |||
| 3880 | return wmem_strdup_printf(scope, "%s (%u)", port_str, port); | |||
| 3881 | } | |||
| 3882 | ||||
| 3883 | int | |||
| 3884 | port_with_resolution_to_str_buf(char *buf, unsigned long buf_size, port_type proto, unsigned port) | |||
| 3885 | { | |||
| 3886 | const char *port_str; | |||
| 3887 | ||||
| 3888 | if (!gbl_resolv_flags.transport_name || (proto == PT_NONE)) { | |||
| 3889 | /* No name resolution support, just return port string */ | |||
| 3890 | return snprintf(buf, buf_size, "%u", port); | |||
| 3891 | } | |||
| 3892 | port_str = serv_name_lookup(proto, port); | |||
| 3893 | ws_assert(port_str)do { if ((1) && !(port_str)) ws_log_fatal_full("", LOG_LEVEL_ERROR , "epan/addr_resolv.c", 3893, __func__, "assertion failed: %s" , "port_str"); } while (0); | |||
| 3894 | return snprintf(buf, buf_size, "%s (%u)", port_str, port); | |||
| 3895 | } | |||
| 3896 | ||||
| 3897 | const char * | |||
| 3898 | get_ether_name(const uint8_t *addr) | |||
| 3899 | { | |||
| 3900 | hashether_t *tp; | |||
| 3901 | bool_Bool resolve = gbl_resolv_flags.mac_name; | |||
| 3902 | ||||
| 3903 | tp = eth_name_lookup(addr, resolve); | |||
| 3904 | ||||
| 3905 | return resolve ? tp->resolved_name : tp->hexaddr; | |||
| 3906 | ||||
| 3907 | } /* get_ether_name */ | |||
| 3908 | ||||
| 3909 | const char * | |||
| 3910 | tvb_get_ether_name(tvbuff_t *tvb, int offset) | |||
| 3911 | { | |||
| 3912 | return get_ether_name(tvb_get_ptr(tvb, offset, 6)); | |||
| 3913 | } | |||
| 3914 | ||||
| 3915 | /* Look for a (non-dummy) ether name in the hash, and return it if found. | |||
| 3916 | * If it's not found, simply return NULL. | |||
| 3917 | */ | |||
| 3918 | const char * | |||
| 3919 | get_ether_name_if_known(const uint8_t *addr) | |||
| 3920 | { | |||
| 3921 | hashether_t *tp; | |||
| 3922 | ||||
| 3923 | /* Initialize ether structs if we're the first | |||
| 3924 | * ether-related function called */ | |||
| 3925 | if (!gbl_resolv_flags.mac_name) | |||
| 3926 | return NULL((void*)0); | |||
| 3927 | ||||
| 3928 | /* eth_name_lookup will create a (resolved) hash entry | |||
| 3929 | * if it doesn't exist, so it never returns NULL */ | |||
| 3930 | tp = eth_name_lookup(addr, true1); | |||
| 3931 | ||||
| 3932 | if ((tp->flags & (NAME_RESOLVED(1U<<1) | NAME_RESOLVED_PREFIX(1U<<4))) == NAME_RESOLVED(1U<<1)) { | |||
| 3933 | /* Name is from an exact match, not a prefix/OUI */ | |||
| 3934 | return tp->resolved_name; | |||
| 3935 | } | |||
| 3936 | else { | |||
| 3937 | /* Name was created */ | |||
| 3938 | return NULL((void*)0); | |||
| 3939 | } | |||
| 3940 | } | |||
| 3941 | ||||
| 3942 | void | |||
| 3943 | add_ether_byip(const unsigned ip, const uint8_t *eth) | |||
| 3944 | { | |||
| 3945 | hashipv4_t *tp; | |||
| 3946 | ||||
| 3947 | /* first check that IP address can be resolved */ | |||
| 3948 | if (!gbl_resolv_flags.network_name) | |||
| 3949 | return; | |||
| 3950 | ||||
| 3951 | tp = host_lookup(ip); | |||
| 3952 | ||||
| 3953 | /* | |||
| 3954 | * Was this IP address resolved to a host name? | |||
| 3955 | */ | |||
| 3956 | if (tp->flags & NAME_RESOLVED(1U<<1)) { | |||
| 3957 | /* | |||
| 3958 | * Yes, so add an entry in the ethers hashtable resolving | |||
| 3959 | * the MAC address to that name. | |||
| 3960 | */ | |||
| 3961 | add_eth_name(eth, tp->name, false0); | |||
| 3962 | } | |||
| 3963 | ||||
| 3964 | } /* add_ether_byip */ | |||
| 3965 | ||||
| 3966 | char * | |||
| 3967 | get_ipxnet_name(wmem_allocator_t *allocator, const uint32_t addr) | |||
| 3968 | { | |||
| 3969 | ||||
| 3970 | if (!gbl_resolv_flags.network_name) { | |||
| 3971 | return ipxnet_to_str_punct(allocator, addr, '\0'); | |||
| 3972 | } | |||
| 3973 | ||||
| 3974 | return ipxnet_name_lookup(allocator, addr); | |||
| 3975 | ||||
| 3976 | } /* get_ipxnet_name */ | |||
| 3977 | ||||
| 3978 | char * | |||
| 3979 | get_vlan_name(wmem_allocator_t *allocator, const uint16_t id) | |||
| 3980 | { | |||
| 3981 | ||||
| 3982 | if (!gbl_resolv_flags.vlan_name) { | |||
| 3983 | return NULL((void*)0); | |||
| 3984 | } | |||
| 3985 | ||||
| 3986 | return wmem_strdup(allocator, vlan_name_lookup(id)); | |||
| 3987 | ||||
| 3988 | } /* get_vlan_name */ | |||
| 3989 | ||||
| 3990 | const char * | |||
| 3991 | get_manuf_name(const uint8_t *addr, size_t size) | |||
| 3992 | { | |||
| 3993 | hashmanuf_t *manuf_value; | |||
| 3994 | ||||
| 3995 | ws_return_val_if(size < 3, NULL)do { if (1 && (size < 3)) { ws_log_full("InvalidArg" , LOG_LEVEL_WARNING, "epan/addr_resolv.c", 3995, __func__, "invalid argument: %s" , "size < 3"); return (((void*)0)); } } while (0); | |||
| 3996 | ||||
| 3997 | manuf_value = manuf_name_lookup(addr, size); | |||
| 3998 | if (gbl_resolv_flags.mac_name && ((manuf_value->flags & NAME_RESOLVED(1U<<1)) == NAME_RESOLVED(1U<<1))) | |||
| 3999 | return manuf_value->resolved_name; | |||
| 4000 | ||||
| 4001 | return manuf_value->hexaddr; | |||
| 4002 | ||||
| 4003 | } /* get_manuf_name */ | |||
| 4004 | ||||
| 4005 | const char * | |||
| 4006 | tvb_get_manuf_name(tvbuff_t *tvb, int offset) | |||
| 4007 | { | |||
| 4008 | uint8_t buf[3] = { 0 }; | |||
| 4009 | tvb_memcpy(tvb, buf, offset, 3); | |||
| 4010 | return get_manuf_name(buf, sizeof(buf)); | |||
| 4011 | } | |||
| 4012 | ||||
| 4013 | const char * | |||
| 4014 | get_manuf_name_if_known(const uint8_t *addr, size_t size) | |||
| 4015 | { | |||
| 4016 | hashmanuf_t *manuf_value; | |||
| 4017 | ||||
| 4018 | ws_return_val_if(size < 3, NULL)do { if (1 && (size < 3)) { ws_log_full("InvalidArg" , LOG_LEVEL_WARNING, "epan/addr_resolv.c", 4018, __func__, "invalid argument: %s" , "size < 3"); return (((void*)0)); } } while (0); | |||
| 4019 | ||||
| 4020 | manuf_value = manuf_name_lookup(addr, size); | |||
| 4021 | if (manuf_value != NULL((void*)0) && ((manuf_value->flags & NAME_RESOLVED(1U<<1)) == NAME_RESOLVED(1U<<1))) { | |||
| 4022 | return manuf_value->resolved_longname; | |||
| 4023 | } | |||
| 4024 | ||||
| 4025 | if (size >= 6) { | |||
| 4026 | /* Try the global manuf tables. */ | |||
| 4027 | const char *short_name, *long_name; | |||
| 4028 | short_name = ws_manuf_lookup_str(addr, &long_name); | |||
| 4029 | if (short_name != NULL((void*)0)) { | |||
| 4030 | /* Found it */ | |||
| 4031 | return long_name; | |||
| 4032 | } | |||
| 4033 | } | |||
| 4034 | ||||
| 4035 | return NULL((void*)0); | |||
| 4036 | ||||
| 4037 | } /* get_manuf_name_if_known */ | |||
| 4038 | ||||
| 4039 | const char * | |||
| 4040 | uint_get_manuf_name_if_known(const uint32_t manuf_key) | |||
| 4041 | { | |||
| 4042 | uint8_t addr[6] = { 0 }; | |||
| 4043 | addr[0] = (manuf_key >> 16) & 0xFF; | |||
| 4044 | addr[1] = (manuf_key >> 8) & 0xFF; | |||
| 4045 | addr[2] = manuf_key & 0xFF; | |||
| 4046 | ||||
| 4047 | return get_manuf_name_if_known(addr, sizeof(addr)); | |||
| 4048 | } | |||
| 4049 | ||||
| 4050 | const char * | |||
| 4051 | tvb_get_manuf_name_if_known(tvbuff_t *tvb, int offset) | |||
| 4052 | { | |||
| 4053 | uint8_t buf[3] = { 0 }; | |||
| 4054 | tvb_memcpy(tvb, buf, offset, 3); | |||
| 4055 | return get_manuf_name_if_known(buf, sizeof(buf)); | |||
| 4056 | } | |||
| 4057 | ||||
| 4058 | bool_Bool get_hash_manuf_used(hashmanuf_t* manuf) | |||
| 4059 | { | |||
| 4060 | return ((manuf->flags & TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))) == TRIED_OR_RESOLVED_MASK((1U<<0) | (1U<<1))); | |||
| 4061 | } | |||
| 4062 | ||||
| 4063 | char* get_hash_manuf_resolved_name(hashmanuf_t* manuf) | |||
| 4064 | { | |||
| 4065 | return manuf->resolved_longname; | |||
| 4066 | } | |||
| 4067 | ||||
| 4068 | const char * | |||
| 4069 | get_eui64_name(const uint8_t *addr) | |||
| 4070 | { | |||
| 4071 | hasheui64_t *tp; | |||
| 4072 | bool_Bool resolve = gbl_resolv_flags.mac_name; | |||
| 4073 | ||||
| 4074 | tp = eui64_name_lookup(addr, resolve); | |||
| 4075 | ||||
| 4076 | return resolve ? tp->resolved_name : tp->hexaddr; | |||
| 4077 | ||||
| 4078 | } /* get_eui64_name */ | |||
| 4079 | ||||
| 4080 | char * | |||
| 4081 | eui64_to_display(wmem_allocator_t *allocator, const uint64_t addr_eui64) | |||
| 4082 | { | |||
| 4083 | uint8_t addr[EUI64_ADDR_LEN8]; | |||
| 4084 | ||||
| 4085 | phton64(addr, addr_eui64); | |||
| 4086 | ||||
| 4087 | const char *result = get_eui64_name(addr); | |||
| 4088 | ||||
| 4089 | return wmem_strdup(allocator, result); | |||
| 4090 | } /* eui64_to_display */ | |||
| 4091 | ||||
| 4092 | #define GHI_TIMEOUT(250 * 1000) (250 * 1000) | |||
| 4093 | static void | |||
| 4094 | c_ares_ghi_cb(void *arg, int status, int timeouts _U___attribute__((unused)), struct hostent *hp) { | |||
| 4095 | /* | |||
| 4096 | * XXX - If we wanted to be really fancy we could cache results here and | |||
| 4097 | * look them up in get_host_ipaddr* below. | |||
| 4098 | * | |||
| 4099 | * XXX - This only gets the first host address if there's more than one. | |||
| 4100 | */ | |||
| 4101 | async_hostent_t *ahp = (async_hostent_t *)arg; | |||
| 4102 | if (status == ARES_SUCCESS && hp && ahp && hp->h_length == ahp->addr_size) { | |||
| 4103 | memcpy(ahp->addrp, hp->h_addrh_addr_list[0], hp->h_length); | |||
| 4104 | ahp->copied = hp->h_length; | |||
| 4105 | } | |||
| 4106 | } | |||
| 4107 | ||||
| 4108 | /* Translate a string, assumed either to be a dotted-quad IPv4 address or | |||
| 4109 | * a host name, to a numeric IPv4 address. Return true if we succeed and | |||
| 4110 | * set "*addrp" to that numeric IPv4 address; return false if we fail. */ | |||
| 4111 | bool_Bool | |||
| 4112 | get_host_ipaddr(const char *host, uint32_t *addrp) | |||
| 4113 | { | |||
| 4114 | struct timeval tv = { 0, GHI_TIMEOUT(250 * 1000) }, *tvp; | |||
| 4115 | int nfds; | |||
| 4116 | fd_set rfds, wfds; | |||
| 4117 | async_hostent_t ahe; | |||
| 4118 | ||||
| 4119 | /* | |||
| 4120 | * XXX - are there places where this is used to translate something | |||
| 4121 | * that's *only* supposed to be an IPv4 address, and where it | |||
| 4122 | * *shouldn't* translate host names? | |||
| 4123 | */ | |||
| 4124 | if (!ws_inet_pton4(host, addrp)) { | |||
| 4125 | ||||
| 4126 | /* It's not a valid dotted-quad IP address; is it a valid | |||
| 4127 | * host name? | |||
| 4128 | */ | |||
| 4129 | ||||
| 4130 | /* If we're not allowed to do name resolution, don't do name | |||
| 4131 | * resolution... | |||
| 4132 | * XXX - What if we're allowed to do name resolution, and the name | |||
| 4133 | * is in a DNS packet we've dissected or in a Name Resolution Block, | |||
| 4134 | * or a user-entered manual name resolution? | |||
| 4135 | */ | |||
| 4136 | if (!gbl_resolv_flags.network_name || | |||
| 4137 | !gbl_resolv_flags.use_external_net_name_resolver) { | |||
| 4138 | return false0; | |||
| 4139 | } | |||
| 4140 | ||||
| 4141 | if (!async_dns_initialized || name_resolve_concurrency < 1) { | |||
| 4142 | return false0; | |||
| 4143 | } | |||
| 4144 | ahe.addr_size = (int) sizeof (struct in_addr); | |||
| 4145 | ahe.copied = 0; | |||
| 4146 | ahe.addrp = addrp; | |||
| 4147 | ares_gethostbyname(ghbn_chan, host, AF_INET2, c_ares_ghi_cb, &ahe); | |||
| 4148 | 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); | |||
| 4149 | 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); | |||
| 4150 | nfds = ares_fds(ghbn_chan, &rfds, &wfds); | |||
| 4151 | if (nfds > 0) { | |||
| 4152 | tvp = ares_timeout(ghbn_chan, &tv, &tv); | |||
| 4153 | if (select(nfds, &rfds, &wfds, NULL((void*)0), tvp) == -1) { /* call to select() failed */ | |||
| 4154 | /* If it's interrupted by a signal, no need to put out a message */ | |||
| 4155 | if (errno(*__errno_location ()) != EINTR4) | |||
| 4156 | fprintf(stderrstderr, "Warning: call to select() failed, error is %s\n", g_strerror(errno(*__errno_location ()))); | |||
| 4157 | return false0; | |||
| 4158 | } | |||
| 4159 | ares_process(ghbn_chan, &rfds, &wfds); | |||
| 4160 | } | |||
| 4161 | ares_cancel(ghbn_chan); | |||
| 4162 | if (ahe.addr_size == ahe.copied) { | |||
| 4163 | return true1; | |||
| 4164 | } | |||
| 4165 | return false0; | |||
| 4166 | } | |||
| 4167 | ||||
| 4168 | return true1; | |||
| 4169 | } | |||
| 4170 | ||||
| 4171 | /* | |||
| 4172 | * Translate IPv6 numeric address or FQDN hostname into binary IPv6 address. | |||
| 4173 | * Return true if we succeed and set "*addrp" to that numeric IPv6 address; | |||
| 4174 | * return false if we fail. | |||
| 4175 | */ | |||
| 4176 | bool_Bool | |||
| 4177 | get_host_ipaddr6(const char *host, ws_in6_addr *addrp) | |||
| 4178 | { | |||
| 4179 | struct timeval tv = { 0, GHI_TIMEOUT(250 * 1000) }, *tvp; | |||
| 4180 | int nfds; | |||
| 4181 | fd_set rfds, wfds; | |||
| 4182 | async_hostent_t ahe; | |||
| 4183 | ||||
| 4184 | if (str_to_ip6(host, addrp)) | |||
| 4185 | return true1; | |||
| 4186 | ||||
| 4187 | /* It's not a valid dotted-quad IP address; is it a valid | |||
| 4188 | * host name? | |||
| 4189 | * | |||
| 4190 | * XXX - are there places where this is used to translate something | |||
| 4191 | * that's *only* supposed to be an IPv6 address, and where it | |||
| 4192 | * *shouldn't* translate host names? | |||
| 4193 | */ | |||
| 4194 | ||||
| 4195 | /* If we're not allowed to do name resolution, don't do name | |||
| 4196 | * resolution... | |||
| 4197 | * XXX - What if we're allowed to do name resolution, and the name | |||
| 4198 | * is in a DNS packet we've dissected or in a Name Resolution Block, | |||
| 4199 | * or a user-entered manual name resolution? | |||
| 4200 | */ | |||
| 4201 | if (!gbl_resolv_flags.network_name || | |||
| 4202 | !gbl_resolv_flags.use_external_net_name_resolver) { | |||
| 4203 | return false0; | |||
| 4204 | } | |||
| 4205 | ||||
| 4206 | /* try FQDN */ | |||
| 4207 | if (!async_dns_initialized || name_resolve_concurrency < 1) { | |||
| 4208 | return false0; | |||
| 4209 | } | |||
| 4210 | ahe.addr_size = (int) sizeof (ws_in6_addr); | |||
| 4211 | ahe.copied = 0; | |||
| 4212 | ahe.addrp = addrp; | |||
| 4213 | ares_gethostbyname(ghbn_chan, host, AF_INET610, c_ares_ghi_cb, &ahe); | |||
| 4214 | 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); | |||
| 4215 | 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); | |||
| 4216 | nfds = ares_fds(ghbn_chan, &rfds, &wfds); | |||
| 4217 | if (nfds > 0) { | |||
| 4218 | tvp = ares_timeout(ghbn_chan, &tv, &tv); | |||
| 4219 | if (select(nfds, &rfds, &wfds, NULL((void*)0), tvp) == -1) { /* call to select() failed */ | |||
| 4220 | /* If it's interrupted by a signal, no need to put out a message */ | |||
| 4221 | if (errno(*__errno_location ()) != EINTR4) | |||
| 4222 | fprintf(stderrstderr, "Warning: call to select() failed, error is %s\n", g_strerror(errno(*__errno_location ()))); | |||
| 4223 | return false0; | |||
| 4224 | } | |||
| 4225 | ares_process(ghbn_chan, &rfds, &wfds); | |||
| 4226 | } | |||
| 4227 | ares_cancel(ghbn_chan); | |||
| 4228 | if (ahe.addr_size == ahe.copied) { | |||
| 4229 | return true1; | |||
| 4230 | } | |||
| 4231 | ||||
| 4232 | return false0; | |||
| 4233 | } | |||
| 4234 | ||||
| 4235 | wmem_map_t * | |||
| 4236 | get_manuf_hashtable(void) | |||
| 4237 | { | |||
| 4238 | return manuf_hashtable; | |||
| 4239 | } | |||
| 4240 | ||||
| 4241 | wmem_map_t * | |||
| 4242 | get_wka_hashtable(void) | |||
| 4243 | { | |||
| 4244 | return wka_hashtable; | |||
| 4245 | } | |||
| 4246 | ||||
| 4247 | wmem_map_t * | |||
| 4248 | get_eth_hashtable(void) | |||
| 4249 | { | |||
| 4250 | return eth_hashtable; | |||
| 4251 | } | |||
| 4252 | ||||
| 4253 | wmem_map_t * | |||
| 4254 | get_serv_port_hashtable(void) | |||
| 4255 | { | |||
| 4256 | return serv_port_hashtable; | |||
| 4257 | } | |||
| 4258 | ||||
| 4259 | wmem_map_t * | |||
| 4260 | get_ipxnet_hash_table(void) | |||
| 4261 | { | |||
| 4262 | return ipxnet_hash_table; | |||
| 4263 | } | |||
| 4264 | ||||
| 4265 | wmem_map_t * | |||
| 4266 | get_vlan_hash_table(void) | |||
| 4267 | { | |||
| 4268 | return vlan_hash_table; | |||
| 4269 | } | |||
| 4270 | ||||
| 4271 | wmem_map_t * | |||
| 4272 | get_ipv4_hash_table(void) | |||
| 4273 | { | |||
| 4274 | return ipv4_hash_table; | |||
| 4275 | } | |||
| 4276 | ||||
| 4277 | wmem_map_t * | |||
| 4278 | get_ipv6_hash_table(void) | |||
| 4279 | { | |||
| 4280 | return ipv6_hash_table; | |||
| 4281 | } | |||
| 4282 | /* Initialize all the address resolution subsystems in this file */ | |||
| 4283 | void | |||
| 4284 | addr_resolv_init(void) | |||
| 4285 | { | |||
| 4286 | 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", 4286, __func__, "assertion failed: %s" , "addr_resolv_scope == ((void*)0)"); } while (0); | |||
| 4287 | addr_resolv_scope = wmem_allocator_new(WMEM_ALLOCATOR_BLOCK); | |||
| 4288 | initialize_services(); | |||
| 4289 | initialize_ethers(); | |||
| 4290 | initialize_ipxnets(); | |||
| 4291 | initialize_vlans(); | |||
| 4292 | initialize_enterprises(); | |||
| 4293 | host_name_lookup_init(); | |||
| 4294 | } | |||
| 4295 | ||||
| 4296 | /* Clean up all the address resolution subsystems in this file */ | |||
| 4297 | void | |||
| 4298 | addr_resolv_cleanup(void) | |||
| 4299 | { | |||
| 4300 | vlan_name_lookup_cleanup(); | |||
| 4301 | service_name_lookup_cleanup(); | |||
| 4302 | ethers_cleanup(); | |||
| 4303 | ipx_name_lookup_cleanup(); | |||
| 4304 | enterprises_cleanup(); | |||
| 4305 | host_name_lookup_cleanup(); | |||
| 4306 | ||||
| 4307 | wmem_destroy_allocator(addr_resolv_scope); | |||
| 4308 | addr_resolv_scope = NULL((void*)0); | |||
| 4309 | } | |||
| 4310 | ||||
| 4311 | bool_Bool | |||
| 4312 | str_to_ip(const char *str, void *dst) | |||
| 4313 | { | |||
| 4314 | return ws_inet_pton4(str, (uint32_t *)dst); | |||
| 4315 | } | |||
| 4316 | ||||
| 4317 | bool_Bool | |||
| 4318 | str_to_ip6(const char *str, void *dst) | |||
| 4319 | { | |||
| 4320 | return ws_inet_pton6(str, (ws_in6_addr *)dst); | |||
| 4321 | } | |||
| 4322 | ||||
| 4323 | /* | |||
| 4324 | * convert a 0-terminated string that contains an ethernet address into | |||
| 4325 | * the corresponding sequence of 6 bytes | |||
| 4326 | * eth_bytes is a buffer >= 6 bytes that was allocated by the caller | |||
| 4327 | */ | |||
| 4328 | bool_Bool | |||
| 4329 | str_to_eth(const char *str, char *eth_bytes) | |||
| 4330 | { | |||
| 4331 | ether_t eth; | |||
| 4332 | unsigned mask; | |||
| 4333 | ||||
| 4334 | if (!parse_ether_address(str, ð, &mask, false0)) | |||
| 4335 | return false0; | |||
| 4336 | ||||
| 4337 | if (mask == 48) { | |||
| 4338 | memcpy(eth_bytes, eth.addr, 6); | |||
| 4339 | } | |||
| 4340 | return true1; | |||
| 4341 | } | |||
| 4342 | ||||
| 4343 | /* | |||
| 4344 | * Editor modelines - https://www.wireshark.org/tools/modelines.html | |||
| 4345 | * | |||
| 4346 | * Local variables: | |||
| 4347 | * c-basic-offset: 4 | |||
| 4348 | * tab-width: 8 | |||
| 4349 | * indent-tabs-mode: nil | |||
| 4350 | * End: | |||
| 4351 | * | |||
| 4352 | * vi: set shiftwidth=4 tabstop=8 expandtab: | |||
| 4353 | * :indentSize=4:tabSize=8:noTabs=true: | |||
| 4354 | */ |