/**
* Check whether hosts are "equivalent", modulo conversion to IPv4 for IPv6.
*
* @attention
* This routine CANNOT be used directly or indirectly as a comparison function
* for hash tables because it's not possible to have two items being "equal"
* that do not hash to the same value! For hash tables, use host_addr_equal()
* which tests true equality.
*/
bool
host_addr_equiv(const host_addr_t a, const host_addr_t b)
{
if (a.net == b.net) {
switch (a.net) {
case NET_TYPE_IPV4:
return host_addr_ipv4(a) == host_addr_ipv4(b);
case NET_TYPE_IPV6:
if (0 != memcmp(a.addr.ipv6, b.addr.ipv6, sizeof a.addr.ipv6)) {
host_addr_t a_ipv4, b_ipv4;
return host_addr_convert(a, &a_ipv4, NET_TYPE_IPV4) &&
host_addr_convert(b, &b_ipv4, NET_TYPE_IPV4) &&
host_addr_ipv4(a_ipv4) == host_addr_ipv4(b_ipv4);
}
return TRUE;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
return TRUE;
}
g_assert_not_reached();
} else {
host_addr_t to;
return host_addr_convert(a, &to, b.net) && host_addr_equiv(to, b);
}
return FALSE;
}
/**
* Check whether host can be reached from the Internet.
* We rule out IPs of private networks, plus some other invalid combinations.
*/
bool
host_addr_is_routable(const host_addr_t addr)
{
host_addr_t ha;
if (!is_host_addr(addr) || is_private_addr(addr))
return FALSE;
if (!host_addr_convert(addr, &ha, NET_TYPE_IPV4))
ha = addr;
switch (host_addr_net(ha)) {
case NET_TYPE_IPV4:
return ipv4_addr_is_routable(host_addr_ipv4(ha));
case NET_TYPE_IPV6:
return !host_addr_matches(ha, ipv6_unspecified, 8) &&
!host_addr_matches(ha, ipv6_multicast, 8) &&
!host_addr_matches(ha, ipv6_site_local, 10) &&
!host_addr_matches(ha, ipv6_link_local, 10) &&
!(
host_addr_is_tunneled(ha) &&
!ipv4_addr_is_routable(host_addr_tunnel_client_ipv4(ha))
);
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
return FALSE;
}
g_assert_not_reached();
return FALSE;
}
uint32
host_addr_tunnel_client_ipv4(const host_addr_t from)
{
host_addr_t to;
(void) host_addr_tunnel_client(from, &to);
return host_addr_ipv4(to);
}
/**
* Fill dump header with node address information.
*/
static void
dump_header_set(struct dump_header *dh, const struct gnutella_node *node)
{
ZERO(dh);
dh->data[0] = NODE_IS_UDP(node) ? DH_F_UDP : DH_F_TCP;
switch (host_addr_net(node->addr)) {
case NET_TYPE_IPV4:
{
guint32 ip;
dh->data[0] |= DH_F_IPV4;
ip = host_addr_ipv4(node->addr);
poke_be32(&dh->data[1], ip);
}
break;
case NET_TYPE_IPV6:
dh->data[0] |= DH_F_IPV6;
memcpy(&dh->data[1], host_addr_ipv6(&node->addr), 16);
break;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
break;
}
poke_be16(&dh->data[17], node->port);
}
/**
* Check whether the Gnutella host vector already contains the address:port.
*
* @return TRUE if the host vector already contains it.
*/
bool
gnet_host_vec_contains(gnet_host_vec_t *vec, host_addr_t addr, uint16 port)
{
size_t i;
g_return_val_if_fail(vec, FALSE);
switch (host_addr_net(addr)) {
case NET_TYPE_IPV4:
for (i = 0; i < vec->n_ipv4; i++) {
char *dest = cast_to_pointer(&vec->hvec_v4[i]);
uint32 ip = peek_be32(&dest[0]);
uint16 pt = peek_le16(&dest[4]);
if (pt == port && host_addr_ipv4(addr) == ip)
return TRUE;
}
break;
case NET_TYPE_IPV6:
for (i = 0; i < vec->n_ipv6; i++) {
char *dest = cast_to_pointer(&vec->hvec_v6[i]);
uint16 pt = peek_le16(&dest[16]);
if (pt == port && 0 == memcmp(dest, host_addr_ipv6(&addr), 16))
return TRUE;
}
break;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
break;
}
return FALSE;
}
/**
* Check whether hosts are equal.
*/
bool
host_addr_equal(const host_addr_t a, const host_addr_t b)
{
if (a.net == b.net) {
switch (a.net) {
case NET_TYPE_IPV4:
return host_addr_ipv4(a) == host_addr_ipv4(b);
case NET_TYPE_IPV6:
return 0 == memcmp(a.addr.ipv6, b.addr.ipv6, sizeof a.addr.ipv6);
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
return TRUE;
}
g_assert_not_reached();
}
return FALSE;
}
/**
* Retrieve value associated with an IP address, i.e. that of the range
* containing it.
*
* @param db the IP range database
* @param ha the IP address to lookup
*
* @return The data associated with the IP address or 0 if not found.
*/
uint16
iprange_get_addr(const struct iprange_db *idb, const host_addr_t ha)
{
host_addr_t to;
if (
host_addr_convert(ha, &to, NET_TYPE_IPV4) ||
host_addr_tunnel_client(ha, &to)
) {
return iprange_get(idb, host_addr_ipv4(to));
} else if (host_addr_is_ipv6(ha)) {
return iprange_get6(idb, host_addr_ipv6(&ha));
}
return 0;
}
/**
* Tries to convert the host address "from" to the network type "to_net"
* and stores the converted address in "*to". If conversion is not possible,
* FALSE is returned and "*to" is set to zero_host_addr.
*
* @param from The address to convert.
* @param to Will hold the converted address.
* @param to_net The network type to convert the address to.
*
* @return TRUE if the address could be converted, FALSE otherwise.
*/
bool
host_addr_convert(const host_addr_t from, host_addr_t *to,
enum net_type to_net)
{
if (from.net == to_net) {
*to = from;
return TRUE;
}
switch (to_net) {
case NET_TYPE_IPV4:
switch (from.net) {
case NET_TYPE_IPV6:
if (host_addr_can_convert(from, NET_TYPE_IPV4)) {
*to = host_addr_peek_ipv4(&from.addr.ipv6[12]);
return TRUE;
}
break;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
break;
}
break;
case NET_TYPE_IPV6:
switch (from.net) {
case NET_TYPE_IPV4:
to->net = to_net;
memset(to->addr.ipv6, 0, 10);
to->addr.ipv6[10] = 0xff;
to->addr.ipv6[11] = 0xff;
poke_be32(&to->addr.ipv6[12], host_addr_ipv4(from));
return TRUE;
case NET_TYPE_NONE:
break;
}
break;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
break;
}
*to = zero_host_addr;
return FALSE;
}
/**
* Prints the host address ``ha'' to ``dst''. The string written to ``dst''
* is always NUL-terminated unless ``size'' is zero. If ``size'' is too small,
* the string will be truncated.
*
* @param dst the destination buffer; may be NULL iff ``size'' is zero.
* @param ha the host address.
* @param size the size of ``dst'' in bytes.
*
* @return The length of the resulting string assuming ``size'' is sufficient.
*/
size_t
host_addr_to_string_buf(const host_addr_t ha, char *dst, size_t size)
{
switch (host_addr_net(ha)) {
case NET_TYPE_IPV4:
return ipv4_to_string_buf(host_addr_ipv4(ha), dst, size);
case NET_TYPE_IPV6:
return ipv6_to_string_buf(host_addr_ipv6(&ha), dst, size);
case NET_TYPE_LOCAL:
return g_strlcpy(dst, "<local>", size);
case NET_TYPE_NONE:
return g_strlcpy(dst, "<none>", size);
}
g_assert_not_reached();
return 0;
}
/**
* @returns true if the address is inside one of the local networks
*/
gboolean
host_is_nearby(const host_addr_t addr)
{
guint i;
if (host_addr_is_ipv4(addr)) {
for (i = 0; i < number_local_networks; i++) {
guint32 m_mask = local_networks[i].mask;
guint32 m_ip = local_networks[i].net;
if ((host_addr_ipv4(addr) & m_mask) == (m_ip & m_mask))
return TRUE;
}
} else if (host_addr_is_ipv6(addr)) {
/* XXX: Implement this! */
}
return FALSE;
}
/**
* Checks whether the given address is unspecified (all zeroes).
*/
bool
host_addr_is_unspecified(const host_addr_t addr)
{
switch (host_addr_net(addr)) {
case NET_TYPE_IPV4:
return host_addr_ipv4(addr) == 0;
case NET_TYPE_IPV6:
return host_addr_equal(addr, ipv6_unspecified);
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
break;
}
g_assert_not_reached();
return FALSE;
}
/**
* Initializes sa_ptr from a host address and a port number.
*
* @param addr The host address.
* @param port The port number.
* @param sa_ptr a pointer to a socket_addr_t
*
* @return The length of the initialized structure.
*/
socklen_t
socket_addr_set(socket_addr_t *sa_ptr, const host_addr_t addr, uint16 port)
{
switch (host_addr_net(addr)) {
case NET_TYPE_IPV4:
if (sa_ptr) {
static const struct sockaddr_in zero_sin;
sa_ptr->inet4 = zero_sin;
#ifdef HAS_SOCKADDR_IN_SIN_LEN
sa_ptr->inet4.sin_len = sizeof sa_ptr->inet4;
#endif /* HAS_SOCKADDR_IN_SIN_LEN */
sa_ptr->inet4.sin_family = AF_INET;
sa_ptr->inet4.sin_port = htons(port);
sa_ptr->inet4.sin_addr.s_addr = htonl(host_addr_ipv4(addr));
}
return sizeof sa_ptr->inet4;
case NET_TYPE_IPV6:
#ifdef HAS_IPV6
if (sa_ptr) {
static const struct sockaddr_in6 zero_sin6;
sa_ptr->inet6 = zero_sin6;
#ifdef SIN6_LEN
sa_ptr->inet6.sin6_len = sizeof sa_ptr->inet6;
#endif /* SIN6_LEN */
sa_ptr->inet6.sin6_family = AF_INET6;
sa_ptr->inet6.sin6_port = htons(port);
memcpy(sa_ptr->inet6.sin6_addr.s6_addr, addr.addr.ipv6, 16);
}
return sizeof sa_ptr->inet6;
#endif /* HAS_IPV6 */
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
if (sa_ptr) {
static const socket_addr_t zero_sa;
*sa_ptr = zero_sa;
}
return 0;
}
g_assert_not_reached();
return 0;
}
/**
* Generate GUID for a query with OOB results delivery.
* If `initial' is false, this is a requery.
*
* Bytes 0 to 3 if the GUID are the 4 octet bytes of the IP address.
* Bytes 13 and 14 are the little endian representation of the port.
* Byte 15 holds an HEC with bit 0 indicating a requery.
*/
void
guid_query_oob_muid(struct guid *muid, const host_addr_t addr, uint16 port,
bool initial)
{
uint32 ip;
g_assert(host_addr_is_ipv4(addr));
guid_random_fill(muid);
ip = host_addr_ipv4(addr);
poke_be32(&muid->v[0], ip);
poke_le16(&muid->v[13], port);
guid_flag_oob_gtkg(muid); /* Mark as being from GTKG */
if (initial)
muid->v[15] &= ~GUID_REQUERY;
else
muid->v[15] |= GUID_REQUERY;
}
/**
* Write an IPv4 or IPv6 address.
*/
void
pmsg_write_ipv4_or_ipv6_addr(pmsg_t *mb, host_addr_t addr)
{
g_assert(pmsg_is_writable(mb)); /* Not shared, or would corrupt data */
g_assert(pmsg_available(mb) >= 17);
switch (host_addr_net(addr)) {
case NET_TYPE_IPV4:
pmsg_write_u8(mb, 4);
pmsg_write_be32(mb, host_addr_ipv4(addr));
break;
case NET_TYPE_IPV6:
pmsg_write_u8(mb, 16);
pmsg_write(mb, host_addr_ipv6(&addr), 16);
break;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
g_error("unexpected address in pmsg_write_ipv4_or_ipv6_addr(): %s",
host_addr_to_string(addr));
}
}
/**
* Checks for RFC1918 private addresses but also IPv6 link-local and site-local
* addresses.
*
* @return TRUE if is a private address.
*/
bool
is_private_addr(const host_addr_t addr)
{
host_addr_t addr_ipv4;
if (host_addr_convert(addr, &addr_ipv4, NET_TYPE_IPV4)) {
uint32 ip = host_addr_ipv4(addr_ipv4);
/* 10.0.0.0 -- (10/8 prefix) */
if ((ip & 0xff000000) == 0xa000000)
return TRUE;
/* 172.16.0.0 -- (172.16/12 prefix) */
if ((ip & 0xfff00000) == 0xac100000)
return TRUE;
/* 169.254.0.0 -- (169.254/16 prefix) -- since Jan 2001 */
if ((ip & 0xffff0000) == 0xa9fe0000)
return TRUE;
/* 192.168.0.0 -- (192.168/16 prefix) */
if ((ip & 0xffff0000) == 0xc0a80000)
return TRUE;
} else {
switch (host_addr_net(addr)) {
case NET_TYPE_IPV4:
g_assert_not_reached();
case NET_TYPE_IPV6:
return host_addr_equal(addr, ipv6_loopback) ||
host_addr_matches(addr, ipv6_link_local, 10) ||
host_addr_matches(addr, ipv6_site_local, 10);
case NET_TYPE_LOCAL:
return TRUE;
case NET_TYPE_NONE:
break;
}
}
return FALSE;
}
/**
* Add new host (identified by address and port) to the Gnutella host vector.
*/
void
gnet_host_vec_add(gnet_host_vec_t *vec, host_addr_t addr, uint16 port)
{
g_return_if_fail(vec);
switch (host_addr_net(addr)) {
case NET_TYPE_IPV4:
if (vec->n_ipv4 < 255) {
size_t size, old_size;
char *dest;
old_size = vec->n_ipv4 * sizeof vec->hvec_v4[0];
size = old_size + sizeof vec->hvec_v4[0];
vec->hvec_v4 = wrealloc(vec->hvec_v4, old_size, size);
dest = cast_to_pointer(&vec->hvec_v4[vec->n_ipv4++]);
poke_be32(&dest[0], host_addr_ipv4(addr));
poke_le16(&dest[4], port);
}
break;
case NET_TYPE_IPV6:
if (vec->n_ipv6 < 255) {
size_t size, old_size;
char *dest;
old_size = vec->n_ipv6 * sizeof vec->hvec_v6[0];
size = old_size + sizeof vec->hvec_v6[0];
vec->hvec_v6 = wrealloc(vec->hvec_v6, old_size, size);
dest = cast_to_pointer(&vec->hvec_v6[vec->n_ipv6++]);
dest = mempcpy(dest, host_addr_ipv6(&addr), 16);
poke_le16(dest, port);
}
break;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
break;
}
}
/**
* Alternate hashing of host_addr_t.
*/
unsigned
host_addr_hash2(host_addr_t ha)
{
switch (ha.net) {
case NET_TYPE_IPV6:
{
host_addr_t ha_ipv4;
if (!host_addr_convert(ha, &ha_ipv4, NET_TYPE_IPV4))
return binary_hash2(&ha.addr.ipv6[0], sizeof ha.addr.ipv6);
ha = ha_ipv4;
}
/* FALL THROUGH */
case NET_TYPE_IPV4:
return ha.net ^ integer_hash2(host_addr_ipv4(ha));
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
return ha.net;
}
g_assert_not_reached();
return (unsigned) -1;
}
/**
* Checks whether the given address is 127.0.0.1 or ::1.
*/
bool
host_addr_is_loopback(const host_addr_t addr)
{
host_addr_t ha;
if (!host_addr_convert(addr, &ha, NET_TYPE_IPV4))
ha = addr;
switch (host_addr_net(ha)) {
case NET_TYPE_IPV4:
return host_addr_ipv4(ha) == 0x7f000001; /* 127.0.0.1 in host endian */
case NET_TYPE_IPV6:
return host_addr_equal(ha, ipv6_loopback);
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
break;
}
g_assert_not_reached();
return FALSE;
}
/**
* Hashing of host_addr_t + port.
*/
unsigned
host_addr_port_hash(host_addr_t ha, uint16 port)
{
switch (ha.net) {
case NET_TYPE_IPV6:
{
host_addr_t ha_ipv4;
if (!host_addr_convert(ha, &ha_ipv4, NET_TYPE_IPV4))
return binary_hash(&ha.addr.ipv6[0], sizeof ha.addr.ipv6);
ha = ha_ipv4;
}
/* FALL THROUGH */
case NET_TYPE_IPV4:
return hashing_mix32(
ha.net + integer_hash_fast(host_addr_ipv4(ha)) + u16_hash(port));
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
return hashing_mix32(ha.net + u16_hash(port));
}
g_assert_not_reached();
return (unsigned) -1;
}
/**
* Serialization convenience for IP:port.
*
* Write the IP:port (IP as big-endian, port as little-endian) into the
* supplied buffer, whose length MUST be 18 bytes at least.
*
* If len is non-NULL, it is written with the length of the serialized data.
*
* @return pointer following serialization data.
*/
void *
host_ip_port_poke(void *p, const host_addr_t addr, uint16 port, size_t *len)
{
void *q = p;
switch (host_addr_net(addr)) {
case NET_TYPE_IPV4:
q = poke_be32(q, host_addr_ipv4(addr));
break;
case NET_TYPE_IPV6:
q = mempcpy(q, host_addr_ipv6(&addr), sizeof addr.addr.ipv6);
break;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
g_assert_not_reached();
}
q = poke_le16(q, port);
if (len != NULL)
*len = ptr_diff(q, p);
return q;
}
/**
* Create a new Gnutella host vector out of a sequence of gnet_host_t items.
*/
static gnet_host_vec_t *
gnet_host_vec_from_sequence(sequence_t *s)
{
sequence_iter_t *iter;
gnet_host_vec_t *vec;
uint n_ipv6 = 0, n_ipv4 = 0, hcnt;
if (sequence_is_empty(s))
return NULL;
hcnt = 0;
iter = sequence_forward_iterator(s);
while (sequence_iter_has_next(iter)) {
const gnet_host_t *host = sequence_iter_next(iter);
switch (gnet_host_get_net(host)) {
case NET_TYPE_IPV4:
n_ipv4++;
hcnt++;
break;
case NET_TYPE_IPV6:
n_ipv6++;
hcnt++;
break;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
break;
}
}
sequence_iterator_release(&iter);
if (0 == hcnt)
return NULL;
vec = gnet_host_vec_alloc();
vec->n_ipv4 = MIN(n_ipv4, 255);
vec->n_ipv6 = MIN(n_ipv6, 255);
if (vec->n_ipv4 > 0)
WALLOC_ARRAY(vec->hvec_v4, vec->n_ipv4);
if (vec->n_ipv6 > 0)
WALLOC_ARRAY(vec->hvec_v6, vec->n_ipv6);
n_ipv4 = 0;
n_ipv6 = 0;
iter = sequence_forward_iterator(s);
while (sequence_iter_has_next(iter)) {
const gnet_host_t *host = sequence_iter_next(iter);
host_addr_t addr = gnet_host_get_addr(host);
uint16 port = gnet_host_get_port(host);
switch (gnet_host_get_net(host)) {
case NET_TYPE_IPV4:
if (n_ipv4 < vec->n_ipv4) {
char *dest = cast_to_pointer(&vec->hvec_v4[n_ipv4++]);
poke_be32(&dest[0], host_addr_ipv4(addr));
poke_le16(&dest[4], port);
}
break;
case NET_TYPE_IPV6:
if (n_ipv6 < vec->n_ipv6) {
char *dest = cast_to_pointer(&vec->hvec_v6[n_ipv6++]);
dest = mempcpy(dest, host_addr_ipv6(&addr), 16);
poke_le16(dest, port);
}
break;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
break;
}
}
sequence_iterator_release(&iter);
return vec;
}
/**
* Create a security token from host address and port using specified key.
*
* Optionally, extra contextual data may be given (i.e. the token is not
* only based on the address and port) to make the token more unique to
* a specific context.
*
* @param stg the security token generator
* @param n key index to use
* @param tok where security token is written
* @param addr address of the host for which we're generating a token
* @param port port of the host for which we're generating a token
* @param data optional contextual data
* @param len length of contextual data
*/
static void
sectoken_generate_n(sectoken_gen_t *stg, size_t n,
sectoken_t *tok, host_addr_t addr, uint16 port,
const void *data, size_t len)
{
char block[8];
char enc[8];
char *p = block;
sectoken_gen_check(stg);
g_assert(tok != NULL);
g_assert(size_is_non_negative(n));
g_assert(n < stg->keycnt);
g_assert((NULL != data) == (len != 0));
switch (host_addr_net(addr)) {
case NET_TYPE_IPV4:
p = poke_be32(p, host_addr_ipv4(addr));
break;
case NET_TYPE_IPV6:
{
uint val;
val = binary_hash(host_addr_ipv6(&addr), 16);
p = poke_be32(p, val);
}
break;
case NET_TYPE_LOCAL:
case NET_TYPE_NONE:
g_error("unexpected address for security token generation: %s",
host_addr_to_string(addr));
}
p = poke_be16(p, port);
p = poke_be16(p, 0); /* Filler */
g_assert(p == &block[8]);
STATIC_ASSERT(sizeof(tok->v) == sizeof(uint32));
STATIC_ASSERT(sizeof(block) == sizeof(enc));
tea_encrypt(&stg->keys[n], enc, block, sizeof block);
/*
* If they gave contextual data, encrypt them by block of 8 bytes,
* filling the last partial block with zeroes if needed.
*/
if (data != NULL) {
const void *q = data;
size_t remain = len;
char denc[8];
STATIC_ASSERT(sizeof(denc) == sizeof(enc));
while (remain != 0) {
size_t fill = MIN(remain, 8U);
unsigned i;
if (fill != 8U)
ZERO(&block);
memcpy(block, q, fill);
remain -= fill;
q = const_ptr_add_offset(q, fill);
/*
* Encrypt block of contextual data (possibly filled with trailing
* zeroes) and merge back the result into the main encryption
* output with XOR.
*/
tea_encrypt(&stg->keys[n], denc, block, sizeof block);
for (i = 0; i < sizeof denc; i++)
enc[i] ^= denc[i];
}
}
poke_be32(tok->v, tea_squeeze(enc, sizeof enc));
}
