/**
* Insert `key' into the list.
*
* It is safe to call this routine whilst iterating although there is no
* guarantee as to whether the iteration will see the new item.
*/
void
hash_list_insert_sorted(hash_list_t *hl, const void *key, cmp_fn_t func)
{
link_t *lk;
hash_list_check(hl);
g_assert(NULL != func);
g_assert(!hikset_contains(hl->ht, key));
for (lk = elist_first(&hl->list); lk != NULL; lk = elist_next(lk)) {
struct hash_list_item *item = ITEM(lk);
if ((*func)(key, item->key) <= 0)
break;
}
if (NULL == lk) {
hash_list_append(hl, key);
} else {
struct hash_list_item *item;
WALLOC(item);
item->key = key;
/* Inserting ``item'' before ``lk'' */
elist_link_insert_before(&hl->list, lk, &item->lnk);
hash_list_insert_item(hl, item);
}
}
/**
* Check whether hashlist contains the key.
* @return TRUE if the key is present.
*/
bool
hash_list_contains(hash_list_t *hl, const void *key)
{
hash_list_check(hl);
return hikset_contains(hl->ht, key);
}
/**
* DBMW foreach iterator to remove keys otherwise unknown by the publisher.
* @return TRUE if entry is to be deleted.
*/
static bool
publisher_remove_orphan(void *key, void *u_value, size_t u_len, void *u_data)
{
const sha1_t *sha1 = key;
(void) u_value;
(void) u_len;
(void) u_data;
return !hikset_contains(publisher_sha1, sha1);
}
/**
* Register new file to be monitored.
*
* If the file was already monitored, cancel the previous monitoring action
* and replace it with this one.
*
* @param filename the file to monitor (string duplicated)
* @param cb the callback to invoke when the file changes
* @param udata extra data to pass to the callback, along with filename
*/
void
watcher_register(const char *filename, watcher_cb_t cb, void *udata)
{
struct monitored *m;
WALLOC0(m);
m->filename = atom_str_get(filename);
m->cb = cb;
m->udata = udata;
m->mtime = watcher_mtime(filename);
if (hikset_contains(monitored, filename))
watcher_unregister(filename);
hikset_insert_key(monitored, &m->filename);
}
static void
hash_list_insert_item(hash_list_t *hl, struct hash_list_item *item)
{
g_assert(!hikset_contains(hl->ht, item->key));
hikset_insert_key(hl->ht, &item->key);
/*
* Insertion in the list is "safe" with respect to iterators.
*
* Although there is no guarantee the inserted item will be iterated
* over (if it lies before the iterating point), there is no invalidation
* of the "next" and "prev" entries that we can have pre-computed in the
* iterator, nor is there the risk that we would iterate forever. All
* existing references to linkable cells will remain valid after the
* insertion took place.
*
* Therefore, do not update the hl->stamp value.
*/
hash_list_regression(hl);
}
/**
* 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);
}
/**
* @return TRUE if key is stored here.
*/
bool
keys_exists(const kuid_t *key)
{
return hikset_contains(keys, key);
}
