static void test_hashmap_remove(void) {
_cleanup_hashmap_free_ Hashmap *m = NULL;
char *r;
log_info("%s", __func__);
r = hashmap_remove(NULL, "key 1");
assert_se(r == NULL);
m = hashmap_new(&string_hash_ops);
assert_se(m);
r = hashmap_remove(m, "no such key");
assert_se(r == NULL);
hashmap_put(m, "key 1", (void*) "val 1");
hashmap_put(m, "key 2", (void*) "val 2");
r = hashmap_remove(m, "key 1");
assert_se(streq(r, "val 1"));
r = hashmap_get(m, "key 2");
assert_se(streq(r, "val 2"));
assert_se(!hashmap_get(m, "key 1"));
}
/*
* shm_disconnect - Disconnects and cleans up the device
* [shm_t * dev] - Pointer to the device we're going to destroy
*/
static void shm_disconnect(shm_t * dev) {
if(dev->dev_type == SHM_DEV_SERVER) {
hashmap_remove(shm_network, dev->shm_key);
hashmap_remove(shm_client_list, dev->unique_id);
servers_online--;
}
}
Link *link_free(Link *l) {
if (!l)
return NULL;
if (l->manager) {
hashmap_remove(l->manager->links, INT_TO_PTR(l->ifindex));
hashmap_remove(l->manager->links_by_name, l->ifname);
}
free(l->ifname);
return mfree(l);
}
void button_free(Button *b) {
assert(b);
hashmap_remove(b->manager->buttons, b->name);
if (b->fd >= 0) {
hashmap_remove(b->manager->button_fds, INT_TO_PTR(b->fd + 1));
assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
close_nointr_nofail(b->fd);
}
free(b->name);
free(b->seat);
free(b);
}
void TestHashmaplinked_IterateAndRemoveDoesntBreakIteration(
CuTest * tc
)
{
hashmap_t *hm;
hashmap_t *hm2;
hashmap_iterator_t iter;
void *key;
hm = hashmap_new(__uint_hash, __uint_compare, 11);
hm2 = hashmap_new(__uint_hash, __uint_compare, 11);
hashmap_put(hm, (void *) 50, (void *) 92);
hashmap_put(hm, (void *) 49, (void *) 91);
hashmap_put(hm, (void *) 48, (void *) 90);
hashmap_put(hm, (void *) 47, (void *) 89);
hashmap_put(hm, (void *) 46, (void *) 88);
hashmap_put(hm, (void *) 45, (void *) 87);
/* the following 3 collide: */
hashmap_put(hm, (void *) 1, (void *) 92);
hashmap_put(hm, (void *) 5, (void *) 91);
hashmap_put(hm, (void *) 9, (void *) 90);
hashmap_put(hm2, (void *) 50, (void *) 92);
hashmap_put(hm2, (void *) 49, (void *) 91);
hashmap_put(hm2, (void *) 48, (void *) 90);
hashmap_put(hm2, (void *) 47, (void *) 89);
hashmap_put(hm2, (void *) 46, (void *) 88);
hashmap_put(hm2, (void *) 45, (void *) 87);
/* the following 3 collide: */
hashmap_put(hm2, (void *) 1, (void *) 92);
hashmap_put(hm2, (void *) 5, (void *) 91);
hashmap_put(hm2, (void *) 9, (void *) 90);
hashmap_iterator(hm, &iter);
/* remove every key we iterate on */
while ((key = hashmap_iterator_next(hm, &iter)))
{
CuAssertTrue(tc, NULL != hashmap_remove(hm2, key));
hashmap_remove(hm,key);
}
/* check if the hashmap is empty */
CuAssertTrue(tc, 0 == hashmap_count(hm2));
hashmap_freeall(hm);
hashmap_freeall(hm2);
}
CurlGlue *curl_glue_unref(CurlGlue *g) {
sd_event_source *io;
if (!g)
return NULL;
if (g->curl)
curl_multi_cleanup(g->curl);
while ((io = hashmap_steal_first(g->ios))) {
int fd;
fd = sd_event_source_get_io_fd(io);
assert(fd >= 0);
hashmap_remove(g->translate_fds, FD_TO_PTR(fd));
safe_close(fd);
sd_event_source_unref(io);
}
hashmap_free(g->ios);
sd_event_source_unref(g->timer);
sd_event_unref(g->event);
free(g);
return NULL;
}
void route_free(Route *route) {
if (!route)
return;
if (route->network) {
LIST_REMOVE(routes, route->network->static_routes, route);
assert(route->network->n_static_routes > 0);
route->network->n_static_routes--;
if (route->section)
hashmap_remove(route->network->routes_by_section, route->section);
}
network_config_section_free(route->section);
if (route->link) {
set_remove(route->link->routes, route);
set_remove(route->link->routes_foreign, route);
}
sd_event_source_unref(route->expire);
free(route);
}
void routing_policy_rule_free(RoutingPolicyRule *rule) {
if (!rule)
return;
if (rule->network) {
LIST_REMOVE(rules, rule->network->rules, rule);
assert(rule->network->n_rules > 0);
rule->network->n_rules--;
if (rule->section) {
hashmap_remove(rule->network->rules_by_section, rule->section);
network_config_section_free(rule->section);
}
}
if (rule->manager) {
set_remove(rule->manager->rules, rule);
set_remove(rule->manager->rules_foreign, rule);
}
free(rule->iif);
free(rule->oif);
free(rule);
}
void db_destroy_table_groups(ContentTableGroups *groups)
{
int error;
ContentTable *table;
const App *s_app = appe_get_app_instance();
Logger *logger = s_app->logger;
DEBUG("db_destroy_tables: BEGIN\n");
int i;
for (i = 0; i < DB_MAX_TABLES; i++) {
error = hashmap_get(groups->hashmap_table_groups, groups->table_names[i], (void**)(&table));
if (table != NULL) {
DEBUG("db_destroy_tables: table_name=%s\n", table->table_name);
db_destroy_table(table);
error = hashmap_remove(groups->hashmap_table_groups, groups->table_names[i]);
if (error != MAP_OK) {
logger->log_e(logger, "DB: Groups Free, Table Removed Error.");
}
}
free(groups->table_names[i]);
groups->table_names[i] = NULL;
}
groups->table_count = 0;
DEBUG("db_destroy_tables: OK\n");
hashmap_free(groups->hashmap_table_groups);
free(groups);
groups = NULL;
}
void TestHashmaplinked_IterateHandlesCollisions(
CuTest * tc
)
{
hashmap_t *hm, *hm2;
hashmap_iterator_t iter;
void *key;
hm = hashmap_new(__uint_hash, __uint_compare, 4);
hm2 = hashmap_new(__uint_hash, __uint_compare, 4);
hashmap_put(hm, (void *) 1, (void *) 92);
hashmap_put(hm, (void *) 5, (void *) 91);
hashmap_put(hm, (void *) 9, (void *) 90);
hashmap_put(hm2, (void *) 1, (void *) 92);
hashmap_put(hm2, (void *) 5, (void *) 91);
hashmap_put(hm2, (void *) 9, (void *) 90);
hashmap_iterator(hm, &iter);
/* remove every key we iterate on */
while ((key = hashmap_iterator_next(hm, &iter)))
{
CuAssertTrue(tc, NULL != hashmap_remove(hm2, key));
}
/* check if the hashmap is empty */
CuAssertTrue(tc, 0 == hashmap_count(hm2));
hashmap_freeall(hm);
}
Link *link_free(Link *l) {
if (!l)
return NULL;
/* Send goodbye messages. */
dns_scope_announce(l->mdns_ipv4_scope, true);
dns_scope_announce(l->mdns_ipv6_scope, true);
link_flush_settings(l);
while (l->addresses)
(void) link_address_free(l->addresses);
if (l->manager)
hashmap_remove(l->manager->links, INT_TO_PTR(l->ifindex));
dns_scope_free(l->unicast_scope);
dns_scope_free(l->llmnr_ipv4_scope);
dns_scope_free(l->llmnr_ipv6_scope);
dns_scope_free(l->mdns_ipv4_scope);
dns_scope_free(l->mdns_ipv6_scope);
free(l->state_file);
return mfree(l);
}
int
load_words(struct test *t)
{
int n;
char *word;
int count = 1;
while ((n = get_word(t, &word)) > 0) {
errno = 0;
if (hashmap_put(t->words, word, (void *)count) == -1) {
char *key = word;
int data;
if (errno != EEXIST) {
AMSG("");
return -1;
}
if (hashmap_remove(t->words, (void **)&key, (void **)&data) == -1) {
AMSG("");
return -1;
}
data++;
if (hashmap_put(t->words, word, (void *)data) == -1) {
AMSG("");
return -1;
}
}
}
if (n == -1) {
MMSG("");
return -1;
}
return 0;
}
int link_update_rtnl(Link *l, sd_rtnl_message *m) {
const char *ifname;
int r;
assert(l);
assert(l->manager);
assert(m);
r = sd_rtnl_message_link_get_flags(m, &l->flags);
if (r < 0)
return r;
r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
if (r < 0)
return r;
if (!streq(l->ifname, ifname)) {
char *new_ifname;
new_ifname = strdup(ifname);
if (!new_ifname)
return -ENOMEM;
hashmap_remove(l->manager->links_by_name, l->ifname);
free(l->ifname);
l->ifname = new_ifname;
r = hashmap_put(l->manager->links_by_name, l->ifname, l);
if (r < 0)
return r;
}
return 0;
}
void cgroup_bonding_free(CGroupBonding *b, bool trim) {
assert(b);
if (b->unit) {
CGroupBonding *f;
LIST_REMOVE(CGroupBonding, by_unit, b->unit->cgroup_bondings, b);
if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
assert_se(f = hashmap_get(b->unit->manager->cgroup_bondings, b->path));
LIST_REMOVE(CGroupBonding, by_path, f, b);
if (f)
hashmap_replace(b->unit->manager->cgroup_bondings, b->path, f);
else
hashmap_remove(b->unit->manager->cgroup_bondings, b->path);
}
}
if (b->realized && b->ours && trim)
cg_trim(b->controller, b->path, false);
free(b->controller);
free(b->path);
free(b);
}
/*
* Extract the headers to remove. These headers were listed in the Connection
* and Proxy-Connection headers.
*/
static int
remove_connection_headers(hashmap_t hashofheaders)
{
static char* headers[] = {
"connection",
"proxy-connection"
};
char *data;
char* ptr;
ssize_t len;
int i;
for (i = 0; i != (sizeof(headers) / sizeof(char *)); ++i) {
/* Look for the connection header. If it's not found, return. */
len = hashmap_entry_by_key(hashofheaders, headers[i], (void **)&data);
if (len <= 0)
return 0;
/*
* Go through the data line and replace any special characters
* with a NULL.
*/
ptr = data;
while ((ptr = strpbrk(ptr, "()<>@,;:\\\"/[]?={} \t")))
*ptr++ = '\0';
/*
* All the tokens are separated by NULLs. Now go through the
* token and remove them from the hashofheaders.
*/
ptr = data;
while (ptr < data + len) {
hashmap_remove(hashofheaders, ptr);
/* Advance ptr to the next token */
ptr += strlen(ptr) + 1;
while (*ptr == '\0')
ptr++;
}
/* Now remove the connection header it self. */
hashmap_remove(hashofheaders, headers[i]);
}
return 0;
}
void dcache_remove(struct _fs_instance_t *instance, struct _dentry_t* dentry, const char * name) {
if (!instance->fs->unique_inode) return;
struct key_t key;
key.instance = instance;
key.dentry = dentry;
key.name = name;
hashmap_remove(map, (struct hashmap_key_t*)&key);
}
/*
* Removes a directory listing from the cache.
*/
static void fscache_remove(struct fsentry *fse)
{
if (fse->list)
fse = fse->list;
for (; fse; fse = fse->next)
hashmap_remove(&map, fse, NULL);
}
/**
* Remove the peer.
* Disconnect the peer
*
* @todo add disconnection functionality
*
* @return 1 on sucess; otherwise 0
*/
int bt_peermanager_remove_peer(void *pm, bt_peer_t* peer)
{
bt_peermanager_t *me = pm;
// bt_leeching_choker_add_peer(me->lchoke, peer);
hashmap_remove(me->peers,peer);
return 1;
}
static int enumerate_dir(Hashmap *top, Hashmap *bottom, const char *path) {
_cleanup_closedir_ DIR *d;
assert(top);
assert(bottom);
assert(path);
d = opendir(path);
if (!d) {
if (errno == ENOENT)
return 0;
log_error("Failed to enumerate %s: %m", path);
return -errno;
}
for (;;) {
struct dirent *de;
union dirent_storage buf;
int k;
char *p;
k = readdir_r(d, &buf.de, &de);
if (k != 0)
return -k;
if (!de)
break;
if (!dirent_is_file(de))
continue;
p = strjoin(path, "/", de->d_name, NULL);
if (!p)
return -ENOMEM;
path_kill_slashes(p);
k = hashmap_put(top, path_get_file_name(p), p);
if (k >= 0) {
p = strdup(p);
if (!p)
return -ENOMEM;
} else if (k != -EEXIST) {
free(p);
return k;
}
free(hashmap_remove(bottom, path_get_file_name(p)));
k = hashmap_put(bottom, path_get_file_name(p), p);
if (k < 0) {
free(p);
return k;
}
}
return 0;
}
void closeConnection(Channel ch)
{
int connectionFD = 0;
connectionFD = (int) hashmap_get(sockets_hmap , ch->port);
close(connectionFD);
hashmap_remove(sockets_hmap, ch->port);
openedSockets--;
}
int main(int argc, char* argv) {
int index;
int error;
map_t mymap;
char key_string[KEY_MAX_LENGTH];
data_struct_t* value;
mymap = hashmap_new();
/* First, populate the hash map with ascending values */
for (index=0; index<KEY_COUNT; index+=1) {
/* Store the key string along side the numerical value so we can free it later */
value = malloc(sizeof(data_struct_t));
snprintf(value->key_string, KEY_MAX_LENGTH, "%s%d", KEY_PREFIX, index);
value->number = index;
error = hashmap_put(mymap, value->key_string, value);
assert(error==MAP_OK);
}
/* Now, check all of the expected values are there */
for (index=0; index<KEY_COUNT; index+=1) {
snprintf(key_string, KEY_MAX_LENGTH, "%s%d", KEY_PREFIX, index);
error = hashmap_get(mymap, key_string, (void**)(&value));
/* Make sure the value was both found and the correct number */
assert(error==MAP_OK);
assert(value->number==index);
}
/* Make sure that a value that wasn't in the map can't be found */
snprintf(key_string, KEY_MAX_LENGTH, "%s%d", KEY_PREFIX, KEY_COUNT);
error = hashmap_get(mymap, key_string, (void**)(&value));
/* Make sure the value was not found */
assert(error==MAP_MISSING);
/* Free all of the values we allocated and remove them from the map */
for (index=0; index<KEY_COUNT; index+=1) {
snprintf(key_string, KEY_MAX_LENGTH, "%s%d", KEY_PREFIX, index);
error = hashmap_get(mymap, key_string, (void**)(&value));
assert(error==MAP_OK);
error = hashmap_remove(mymap, key_string);
assert(error==MAP_OK);
free(value);
}
/* Now, destroy the map */
hashmap_free(mymap);
return 1;
}
void remove_name_hash(struct index_state *istate, struct cache_entry *ce)
{
if (!istate->name_hash_initialized || !(ce->ce_flags & CE_HASHED))
return;
ce->ce_flags &= ~CE_HASHED;
hashmap_remove(&istate->name_hash, ce, ce);
if (ignore_case)
remove_dir_entry(istate, ce);
}
void TestHashmaplinked_RemoveReturnsNullIfMissingAndTraversesChain(
CuTest * tc
)
{
hashmap_t *hm;
unsigned long val;
hm = hashmap_new(__uint_hash, __uint_compare, 4);
hashmap_put(hm, (void *) 1, (void *) 92);
val = (unsigned long) hashmap_remove(hm, (void *) 5);
CuAssertTrue(tc, 0 == val);
val = (unsigned long) hashmap_remove(hm, (void *) 1);
CuAssertTrue(tc, 0 != val);
CuAssertTrue(tc, val == 92);
hashmap_freeall(hm);
}
void device_free(Device *d) {
assert(d);
device_detach(d);
hashmap_remove(d->manager->devices, d->sysfs);
free(d->sysfs);
free(d);
}
static DynamicUser* dynamic_user_free(DynamicUser *d) {
if (!d)
return NULL;
if (d->manager)
(void) hashmap_remove(d->manager->dynamic_users, d->name);
safe_close_pair(d->storage_socket);
return mfree(d);
}
void *oidmap_remove(struct oidmap *map, const struct object_id *key)
{
struct hashmap_entry entry;
if (!map->map.cmpfn)
oidmap_init(map, 0);
hashmap_entry_init(&entry, hash(key));
return hashmap_remove(&map->map, &entry, key);
}
void Arena::HookOnPlayerDeath(PlayerPointer plr)
{
ASSERT(plr != NULL);
if (hashmap_get(m_playersAlive, plr->GetLowGUID(), NULL) == MAP_OK) {
m_playersCount[plr->GetTeam()]--;
UpdatePlayerCounts();
hashmap_remove(m_playersAlive, plr->GetLowGUID());
}
}
void netlink_slot_disconnect(sd_netlink_slot *slot, bool unref) {
sd_netlink *nl;
assert(slot);
nl = slot->netlink;
if (!nl)
return;
switch (slot->type) {
case NETLINK_REPLY_CALLBACK:
(void) hashmap_remove(nl->reply_callbacks, &slot->reply_callback.serial);
if (slot->reply_callback.timeout != 0)
prioq_remove(nl->reply_callbacks_prioq, &slot->reply_callback, &slot->reply_callback.prioq_idx);
break;
case NETLINK_MATCH_CALLBACK:
LIST_REMOVE(match_callbacks, nl->match_callbacks, &slot->match_callback);
switch (slot->match_callback.type) {
case RTM_NEWLINK:
case RTM_DELLINK:
(void) socket_broadcast_group_unref(nl, RTNLGRP_LINK);
break;
case RTM_NEWADDR:
case RTM_DELADDR:
(void) socket_broadcast_group_unref(nl, RTNLGRP_IPV4_IFADDR);
(void) socket_broadcast_group_unref(nl, RTNLGRP_IPV6_IFADDR);
break;
case RTM_NEWROUTE:
case RTM_DELROUTE:
(void) socket_broadcast_group_unref(nl, RTNLGRP_IPV4_ROUTE);
(void) socket_broadcast_group_unref(nl, RTNLGRP_IPV6_ROUTE);
break;
}
break;
default:
assert_not_reached("Wut? Unknown slot type?");
}
slot->type = _NETLINK_SLOT_INVALID;
slot->netlink = NULL;
LIST_REMOVE(slots, nl->slots, slot);
if (!slot->floating)
sd_netlink_unref(nl);
else if (unref)
sd_netlink_slot_unref(slot);
}
static void __peer_release(peer_t* p)
{
hashmap_iterator_t iter;
piece_t* pce;
for (hashmap_iterator(p->have_pieces, &iter);
(pce = hashmap_iterator_next(p->have_pieces, &iter));)
{
hashmap_remove(p->have_pieces, p);
}
}
void subprocess_stop(struct hashmap *hashmap, struct subprocess_entry *entry)
{
if (!entry)
return;
entry->process.clean_on_exit = 0;
kill(entry->process.pid, SIGTERM);
finish_command(&entry->process);
hashmap_remove(hashmap, entry, NULL);
}
