/**
* 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;
}
}
/**
* Add child to the node, carrying an IP:port.
*
* @param t the tree node where child must be added
* @param name the name of the child
* @param addr the IP address
* @param port the port address
*
* @return the added child node
*/
static g2_tree_t *
g2_build_add_host(g2_tree_t *t, const char *name, host_addr_t addr, uint16 port)
{
struct packed_host_addr packed;
uint alen;
char payload[18]; /* Large enough for IPv6 as well, one day? */
void *p;
g2_tree_t *c;
packed = host_addr_pack(addr);
alen = packed_host_addr_size(packed) - 1; /* skip network byte */
p = mempcpy(payload, &packed.addr, alen);
p = poke_le16(p, port);
c = g2_tree_alloc_copy(name, payload, ptr_diff(p, payload));
g2_tree_add_child(t, c);
return c;
}
/**
* 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;
}
/**
* 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;
}
/**
* Add file to the current query hit.
*
* @return TRUE if we kept the file, FALSE if we did not include it in the hit.
*/
static bool
g2_build_qh2_add(struct g2_qh2_builder *ctx, const shared_file_t *sf)
{
const sha1_t *sha1;
g2_tree_t *h, *c;
shared_file_check(sf);
/*
* Make sure the file is still in the library.
*/
if (0 == shared_file_index(sf))
return FALSE;
/*
* On G2, the H/URN child is required, meaning we need the SHA1 at least.
*/
if (!sha1_hash_available(sf))
return FALSE;
/*
* Do not send duplicates, as determined by the SHA1 of the resource.
*
* A user may share several files with different names but the same SHA1,
* and if all of them are hits, we only want to send one instance.
*
* When generating hits for host-browsing, we do not care about duplicates
* and ctx->hs is NULL then.
*/
sha1 = shared_file_sha1(sf); /* This is an atom */
if (ctx->hs != NULL) {
if (hset_contains(ctx->hs, sha1))
return FALSE;
hset_insert(ctx->hs, sha1);
}
/*
* Create the "H" child and attach it to the current tree.
*/
if (NULL == ctx->t)
g2_build_qh2_start(ctx);
h = g2_tree_alloc_empty("H");
g2_tree_add_child(ctx->t, h);
/*
* URN -- Universal Resource Name
*
* If there is a known TTH, then we can generate a bitprint, otherwise
* we just convey the SHA1.
*/
{
const tth_t * const tth = shared_file_tth(sf);
char payload[SHA1_RAW_SIZE + TTH_RAW_SIZE + sizeof G2_URN_BITPRINT];
char *p = payload;
if (NULL == tth) {
p = mempcpy(p, G2_URN_SHA1, sizeof G2_URN_SHA1);
p += clamp_memcpy(p, sizeof payload - ptr_diff(p, payload),
sha1, SHA1_RAW_SIZE);
} else {
p = mempcpy(p, G2_URN_BITPRINT, sizeof G2_URN_BITPRINT);
p += clamp_memcpy(p, sizeof payload - ptr_diff(p, payload),
sha1, SHA1_RAW_SIZE);
p += clamp_memcpy(p, sizeof payload - ptr_diff(p, payload),
tth, TTH_RAW_SIZE);
}
g_assert(ptr_diff(p, payload) <= sizeof payload);
c = g2_tree_alloc_copy("URN", payload, ptr_diff(p, payload));
g2_tree_add_child(h, c);
}
/*
* URL -- empty to indicate that we share the file via uri-res.
*/
if (ctx->flags & QHIT_F_G2_URL) {
uint known;
uint16 csc;
c = g2_tree_alloc_empty("URL");
g2_tree_add_child(h, c);
/*
* CSC -- if we know alternate sources, indicate how many in "CSC".
*
* This child is only emitted when they requested "URL".
*/
known = dmesh_count(sha1);
csc = MIN(known, MAX_INT_VAL(uint16));
if (csc != 0) {
char payload[2];
poke_le16(payload, csc);
c = g2_tree_alloc_copy("CSC", payload, sizeof payload);
g2_tree_add_child(h, c);
}
/*
* PART -- if we only have a partial file, indicate how much we have.
*
* This child is only emitted when they requested "URL".
*/
if (shared_file_is_partial(sf) && !shared_file_is_finished(sf)) {
filesize_t available = shared_file_available(sf);
char payload[8]; /* If we have to encode file size as 64-bit */
uint32 av32;
time_t mtime = shared_file_modification_time(sf);
c = g2_tree_alloc_empty("PART");
g2_tree_add_child(h, c);
av32 = available;
if (av32 == available) {
/* Fits within a 32-bit quantity */
poke_le32(payload, av32);
g2_tree_set_payload(c, payload, sizeof av32, TRUE);
} else {
/* Encode as a 64-bit quantity then */
poke_le64(payload, available);
g2_tree_set_payload(c, payload, sizeof payload, TRUE);
}
/*
* GTKG extension: encode the last modification time of the
* partial file in an "MT" child. This lets the other party
* determine whether the host is still able to actively complete
* the file.
*/
poke_le32(payload, (uint32) mtime);
g2_tree_add_child(c,
g2_tree_alloc_copy("MT", payload, sizeof(uint32)));
}
/*
* CT -- creation time of the resource (GTKG extension).
*/
{
time_t create_time = shared_file_creation_time(sf);
if ((time_t) -1 != create_time) {
char payload[8];
int n;
create_time = MAX(0, create_time);
n = vlint_encode(create_time, payload);
g2_tree_add_child(h,
g2_tree_alloc_copy("CT", payload, n)); /* No trailing 0s */
}
}
}
/*
* DN -- distinguished name.
*
* Note that the presence of DN also governs the presence of SZ if the
* file length does not fit a 32-bit unsigned quantity.
*/
if (ctx->flags & QHIT_F_G2_DN) {
char payload[8]; /* If we have to encode file size as 64-bit */
uint32 fs32;
filesize_t fs = shared_file_size(sf);
const char *name;
const char *rp;
c = g2_tree_alloc_empty("DN");
fs32 = fs;
if (fs32 == fs) {
/* Fits within a 32-bit quantity */
poke_le32(payload, fs32);
g2_tree_set_payload(c, payload, sizeof fs32, TRUE);
} else {
/* Does not fit a 32-bit quantity, emit a SZ child */
poke_le64(payload, fs);
g2_tree_add_child(h,
g2_tree_alloc_copy("SZ", payload, sizeof payload));
}
name = shared_file_name_nfc(sf);
g2_tree_append_payload(c, name, shared_file_name_nfc_len(sf));
g2_tree_add_child(h, c);
/*
* GTKG extension: if there is a file path, expose it as a "P" child
* under the DN node.
*/
rp = shared_file_relative_path(sf);
if (rp != NULL) {
g2_tree_add_child(c, g2_tree_alloc_copy("P", rp, strlen(rp)));
}
}
/*
* GTKG extension: if they requested alt-locs in the /Q2/I with "A", then
* send them some known alt-locs in an "ALT" child.
*
* Note that these alt-locs can be for Gnutella hosts: since both Gnutella
* and G2 share a common HTTP-based file transfer mechanism with compatible
* extra headers, there is no need to handle them separately.
*/
if (ctx->flags & QHIT_F_G2_ALT) {
gnet_host_t hvec[G2_BUILD_QH2_MAX_ALT];
int hcnt = 0;
hcnt = dmesh_fill_alternate(sha1, hvec, N_ITEMS(hvec));
if (hcnt > 0) {
int i;
c = g2_tree_alloc_empty("ALT");
for (i = 0; i < hcnt; i++) {
host_addr_t addr;
uint16 port;
addr = gnet_host_get_addr(&hvec[i]);
port = gnet_host_get_port(&hvec[i]);
if (host_addr_is_ipv4(addr)) {
char payload[6];
host_ip_port_poke(payload, addr, port, NULL);
g2_tree_append_payload(c, payload, sizeof payload);
}
}
/*
* If the payload is still empty, then drop the "ALT" child.
* Otherwise, attach it to the "H" node.
*/
if (NULL == g2_tree_node_payload(c, NULL)) {
g2_tree_free_null(&c);
} else {
g2_tree_add_child(h, c);
}
}
}
/*
* Update the size of the query hit we're generating.
*/
ctx->current_size += g2_frame_serialize(h, NULL, 0);
return TRUE;
}
/**
* 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;
}
