b1a7fc361f
This should hopefully fix linking with Solaris Studio, which doesn't remove unused inline functions by default. Fix a copy+paste error. svn path=/trunk/; revision=52122
337 lines
12 KiB
C
337 lines
12 KiB
C
/* address.h
|
|
* Definitions for structures storing addresses, and for the type of
|
|
* variables holding port-type values
|
|
*
|
|
* $Id$
|
|
*
|
|
* Wireshark - Network traffic analyzer
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
* Copyright 1998 Gerald Combs
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#ifndef __ADDRESS_H__
|
|
#define __ADDRESS_H__
|
|
|
|
#include <string.h> /* for memcmp */
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /* __cplusplus */
|
|
|
|
/* Types of addresses Wireshark knows about. */
|
|
/* If a new address type is added here, a string representation procedure should */
|
|
/* also be included in address_to_str_buf defined in to_str.c, for presentation purposes */
|
|
|
|
typedef enum {
|
|
AT_NONE, /* no link-layer address */
|
|
AT_ETHER, /* MAC (Ethernet, 802.x, FDDI) address */
|
|
AT_IPv4, /* IPv4 */
|
|
AT_IPv6, /* IPv6 */
|
|
AT_IPX, /* IPX */
|
|
AT_SNA, /* SNA */
|
|
AT_ATALK, /* Appletalk DDP */
|
|
AT_VINES, /* Banyan Vines */
|
|
AT_OSI, /* OSI NSAP */
|
|
AT_ARCNET, /* ARCNET */
|
|
AT_FC, /* Fibre Channel */
|
|
AT_SS7PC, /* SS7 Point Code */
|
|
AT_STRINGZ, /* null-terminated string */
|
|
AT_EUI64, /* IEEE EUI-64 */
|
|
AT_URI, /* URI/URL/URN */
|
|
AT_TIPC, /* TIPC Address Zone,Subnetwork,Processor */
|
|
AT_IB, /* Infiniband GID/LID */
|
|
AT_USB, /* USB Device address
|
|
* (0xffffffff represents the host) */
|
|
AT_AX25, /* AX.25 */
|
|
AT_IEEE_802_15_4_SHORT /* IEEE 802.15.4 16-bit short address */
|
|
/* (the long addresses are EUI-64's */
|
|
} address_type;
|
|
|
|
typedef struct _address {
|
|
address_type type; /* type of address */
|
|
int hf; /* the specific field that this addr is */
|
|
int len; /* length of address, in bytes */
|
|
const void *data; /* pointer to address data */
|
|
} address;
|
|
|
|
/** Initialize an address with the given values.
|
|
*
|
|
* @param addr[in,out] The address to initialize.
|
|
* @param addr_type[in] Address type.
|
|
* @param addr_len[in] The length in bytes of the address data. For example, 4 for
|
|
* AT_IPv4 or sizeof(struct e_in6_addr) for AT_IPv6.
|
|
* @param addr_data[in] Pointer to the address data.
|
|
*/
|
|
static inline void
|
|
set_address(address *addr, address_type addr_type, int addr_len, const void * addr_data) {
|
|
addr->data = addr_data;
|
|
addr->type = addr_type;
|
|
addr->hf = -1;
|
|
addr->len = addr_len;
|
|
}
|
|
#define SET_ADDRESS(addr, addr_type, addr_len, addr_data) \
|
|
set_address((addr), (addr_type), (addr_len), (addr_data))
|
|
|
|
/** Initialize an address from TVB data.
|
|
*
|
|
* Same as SET_ADDRESS but it takes a TVB and an offset. This is preferred
|
|
* over passing the return value of tvb_get_ptr() to set_address().
|
|
*
|
|
* This calls tvb_get_ptr() (including throwing any exceptions) before
|
|
* modifying the address.
|
|
*
|
|
* @param addr[in,out] The address to initialize.
|
|
* @param addr_type[in] Address type.
|
|
* @param tvb[in] Pointer to the TVB.
|
|
* @param offset[in] Offset within the TVB.
|
|
* @param addr_len[in] The length in bytes of the address data. For example, 4 for
|
|
* AT_IPv4 or sizeof(struct e_in6_addr) for AT_IPv6.
|
|
*/
|
|
#define TVB_SET_ADDRESS(addr, addr_type, tvb, offset, addr_len) \
|
|
do { \
|
|
const void *TVB_SET_ADDRESS_data = (void *)tvb_get_ptr(tvb, offset, addr_len); \
|
|
set_address((addr), (addr_type), (addr_len), TVB_SET_ADDRESS_data); \
|
|
} while (0)
|
|
|
|
/** Initialize an address with the given values including an associated field.
|
|
*
|
|
* @param addr[in,out] The address to initialize.
|
|
* @param addr_type[in] Address type.
|
|
* @param addr_len[in] The length in bytes of the address data. For example, 4 for
|
|
* AT_IPv4 or sizeof(struct e_in6_addr) for AT_IPv6.
|
|
* @param addr_data[in] Pointer to the address data.
|
|
* @param addr_hf[in] The header field index to associate with the address.
|
|
*/
|
|
static inline void
|
|
set_address_hf(address *addr, address_type addr_type, int addr_len, const void * addr_data, int addr_hf) {
|
|
addr->data = addr_data;
|
|
addr->type = addr_type;
|
|
addr->hf = addr_hf;
|
|
addr->len = addr_len;
|
|
}
|
|
#define SET_ADDRESS_HF(addr, addr_type, addr_len, addr_data, addr_hf) \
|
|
set_address_hf((addr), (addr_type), (addr_len), (addr_hf))
|
|
|
|
/** Initialize an address from TVB data including an associated field.
|
|
*
|
|
* Same as SET_ADDRESS_HF but it takes a TVB and an offset. This is preferred
|
|
* over passing the return value of tvb_get_ptr() to set_address().
|
|
*
|
|
* This calls tvb_get_ptr() (including throwing any exceptions) before
|
|
* modifying the address.
|
|
*
|
|
* @param addr[in,out] The address to initialize.
|
|
* @param addr_type[in] Address type.
|
|
* @param tvb[in] Pointer to the TVB.
|
|
* @param offset[in] Offset within the TVB.
|
|
* @param addr_len[in] The length in bytes of the address data. For example, 4 for
|
|
* AT_IPv4 or sizeof(struct e_in6_addr) for AT_IPv6.
|
|
* @param addr_hf[in] The header field index to associate with the address.
|
|
*/
|
|
#define TVB_SET_ADDRESS_HF(addr, addr_type, tvb, offset, addr_len, addr_hf) \
|
|
do { \
|
|
const void *TVB_SET_ADDRESS_data = (void *) tvb_get_ptr(tvb, offset, addr_len); \
|
|
set_address_hf((addr), (addr_type), (addr_len), TVB_SET_ADDRESS_data, (addr_hf)); \
|
|
} while (0)
|
|
|
|
/** Compare two addresses.
|
|
*
|
|
* @param addr1[in] The first address to compare.
|
|
* @param addr2[in] The second address to compare.
|
|
* @return 0 if the addresses are equal,
|
|
* A positive number if addr1 > addr2 in some nondefined metric,
|
|
* A negative number if addr1 < addr2 in some nondefined metric.
|
|
*/
|
|
static inline int
|
|
cmp_address(const address *addr1, const address *addr2) {
|
|
if (addr1->type > addr2->type) return 1;
|
|
if (addr1->type < addr2->type) return -1;
|
|
if (addr1->len > addr2->len) return 1;
|
|
if (addr1->len < addr2->len) return -1;
|
|
return memcmp(addr1->data, addr2->data, addr1->len);
|
|
}
|
|
#define CMP_ADDRESS(addr1, addr2) cmp_address((addr1), (addr2))
|
|
|
|
/** Check two addresses for equality.
|
|
*
|
|
* Given two addresses, return "true" if they're equal, "false" otherwise.
|
|
* Addresses are equal only if they have the same type; if the type is
|
|
* AT_NONE, they are then equal, otherwise they must have the same
|
|
* amount of data and the data must be the same.
|
|
*
|
|
* @param addr1[in] The first address to compare.
|
|
* @param addr2[in] The second address to compare.
|
|
* @return TRUE if the adresses are equal, FALSE otherwise.
|
|
*/
|
|
static inline gboolean
|
|
addresses_equal(const address *addr1, const address *addr2) {
|
|
if (addr1->type == addr2->type
|
|
&& ( addr1->type == AT_NONE
|
|
|| ( addr1->len == addr2->len
|
|
&& memcmp(addr1->data, addr2->data, addr1->len) == 0
|
|
)
|
|
)
|
|
) return TRUE;
|
|
return FALSE;
|
|
}
|
|
#define ADDRESSES_EQUAL(addr1, addr2) addresses_equal((addr1), (addr2))
|
|
|
|
/** Copy an address, allocating a new buffer for the address data.
|
|
*
|
|
* @param to[in,out] The destination address.
|
|
* @param from[in] The source address.
|
|
*/
|
|
static inline void
|
|
copy_address(address *to, const address *from) {
|
|
guint8 *to_data;
|
|
|
|
to->type = from->type;
|
|
to->len = from->len;
|
|
to->hf = from->hf;
|
|
to_data = (guint8 *)g_malloc(from->len);
|
|
memcpy(to_data, from->data, from->len);
|
|
to->data = to_data;
|
|
}
|
|
#define COPY_ADDRESS(to, from) copy_address((to), (from))
|
|
|
|
/** Perform a shallow copy of the address (both addresses point to the same
|
|
* memory location).
|
|
*
|
|
* @param to[in,out] The destination address.
|
|
* @param from[in] The source address.
|
|
*/
|
|
static inline void
|
|
copy_address_shallow(address *to, const address *from) {
|
|
memcpy(to, from, sizeof(address));
|
|
/*
|
|
to->type = from->type;
|
|
to->len = from->len;
|
|
to->hf = from->hf;
|
|
to->data = from->data;
|
|
*/
|
|
}
|
|
#define COPY_ADDRESS_SHALLOW(to, from) copy_address_shallow((to), (from))
|
|
|
|
/** Copy an address, allocating a new buffer for the address data
|
|
* using seasonal memory.
|
|
*
|
|
* @param to[in,out] The destination address.
|
|
* @param from[in] The source address.
|
|
*/
|
|
#define SE_COPY_ADDRESS(to, from) \
|
|
do { \
|
|
void *SE_COPY_ADDRESS_data; \
|
|
copy_address_shallow((to), (from)); \
|
|
SE_COPY_ADDRESS_data = se_alloc((from)->len); \
|
|
memcpy(SE_COPY_ADDRESS_data, (from)->data, (from)->len); \
|
|
(to)->data = SE_COPY_ADDRESS_data; \
|
|
} while (0)
|
|
|
|
|
|
/** Hash an address into a hash value (which must already have been set).
|
|
*
|
|
* @param hash_val The existing hash value.
|
|
* @param addr The address to add.
|
|
* @return The new hash value.
|
|
*/
|
|
static inline guint
|
|
add_address_to_hash(guint hash_val, const address *addr) {
|
|
const guint8 *hash_data = (const guint8 *)(addr)->data;
|
|
int idx;
|
|
|
|
for (idx = 0; idx < (addr)->len; idx++) {
|
|
hash_val += hash_data[idx];
|
|
hash_val += ( hash_val << 10 );
|
|
hash_val ^= ( hash_val >> 6 );
|
|
}
|
|
return hash_val;
|
|
}
|
|
#define ADD_ADDRESS_TO_HASH(hash_val, addr) do { hash_val = add_address_to_hash(hash_val, (addr)); } while (0)
|
|
|
|
/** Hash an address into a hash value (which must already have been set).
|
|
* 64-bit version of add_address_to_hash().
|
|
*
|
|
* @param hash_val The existing hash value.
|
|
* @param addr The address to add.
|
|
* @return The new hash value.
|
|
*/
|
|
static inline guint64
|
|
add_address_to_hash64(guint64 hash_val, const address *addr) {
|
|
const guint8 *hash_data = (const guint8 *)(addr)->data;
|
|
int idx;
|
|
|
|
for (idx = 0; idx < (addr)->len; idx++) {
|
|
hash_val += hash_data[idx];
|
|
hash_val += ( hash_val << 10 );
|
|
hash_val ^= ( hash_val >> 6 );
|
|
}
|
|
return hash_val;
|
|
}
|
|
|
|
/* Types of port numbers Wireshark knows about. */
|
|
typedef enum {
|
|
PT_NONE, /* no port number */
|
|
PT_SCTP, /* SCTP */
|
|
PT_TCP, /* TCP */
|
|
PT_UDP, /* UDP */
|
|
PT_DCCP, /* DCCP */
|
|
PT_IPX, /* IPX sockets */
|
|
PT_NCP, /* NCP connection */
|
|
PT_EXCHG, /* Fibre Channel exchange */
|
|
PT_DDP, /* DDP AppleTalk connection */
|
|
PT_SBCCS, /* FICON */
|
|
PT_IDP, /* XNS IDP sockets */
|
|
PT_TIPC, /* TIPC PORT */
|
|
PT_USB, /* USB endpoint 0xffff means the host */
|
|
PT_I2C,
|
|
PT_IBQP, /* Infiniband QP number */
|
|
PT_BLUETOOTH
|
|
} port_type;
|
|
|
|
/* Types of circuit IDs Wireshark knows about. */
|
|
typedef enum {
|
|
CT_NONE, /* no circuit type */
|
|
CT_DLCI, /* Frame Relay DLCI */
|
|
CT_ISDN, /* ISDN channel number */
|
|
CT_X25, /* X.25 logical channel number */
|
|
CT_ISUP, /* ISDN User Part CIC */
|
|
CT_IAX2, /* IAX2 call id */
|
|
CT_H223, /* H.223 logical channel number */
|
|
CT_BICC, /* BICC Circuit identifier */
|
|
CT_DVBCI /* DVB-CI session number|transport connection id */
|
|
/* Could also have ATM VPI/VCI pairs */
|
|
} circuit_type;
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* __ADDRESS_H__ */
|
|
|
|
/*
|
|
* Editor modelines - http://www.wireshark.org/tools/modelines.html
|
|
*
|
|
* Local variables:
|
|
* c-basic-offset: 4
|
|
* tab-width: 8
|
|
* indent-tabs-mode: nil
|
|
* End:
|
|
*
|
|
* vi: set shiftwidth=4 tabstop=8 expandtab:
|
|
* :indentSize=4:tabSize=8:noTabs=true:
|
|
*/
|