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 ClientContext* client_context_free(Server *s, ClientContext *c) {
assert(s);
if (!c)
return NULL;
assert_se(hashmap_remove(s->client_contexts, PID_TO_PTR(c->pid)) == c);
if (c->in_lru)
assert_se(prioq_remove(s->client_contexts_lru, c, &c->lru_index) >= 0);
client_context_reset(s, c);
return mfree(c);
}
static void dns_cache_item_unlink_and_free(DnsCache *c, DnsCacheItem *i) {
DnsCacheItem *first;
assert(c);
if (!i)
return;
first = hashmap_get(c->by_key, i->key);
LIST_REMOVE(by_key, first, i);
if (first)
assert_se(hashmap_replace(c->by_key, first->key, first) >= 0);
else
hashmap_remove(c->by_key, i->key);
prioq_remove(c->by_expiry, i, &i->prioq_idx);
dns_cache_item_free(i);
}
void bus_slot_disconnect(sd_bus_slot *slot, bool unref) {
sd_bus *bus;
assert(slot);
if (!slot->bus)
return;
switch (slot->type) {
case BUS_REPLY_CALLBACK:
if (slot->reply_callback.cookie != 0)
ordered_hashmap_remove(slot->bus->reply_callbacks, &slot->reply_callback.cookie);
if (slot->reply_callback.timeout_usec != 0)
prioq_remove(slot->bus->reply_callbacks_prioq, &slot->reply_callback, &slot->reply_callback.prioq_idx);
break;
case BUS_FILTER_CALLBACK:
slot->bus->filter_callbacks_modified = true;
LIST_REMOVE(callbacks, slot->bus->filter_callbacks, &slot->filter_callback);
break;
case BUS_MATCH_CALLBACK:
if (slot->match_added)
(void) bus_remove_match_internal(slot->bus, slot->match_callback.match_string);
if (slot->match_callback.install_slot) {
bus_slot_disconnect(slot->match_callback.install_slot, true);
slot->match_callback.install_slot = sd_bus_slot_unref(slot->match_callback.install_slot);
}
slot->bus->match_callbacks_modified = true;
bus_match_remove(&slot->bus->match_callbacks, &slot->match_callback);
slot->match_callback.match_string = mfree(slot->match_callback.match_string);
break;
case BUS_NODE_CALLBACK:
if (slot->node_callback.node) {
LIST_REMOVE(callbacks, slot->node_callback.node->callbacks, &slot->node_callback);
slot->bus->nodes_modified = true;
bus_node_gc(slot->bus, slot->node_callback.node);
}
break;
case BUS_NODE_ENUMERATOR:
if (slot->node_enumerator.node) {
LIST_REMOVE(enumerators, slot->node_enumerator.node->enumerators, &slot->node_enumerator);
slot->bus->nodes_modified = true;
bus_node_gc(slot->bus, slot->node_enumerator.node);
}
break;
case BUS_NODE_OBJECT_MANAGER:
if (slot->node_object_manager.node) {
LIST_REMOVE(object_managers, slot->node_object_manager.node->object_managers, &slot->node_object_manager);
slot->bus->nodes_modified = true;
bus_node_gc(slot->bus, slot->node_object_manager.node);
}
break;
case BUS_NODE_VTABLE:
if (slot->node_vtable.node && slot->node_vtable.interface && slot->node_vtable.vtable) {
const sd_bus_vtable *v;
for (v = slot->node_vtable.vtable; v->type != _SD_BUS_VTABLE_END; v = bus_vtable_next(slot->node_vtable.vtable, v)) {
struct vtable_member *x = NULL;
switch (v->type) {
case _SD_BUS_VTABLE_METHOD: {
struct vtable_member key;
key.path = slot->node_vtable.node->path;
key.interface = slot->node_vtable.interface;
key.member = v->x.method.member;
x = hashmap_remove(slot->bus->vtable_methods, &key);
break;
}
case _SD_BUS_VTABLE_PROPERTY:
case _SD_BUS_VTABLE_WRITABLE_PROPERTY: {
struct vtable_member key;
key.path = slot->node_vtable.node->path;
key.interface = slot->node_vtable.interface;
key.member = v->x.method.member;
x = hashmap_remove(slot->bus->vtable_properties, &key);
break;
}}
free(x);
}
}
slot->node_vtable.interface = mfree(slot->node_vtable.interface);
if (slot->node_vtable.node) {
LIST_REMOVE(vtables, slot->node_vtable.node->vtables, &slot->node_vtable);
slot->bus->nodes_modified = true;
bus_node_gc(slot->bus, slot->node_vtable.node);
}
break;
default:
assert_not_reached("Wut? Unknown slot type?");
}
bus = slot->bus;
slot->type = _BUS_SLOT_INVALID;
slot->bus = NULL;
LIST_REMOVE(slots, bus->slots, slot);
if (!slot->floating)
sd_bus_unref(bus);
else if (unref)
sd_bus_slot_unref(slot);
}
static void test_struct(void) {
Prioq *q;
Set *s;
unsigned previous = 0, i;
int r;
srand(0);
q = prioq_new(test_compare);
assert_se(q);
s = set_new(test_hash, test_compare);
assert_se(s);
for (i = 0; i < SET_SIZE; i++) {
struct test *t;
t = new0(struct test, 1);
assert_se(t);
t->value = (unsigned) rand();
r = prioq_put(q, t, &t->idx);
assert_se(r >= 0);
if (i % 4 == 0) {
r = set_consume(s, t);
assert_se(r >= 0);
}
}
for (;;) {
struct test *t;
t = set_steal_first(s);
if (!t)
break;
r = prioq_remove(q, t, &t->idx);
assert_se(r > 0);
free(t);
}
for (i = 0; i < SET_SIZE * 3 / 4; i++) {
struct test *t;
assert_se(prioq_size(q) == (SET_SIZE * 3 / 4) - i);
t = prioq_pop(q);
assert_se(t);
assert_se(previous <= t->value);
previous = t->value;
free(t);
}
assert_se(prioq_isempty(q));
prioq_free(q);
assert_se(set_isempty(s));
set_free(s);
}
