/**
* Remove key from the table, freeing it if we have a key free routine.
*
* @return whether key was found and subsequently removed.
*/
bool
aging_remove(aging_table_t *ag, const void *key)
{
struct aging_value *aval;
void *ovalue;
bool found;
aging_check(ag);
aging_synchronize(ag);
if (!hikset_lookup_extended(ag->table, key, &ovalue)) {
found = FALSE;
goto done;
}
aval = ovalue;
hikset_remove(ag->table, aval->key);
aging_free(aval, ag);
found = TRUE;
done:
aging_return(ag, found);
}
/**
* Cancel monitoring of specified file.
*/
void
watcher_unregister(const char *filename)
{
struct monitored *m;
m = hikset_lookup(monitored, filename);
g_assert(m != NULL);
hikset_remove(monitored, m->filename);
watcher_free(m);
}
static void
file_object_remove(struct file_object * const fo)
{
const struct file_object *xfo;
file_object_check(fo);
g_return_if_fail(!fo->removed);
xfo = file_object_find(fo->pathname, fo->accmode);
g_assert(xfo == fo);
hikset_remove(file_object_mode_get_table(fo->accmode), fo->pathname);
fo->removed = TRUE;
}
/**
* Remove specified item.
*
* @return the original key.
*/
static void *
hash_list_remove_item(hash_list_t *hl, struct hash_list_item *item)
{
void *key;
g_assert(item);
key = deconstify_pointer(item->key);
hikset_remove(hl->ht, key);
elist_link_remove(&hl->list, &item->lnk);
WFREE(item);
hl->stamp++; /* Unsafe operation when iterating */
hash_list_regression(hl);
return key;
}
/**
* Free publisher entry.
*/
static void
publisher_entry_free(struct publisher_entry *pe, bool do_remove)
{
publisher_check(pe);
if (do_remove) {
hikset_remove(publisher_sha1, pe->sha1);
delete_pubdata(pe->sha1);
}
if (pe->backgrounded)
pdht_cancel_file(pe->sha1, FALSE);
atom_sha1_free_null(&pe->sha1);
cq_cancel(&pe->publish_ev);
WFREE(pe);
}
/**
* Reclaim key info and data.
*
* @param ki the keyinfo to reclaim
* @param can_remove whether to remove from the `keys' set
*/
static void
keys_reclaim(struct keyinfo *ki, bool can_remove)
{
g_assert(ki);
g_assert(0 == ki->values);
if (GNET_PROPERTY(dht_storage_debug) > 2)
g_debug("DHT STORE key %s reclaimed", kuid_to_hex_string(ki->kuid));
dbmw_delete(db_keydata, ki->kuid);
if (can_remove)
hikset_remove(keys, &ki->kuid);
gnet_stats_dec_general(GNR_DHT_KEYS_HELD);
if (ki->flags & DHT_KEY_F_CACHED)
gnet_stats_dec_general(GNR_DHT_CACHED_KEYS_HELD);
kuid_atom_free_null(&ki->kuid);
ki->magic = 0;
WFREE(ki);
}
/**
* Periodic garbage collecting routine.
*/
static bool
aging_gc(void *obj)
{
aging_table_t *ag = obj;
time_t now = tm_time();
struct aging_value *aval;
aging_check(ag);
aging_synchronize(ag);
g_assert(elist_count(&ag->list) == hikset_count(ag->table));
while (NULL != (aval = elist_head(&ag->list))) {
if (delta_time(now, aval->last_insert) <= ag->delay)
break; /* List is sorted, oldest items first */
hikset_remove(ag->table, aval->key);
aging_free(aval, ag);
}
aging_return(ag, TRUE); /* Keep calling */
}
/**
* Looks for ``hostname'' in ``cache'' wrt to cache->timeout. If
* ``hostname'' is not found or the entry is expired, FALSE will be
* returned. Expired entries will be removed! ``addr'' is allowed to
* be NULL, otherwise the cached IP will be stored into the variable
* ``addr'' points to.
*
* @param addrs An array of host_addr_t items. If not NULL, up to
* ``n'' items will be copied from the cache.
* @param n The number of items "addrs" can hold.
* @return The number of cached addresses for the given hostname.
*/
static size_t
adns_cache_lookup(adns_cache_t *cache, time_t now,
const char *hostname, host_addr_t *addrs, size_t n)
{
adns_cache_entry_t *entry;
g_assert(NULL != cache);
g_assert(NULL != hostname);
g_assert(0 == n || NULL != addrs);
entry = hikset_lookup(cache->ht, hostname);
if (entry) {
if (delta_time(now, entry->timestamp) < cache->timeout) {
size_t i;
for (i = 0; i < n; i++) {
if (i < entry->n) {
addrs[i] = entry->addrs[i];
if (common_dbg > 0)
g_debug("%s: \"%s\" cached (addr=%s)", G_STRFUNC,
entry->hostname, host_addr_to_string(addrs[i]));
} else {
addrs[i] = zero_host_addr;
}
}
} else {
if (common_dbg > 0) {
g_debug("%s: removing \"%s\" from cache",
G_STRFUNC, entry->hostname);
}
hikset_remove(cache->ht, hostname);
adns_cache_free_entry(cache, entry->id);
entry = NULL;
}
}
return entry ? entry->n : 0;
}
/**
* Removes current item in the iterator.
*
* @return item key, NULL if there is no item to remove.
*/
void *
hash_list_iter_remove(hash_list_iter_t *iter)
{
struct hash_list_item *item;
hash_list_iter_check(iter);
item = iter->item;
if (item != NULL) {
void *key = deconstify_pointer(item->key);
hash_list_t *hl = iter->hl;
iter->item = NULL;
hikset_remove(hl->ht, key);
elist_link_remove(&hl->list, &item->lnk);
WFREE(item);
return key;
} else {
return NULL;
}
}
/**
* Adds ``hostname'' and ``addr'' to the cache. The cache is implemented
* as a wrap-around FIFO. In case it's full, the oldest entry will be
* overwritten.
*/
static void
adns_cache_add(adns_cache_t *cache, time_t now,
const char *hostname, const host_addr_t *addrs, size_t n)
{
adns_cache_entry_t *entry;
size_t i;
g_assert(NULL != addrs);
g_assert(NULL != cache);
g_assert(NULL != hostname);
g_assert(n > 0);
g_assert(!hikset_contains(cache->ht, hostname));
g_assert(cache->pos < G_N_ELEMENTS(cache->entries));
entry = adns_cache_get_entry(cache, cache->pos);
if (entry) {
g_assert(entry->hostname);
g_assert(entry == hikset_lookup(cache->ht, entry->hostname));
hikset_remove(cache->ht, entry->hostname);
adns_cache_free_entry(cache, cache->pos);
entry = NULL;
}
entry = walloc(adns_cache_entry_size(n));
entry->n = n;
entry->hostname = atom_str_get(hostname);
entry->timestamp = now;
entry->id = cache->pos;
for (i = 0; i < entry->n; i++) {
entry->addrs[i] = addrs[i];
}
hikset_insert_key(cache->ht, &entry->hostname);
cache->entries[cache->pos++] = entry;
cache->pos %= G_N_ELEMENTS(cache->entries);
}
