host_addr_t
addrinfo_to_addr(const struct addrinfo *ai)
{
host_addr_t addr = zero_host_addr;
switch (ai->ai_family) {
case PF_INET:
if (ai->ai_addrlen >= 4) {
const struct sockaddr_in *sin4;
sin4 = cast_to_constpointer(ai->ai_addr);
addr = host_addr_peek_ipv4(&sin4->sin_addr.s_addr);
}
break;
#ifdef HAS_IPV6
case PF_INET6:
if (ai->ai_addrlen >= 16) {
const struct sockaddr_in6 *sin6;
sin6 = cast_to_constpointer(ai->ai_addr);
addr = host_addr_peek_ipv6(cast_to_constpointer(
sin6->sin6_addr.s6_addr));
}
break;
#endif /* HAS_IPV6 */
}
return addr;
}
/**
* Based on the timestamp, determine the proper token keys to use limiting
* to the first ``count'' items.
*
* @return the suitable keys, falling back to the last keyset in the table
* if we can't find any suitable keys.
*/
static const struct tokkey *
find_tokkey_upto_fallback(time_t now, size_t count)
{
const struct tokkey *tk;
tk = find_tokkey_upto(now, count);
if (NULL == tk) {
g_assert(count <= G_N_ELEMENTS(token_keys));
tk = &token_keys[count - 1];
if (GNET_PROPERTY(version_debug) > 4) {
g_debug("%s: got NULL, will use index %lu", G_STRFUNC, count - 1UL);
}
}
if (GNET_PROPERTY(version_debug) > 4) {
g_debug("%s: returning %p (%u.%u.%u)",
G_STRFUNC, cast_to_constpointer(tk),
tk->ver.major, tk->ver.minor, tk->ver.patchlevel);
}
g_assert(tk != NULL);
return tk;
}
/**
* Dispose of the data structure.
*/
void
list_free(list_t **list_ptr)
{
g_assert(list_ptr);
if (*list_ptr) {
list_t *list;
list = *list_ptr;
g_assert(LIST_MAGIC == list->magic);
g_assert(equiv(list->length == 0, list->tail == NULL));
list_regression(list);
if (--list->refcount != 0) {
g_critical("%s(): list is still referenced! "
"(list=%p, list->refcount=%d)",
G_STRFUNC, cast_to_constpointer(list), list->refcount);
}
gm_list_free_null(&list->head);
list->tail = NULL;
list->magic = 0;
WFREE(list);
*list_ptr = NULL;
}
}
/**
* Convert a KUID to a base32 string.
*
* @return pointer to static data.
*/
const char *
kuid_to_string(const kuid_t *kuid)
{
static char buf[SHA1_BASE32_SIZE + 1];
return sha1_to_base32_buf(cast_to_constpointer(&kuid->v), buf, sizeof buf);
}
/**
* Dispose of the data structure.
*/
void
slist_free(slist_t **slist_ptr)
{
g_assert(slist_ptr);
if (*slist_ptr) {
slist_t *slist;
slist = *slist_ptr;
slist_check(slist);
if (--slist->refcount != 0) {
g_carp("slist_free: slist is still referenced! "
"(slist=%p, slist->refcount=%d)",
cast_to_constpointer(slist), slist->refcount);
}
gm_slist_free_null(&slist->head);
slist->tail = NULL;
slist->magic = 0;
WFREE(slist);
*slist_ptr = NULL;
}
}
/**
* Compress as much data as possible to the output buffer, sending data
* as we go along.
*
* @return the amount of input bytes that were consumed ("added"), -1 on error.
*/
static int
deflate_add(txdrv_t *tx, const void *data, int len)
{
struct attr *attr = tx->opaque;
z_streamp outz = attr->outz;
int added = 0;
if (tx_deflate_debugging(9)) {
g_debug("TX %s: (%s) given %u bytes (buffer #%d, nagle %s, "
"unflushed %zu) [%c%c]%s", G_STRFUNC,
gnet_host_to_string(&tx->host), len, attr->fill_idx,
(attr->flags & DF_NAGLE) ? "on" : "off", attr->unflushed,
(attr->flags & DF_FLOWC) ? 'C' : '-',
(attr->flags & DF_FLUSH) ? 'f' : '-',
(tx->flags & TX_ERROR) ? " ERROR" : "");
}
/*
* If an error was already reported, the whole deflate stream is dead
* and we cannot accept any more data.
*/
if G_UNLIKELY(tx->flags & TX_ERROR)
return -1;
while (added < len) {
struct buffer *b = &attr->buf[attr->fill_idx]; /* Buffer we fill */
int ret;
int old_added = added;
bool flush_started = (attr->flags & DF_FLUSH) ? TRUE : FALSE;
int old_avail;
const char *in, *old_in;
/*
* Prepare call to deflate().
*/
outz->next_out = cast_to_pointer(b->wptr);
outz->avail_out = old_avail = b->end - b->wptr;
in = data;
old_in = &in[added];
outz->next_in = deconstify_pointer(old_in);
outz->avail_in = len - added;
g_assert(outz->avail_out > 0);
g_assert(outz->avail_in > 0);
/*
* Compress data.
*
* If we previously started to flush, continue the operation, now
* that we have more room available for the output.
*/
ret = deflate(outz, flush_started ? Z_SYNC_FLUSH : 0);
if (Z_OK != ret) {
attr->flags |= DF_SHUTDOWN;
(*attr->cb->shutdown)(tx->owner, "Compression failed: %s",
zlib_strerror(ret));
return -1;
}
/*
* Update the parameters.
*/
b->wptr = cast_to_pointer(outz->next_out);
added = ptr_diff(outz->next_in, in);
g_assert(added >= old_added);
attr->unflushed += added - old_added;
attr->flushed += old_avail - outz->avail_out;
if (NULL != attr->cb->add_tx_deflated)
attr->cb->add_tx_deflated(tx->owner, old_avail - outz->avail_out);
if (attr->gzip.enabled) {
size_t r;
r = ptr_diff(outz->next_in, old_in);
attr->gzip.size += r;
attr->gzip.crc = crc32(attr->gzip.crc,
cast_to_constpointer(old_in), r);
}
if (tx_deflate_debugging(9)) {
g_debug("TX %s: (%s) deflated %d bytes into %d "
"(buffer #%d, nagle %s, flushed %zu, unflushed %zu) [%c%c]",
G_STRFUNC, gnet_host_to_string(&tx->host),
added, old_avail - outz->avail_out, attr->fill_idx,
(attr->flags & DF_NAGLE) ? "on" : "off",
attr->flushed, attr->unflushed,
(attr->flags & DF_FLOWC) ? 'C' : '-',
(attr->flags & DF_FLUSH) ? 'f' : '-');
}
/*
* If we filled the output buffer, check whether we have a pending
* send buffer. If we do, we cannot process more data. Otherwise
* send it now and continue.
*/
if (0 == outz->avail_out) {
if (attr->send_idx >= 0) {
deflate_set_flowc(tx, TRUE); /* Enter flow control */
return added;
}
deflate_rotate_and_send(tx); /* Can set TX_ERROR */
if (tx->flags & TX_ERROR)
return -1;
}
/*
* If we were flushing and we consumed all the input, then
* the flush is done and we're starting normal compression again.
*
* This must be done after we made sure that we had enough output
* space avaialable.
*/
if (flush_started && 0 == outz->avail_in)
deflate_flushed(tx);
}
g_assert(0 == outz->avail_in);
/*
* Start Nagle if not already on.
*/
if (attr->flags & DF_NAGLE)
deflate_nagle_delay(tx);
else
deflate_nagle_start(tx);
/*
* We're going to ask for a flush if not already started yet and the
* amount of bytes we have written since the last flush is greater
* than attr->buffer_flush.
*/
if (attr->unflushed > attr->buffer_flush) {
if (!deflate_flush(tx))
return -1;
}
return added;
}