return 0;
}
-BPFProgram *bpf_program_ref(BPFProgram *p) {
- if (!p)
- return NULL;
-
- assert(p->n_ref > 0);
- p->n_ref++;
-
- return p;
-}
-
-BPFProgram *bpf_program_unref(BPFProgram *p) {
- if (!p)
- return NULL;
-
- assert(p->n_ref > 0);
- p->n_ref--;
-
- if (p->n_ref > 0)
- return NULL;
+static BPFProgram *bpf_program_free(BPFProgram *p) {
+ assert(p);
/* Unfortunately, the kernel currently doesn't implicitly detach BPF programs from their cgroups when the last
* fd to the BPF program is closed. This has nasty side-effects since this means that abnormally terminated
return mfree(p);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(BPFProgram, bpf_program, bpf_program_free);
+
int bpf_program_add_instructions(BPFProgram *p, const struct bpf_insn *instructions, size_t count) {
assert(p);
return TAKE_PTR(t);
}
-static TableData *table_data_unref(TableData *d) {
- if (!d)
- return NULL;
-
- assert(d->n_ref > 0);
- d->n_ref--;
-
- if (d->n_ref > 0)
- return NULL;
+static TableData *table_data_free(TableData *d) {
+ assert(d);
free(d->formatted);
return mfree(d);
}
+DEFINE_PRIVATE_TRIVIAL_REF_UNREF_FUNC(TableData, table_data, table_data_free);
DEFINE_TRIVIAL_CLEANUP_FUNC(TableData*, table_data_unref);
-static TableData *table_data_ref(TableData *d) {
- if (!d)
- return NULL;
-
- assert(d->n_ref > 0);
- d->n_ref++;
-
- return d;
-}
-
Table *table_unref(Table *t) {
size_t i;
/* Takes a value generated randomly or by hashing and turns it into a UID in the right range */
#define UID_CLAMP_INTO_RANGE(rnd) (((uid_t) (rnd) % (DYNAMIC_UID_MAX - DYNAMIC_UID_MIN + 1)) + DYNAMIC_UID_MIN)
+DEFINE_PRIVATE_TRIVIAL_REF_FUNC(DynamicUser, dynamic_user);
+
static DynamicUser* dynamic_user_free(DynamicUser *d) {
if (!d)
return NULL;
return 0;
}
-static DynamicUser* dynamic_user_ref(DynamicUser *d) {
- if (!d)
- return NULL;
-
- assert(d->n_ref > 0);
- d->n_ref++;
-
- return d;
-}
-
static DynamicUser* dynamic_user_unref(DynamicUser *d) {
if (!d)
return NULL;
return p;
}
-SocketPeer *socket_peer_ref(SocketPeer *p) {
- if (!p)
- return NULL;
-
- assert(p->n_ref > 0);
- p->n_ref++;
-
- return p;
-}
-
-SocketPeer *socket_peer_unref(SocketPeer *p) {
- if (!p)
- return NULL;
-
- assert(p->n_ref > 0);
-
- p->n_ref--;
-
- if (p->n_ref > 0)
- return NULL;
+static SocketPeer *socket_peer_free(SocketPeer *p) {
+ assert(p);
if (p->socket)
set_remove(p->socket->peers_by_address, p);
return mfree(p);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(SocketPeer, socket_peer, socket_peer_free);
+
int socket_acquire_peer(Socket *s, int fd, SocketPeer **p) {
_cleanup_(socket_peer_unrefp) SocketPeer *remote = NULL;
SocketPeer sa = {}, *i;
return w;
}
-Writer* writer_free(Writer *w) {
+static Writer* writer_free(Writer *w) {
if (!w)
return NULL;
return mfree(w);
}
-Writer* writer_unref(Writer *w) {
- if (w && (-- w->n_ref <= 0))
- writer_free(w);
-
- return NULL;
-}
-
-Writer* writer_ref(Writer *w) {
- if (w)
- assert_se(++ w->n_ref >= 2);
-
- return w;
-}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(Writer, writer, writer_free);
int writer_write(Writer *w,
struct iovec_wrapper *iovw,
} Writer;
Writer* writer_new(RemoteServer* server);
-Writer* writer_free(Writer *w);
-
Writer* writer_ref(Writer *w);
Writer* writer_unref(Writer *w);
return m;
}
-MMapCache* mmap_cache_ref(MMapCache *m) {
- assert(m);
- assert(m->n_ref > 0);
-
- m->n_ref++;
- return m;
-}
-
static void window_unlink(Window *w) {
Context *c;
free(c);
}
-static void mmap_cache_free(MMapCache *m) {
+static MMapCache *mmap_cache_free(MMapCache *m) {
int i;
assert(m);
while (m->unused)
window_free(m->unused);
- free(m);
+ return mfree(m);
}
-MMapCache* mmap_cache_unref(MMapCache *m) {
-
- if (!m)
- return NULL;
-
- assert(m->n_ref > 0);
-
- m->n_ref--;
- if (m->n_ref == 0)
- mmap_cache_free(m);
-
- return NULL;
-}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(MMapCache, mmap_cache, mmap_cache_free);
static int make_room(MMapCache *m) {
assert(m);
#include "ndisc-router.h"
#include "strv.h"
-_public_ sd_ndisc_router* sd_ndisc_router_ref(sd_ndisc_router *rt) {
- if (!rt)
- return NULL;
-
- assert(rt->n_ref > 0);
- rt->n_ref++;
-
- return rt;
-}
-
-_public_ sd_ndisc_router* sd_ndisc_router_unref(sd_ndisc_router *rt) {
- if (!rt)
- return NULL;
-
- assert(rt->n_ref > 0);
- rt->n_ref--;
-
- if (rt->n_ref > 0)
- return NULL;
-
- return mfree(rt);
-}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_ndisc_router, sd_ndisc_router, mfree);
sd_ndisc_router *ndisc_router_new(size_t raw_size) {
sd_ndisc_router *rt;
return client->event;
}
-sd_dhcp_client *sd_dhcp_client_ref(sd_dhcp_client *client) {
-
- if (!client)
- return NULL;
-
- assert(client->n_ref >= 1);
- client->n_ref++;
-
- return client;
-}
-
-sd_dhcp_client *sd_dhcp_client_unref(sd_dhcp_client *client) {
-
- if (!client)
- return NULL;
-
- assert(client->n_ref >= 1);
- client->n_ref--;
-
- if (client->n_ref > 0)
- return NULL;
+static sd_dhcp_client *dhcp_client_free(sd_dhcp_client *client) {
+ assert(client);
log_dhcp_client(client, "FREE");
return mfree(client);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_client, sd_dhcp_client, dhcp_client_free);
+
int sd_dhcp_client_new(sd_dhcp_client **ret, int anonymize) {
_cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = NULL;
return 0;
}
-sd_dhcp_lease *sd_dhcp_lease_ref(sd_dhcp_lease *lease) {
-
- if (!lease)
- return NULL;
-
- assert(lease->n_ref >= 1);
- lease->n_ref++;
-
- return lease;
-}
-
-sd_dhcp_lease *sd_dhcp_lease_unref(sd_dhcp_lease *lease) {
-
- if (!lease)
- return NULL;
-
- assert(lease->n_ref >= 1);
- lease->n_ref--;
-
- if (lease->n_ref > 0)
- return NULL;
+static sd_dhcp_lease *dhcp_lease_free(sd_dhcp_lease *lease) {
+ assert(lease);
while (lease->private_options) {
struct sd_dhcp_raw_option *option = lease->private_options;
return mfree(lease);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_lease, sd_dhcp_lease, dhcp_lease_free);
+
static int lease_parse_u32(const uint8_t *option, size_t len, uint32_t *ret, uint32_t min) {
assert(option);
assert(ret);
return !!server->receive_message;
}
-sd_dhcp_server *sd_dhcp_server_ref(sd_dhcp_server *server) {
-
- if (!server)
- return NULL;
-
- assert(server->n_ref >= 1);
- server->n_ref++;
-
- return server;
-}
-
void client_id_hash_func(const void *p, struct siphash *state) {
const DHCPClientId *id = p;
.compare = client_id_compare_func
};
-sd_dhcp_server *sd_dhcp_server_unref(sd_dhcp_server *server) {
+static sd_dhcp_server *dhcp_server_free(sd_dhcp_server *server) {
DHCPLease *lease;
- if (!server)
- return NULL;
-
- assert(server->n_ref >= 1);
- server->n_ref--;
-
- if (server->n_ref > 0)
- return NULL;
+ assert(server);
log_dhcp_server(server, "UNREF");
return mfree(server);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_server, sd_dhcp_server, dhcp_server_free);
+
int sd_dhcp_server_new(sd_dhcp_server **ret, int ifindex) {
_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
return client->event;
}
-sd_dhcp6_client *sd_dhcp6_client_ref(sd_dhcp6_client *client) {
-
- if (!client)
- return NULL;
-
- assert(client->n_ref >= 1);
- client->n_ref++;
-
- return client;
-}
-
-sd_dhcp6_client *sd_dhcp6_client_unref(sd_dhcp6_client *client) {
-
- if (!client)
- return NULL;
-
- assert(client->n_ref >= 1);
- client->n_ref--;
-
- if (client->n_ref > 0)
- return NULL;
+static sd_dhcp6_client *dhcp6_client_free(sd_dhcp6_client *client) {
+ assert(client);
client_reset(client);
return mfree(client);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp6_client, sd_dhcp6_client, dhcp6_client_free);
+
int sd_dhcp6_client_new(sd_dhcp6_client **ret) {
_cleanup_(sd_dhcp6_client_unrefp) sd_dhcp6_client *client = NULL;
size_t t;
return -ENOENT;
}
-sd_dhcp6_lease *sd_dhcp6_lease_ref(sd_dhcp6_lease *lease) {
-
- if (!lease)
- return NULL;
-
- assert(lease->n_ref >= 1);
- lease->n_ref++;
-
- return lease;
-}
-
-sd_dhcp6_lease *sd_dhcp6_lease_unref(sd_dhcp6_lease *lease) {
-
- if (!lease)
- return NULL;
-
- assert(lease->n_ref >= 1);
- lease->n_ref--;
-
- if (lease->n_ref > 0)
- return NULL;
+static sd_dhcp6_lease *dhcp6_lease_free(sd_dhcp6_lease *lease) {
+ assert(lease);
free(lease->serverid);
dhcp6_lease_free_ia(&lease->ia);
return mfree(lease);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp6_lease, sd_dhcp6_lease, dhcp6_lease_free);
+
int dhcp6_lease_new(sd_dhcp6_lease **ret) {
sd_dhcp6_lease *lease;
ipv4acd_set_state(acd, IPV4ACD_STATE_INIT, true);
}
-sd_ipv4acd *sd_ipv4acd_ref(sd_ipv4acd *acd) {
- if (!acd)
- return NULL;
-
- assert_se(acd->n_ref >= 1);
- acd->n_ref++;
-
- return acd;
-}
-
-sd_ipv4acd *sd_ipv4acd_unref(sd_ipv4acd *acd) {
- if (!acd)
- return NULL;
-
- assert_se(acd->n_ref >= 1);
- acd->n_ref--;
-
- if (acd->n_ref > 0)
- return NULL;
+static sd_ipv4acd *ipv4acd_free(sd_ipv4acd *acd) {
+ assert(acd);
ipv4acd_reset(acd);
sd_ipv4acd_detach_event(acd);
return mfree(acd);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_ipv4acd, sd_ipv4acd, ipv4acd_free);
+
int sd_ipv4acd_new(sd_ipv4acd **ret) {
_cleanup_(sd_ipv4acd_unrefp) sd_ipv4acd *acd = NULL;
static void ipv4ll_on_acd(sd_ipv4acd *ll, int event, void *userdata);
-sd_ipv4ll *sd_ipv4ll_ref(sd_ipv4ll *ll) {
- if (!ll)
- return NULL;
-
- assert(ll->n_ref >= 1);
- ll->n_ref++;
-
- return ll;
-}
-
-sd_ipv4ll *sd_ipv4ll_unref(sd_ipv4ll *ll) {
- if (!ll)
- return NULL;
-
- assert(ll->n_ref >= 1);
- ll->n_ref--;
-
- if (ll->n_ref > 0)
- return NULL;
+static sd_ipv4ll *ipv4ll_free(sd_ipv4ll *ll) {
+ assert(ll);
sd_ipv4acd_unref(ll->acd);
return mfree(ll);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_ipv4ll, sd_ipv4ll, ipv4ll_free);
+
int sd_ipv4ll_new(sd_ipv4ll **ret) {
_cleanup_(sd_ipv4ll_unrefp) sd_ipv4ll *ll = NULL;
int r;
return 0;
}
-_public_ sd_lldp* sd_lldp_ref(sd_lldp *lldp) {
-
- if (!lldp)
- return NULL;
-
- assert(lldp->n_ref > 0);
- lldp->n_ref++;
-
- return lldp;
-}
-
-_public_ sd_lldp* sd_lldp_unref(sd_lldp *lldp) {
-
- if (!lldp)
- return NULL;
-
- assert(lldp->n_ref > 0);
- lldp->n_ref --;
-
- if (lldp->n_ref > 0)
- return NULL;
+static sd_lldp* lldp_free(sd_lldp *lldp) {
+ assert(lldp);
lldp_reset(lldp);
sd_lldp_detach_event(lldp);
return mfree(lldp);
}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_lldp, sd_lldp, lldp_free);
+
_public_ int sd_lldp_new(sd_lldp **ret) {
_cleanup_(sd_lldp_unrefp) sd_lldp *lldp = NULL;
int r;
return nd->event;
}
-_public_ sd_ndisc *sd_ndisc_ref(sd_ndisc *nd) {
-
- if (!nd)
- return NULL;
-
- assert(nd->n_ref > 0);
- nd->n_ref++;
-
- return nd;
-}
-
static int ndisc_reset(sd_ndisc *nd) {
assert(nd);
return 0;
}
-_public_ sd_ndisc *sd_ndisc_unref(sd_ndisc *nd) {
-
- if (!nd)
- return NULL;
-
- assert(nd->n_ref > 0);
- nd->n_ref--;
-
- if (nd->n_ref > 0)
- return NULL;
+static sd_ndisc *ndisc_free(sd_ndisc *nd) {
+ assert(nd);
ndisc_reset(nd);
sd_ndisc_detach_event(nd);
return mfree(nd);
}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_ndisc, sd_ndisc, ndisc_free);
+
_public_ int sd_ndisc_new(sd_ndisc **ret) {
_cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
ra->ra_sent = 0;
}
-_public_ sd_radv *sd_radv_ref(sd_radv *ra) {
- if (!ra)
- return NULL;
-
- assert(ra->n_ref > 0);
- ra->n_ref++;
-
- return ra;
-}
-
-_public_ sd_radv *sd_radv_unref(sd_radv *ra) {
- if (!ra)
- return NULL;
-
- assert(ra->n_ref > 0);
- ra->n_ref--;
-
- if (ra->n_ref > 0)
- return NULL;
+static sd_radv *radv_free(sd_radv *ra) {
+ assert(ra);
while (ra->prefixes) {
sd_radv_prefix *p = ra->prefixes;
return mfree(ra);
}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv, sd_radv, radv_free);
+
static int radv_send(sd_radv *ra, const struct in6_addr *dst,
const uint32_t router_lifetime) {
static const struct ether_addr mac_zero = {};
return 0;
}
-_public_ sd_radv_prefix *sd_radv_prefix_ref(sd_radv_prefix *p) {
- if (!p)
- return NULL;
-
- assert(p->n_ref > 0);
- p->n_ref++;
-
- return p;
-}
-
-_public_ sd_radv_prefix *sd_radv_prefix_unref(sd_radv_prefix *p) {
- if (!p)
- return NULL;
-
- assert(p->n_ref > 0);
- p->n_ref--;
-
- if (p->n_ref > 0)
- return NULL;
-
- return mfree(p);
-}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_prefix, sd_radv_prefix, mfree);
_public_ int sd_radv_prefix_set_prefix(sd_radv_prefix *p, const struct in6_addr *in6_addr,
unsigned char prefixlen) {
return 0;
}
-_public_ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
-
- if (!m)
- return NULL;
-
- assert(m->n_ref > 0);
- m->n_ref++;
-
- return m;
-}
-
-_public_ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
-
- if (!m)
- return NULL;
-
- assert(m->n_ref > 0);
- m->n_ref--;
-
- if (m->n_ref > 0)
- return NULL;
-
- return message_free(m);
-}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_bus_message, sd_bus_message, message_free);
_public_ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
assert_return(m, -EINVAL);
return slot;
}
-_public_ sd_bus_slot* sd_bus_slot_ref(sd_bus_slot *slot) {
-
- if (!slot)
- return NULL;
-
- assert(slot->n_ref > 0);
-
- slot->n_ref++;
- return slot;
-}
-
void bus_slot_disconnect(sd_bus_slot *slot, bool unref) {
sd_bus *bus;
sd_bus_slot_unref(slot);
}
-_public_ sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) {
-
- if (!slot)
- return NULL;
-
- assert(slot->n_ref > 0);
-
- if (slot->n_ref > 1) {
- slot->n_ref--;
- return NULL;
- }
+static sd_bus_slot* bus_slot_free(sd_bus_slot *slot) {
+ assert(slot);
bus_slot_disconnect(slot, false);
return mfree(slot);
}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_bus_slot, sd_bus_slot, bus_slot_free);
+
_public_ sd_bus* sd_bus_slot_get_bus(sd_bus_slot *slot) {
assert_return(slot, NULL);
return 0;
}
-_public_ sd_bus_track* sd_bus_track_ref(sd_bus_track *track) {
-
- if (!track)
- return NULL;
-
- assert(track->n_ref > 0);
-
- track->n_ref++;
-
- return track;
-}
-
-_public_ sd_bus_track* sd_bus_track_unref(sd_bus_track *track) {
- if (!track)
- return NULL;
-
- assert(track->n_ref > 0);
- track->n_ref--;
-
- if (track->n_ref > 0)
- return NULL;
+static sd_bus_track *track_free(sd_bus_track *track) {
+ assert(track);
if (track->in_list)
LIST_REMOVE(tracks, track->bus->tracks, track);
return mfree(track);
}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_bus_track, sd_bus_track, track_free);
+
static int on_name_owner_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
sd_bus_track *track = userdata;
const char *name, *old, *new;
return 0;
}
-_public_ sd_device_enumerator *sd_device_enumerator_ref(sd_device_enumerator *enumerator) {
- assert_return(enumerator, NULL);
-
- assert_se((++ enumerator->n_ref) >= 2);
-
- return enumerator;
-}
-
-_public_ sd_device_enumerator *sd_device_enumerator_unref(sd_device_enumerator *enumerator) {
- if (enumerator && (-- enumerator->n_ref) == 0) {
- sd_device *device;
+static sd_device_enumerator *device_enumerator_free(sd_device_enumerator *enumerator) {
+ sd_device *device;
- while ((device = prioq_pop(enumerator->devices)))
- sd_device_unref(device);
+ assert(enumerator);
- prioq_free(enumerator->devices);
+ while ((device = prioq_pop(enumerator->devices)))
+ sd_device_unref(device);
- set_free_free(enumerator->match_subsystem);
- set_free_free(enumerator->nomatch_subsystem);
- hashmap_free_free_free(enumerator->match_sysattr);
- hashmap_free_free_free(enumerator->nomatch_sysattr);
- hashmap_free_free_free(enumerator->match_property);
- set_free_free(enumerator->match_sysname);
- set_free_free(enumerator->match_tag);
- sd_device_unref(enumerator->match_parent);
+ prioq_free(enumerator->devices);
- free(enumerator);
- }
+ set_free_free(enumerator->match_subsystem);
+ set_free_free(enumerator->nomatch_subsystem);
+ hashmap_free_free_free(enumerator->match_sysattr);
+ hashmap_free_free_free(enumerator->nomatch_sysattr);
+ hashmap_free_free_free(enumerator->match_property);
+ set_free_free(enumerator->match_sysname);
+ set_free_free(enumerator->match_tag);
+ sd_device_unref(enumerator->match_parent);
- return NULL;
+ return mfree(enumerator);
}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_device_enumerator, sd_device_enumerator, device_enumerator_free);
+
_public_ int sd_device_enumerator_add_match_subsystem(sd_device_enumerator *enumerator, const char *subsystem, int match) {
Set **set;
int r;
return 0;
}
-_public_ sd_device *sd_device_ref(sd_device *device) {
- if (device)
- assert_se(++ device->n_ref >= 2);
+static sd_device *device_free(sd_device *device) {
+ assert(device);
- return device;
+ sd_device_unref(device->parent);
+ free(device->syspath);
+ free(device->sysname);
+ free(device->devtype);
+ free(device->devname);
+ free(device->subsystem);
+ free(device->driver_subsystem);
+ free(device->driver);
+ free(device->id_filename);
+ free(device->properties_strv);
+ free(device->properties_nulstr);
+
+ ordered_hashmap_free_free_free(device->properties);
+ ordered_hashmap_free_free_free(device->properties_db);
+ hashmap_free_free_free(device->sysattr_values);
+ set_free_free(device->sysattrs);
+ set_free_free(device->tags);
+ set_free_free(device->devlinks);
+
+ return mfree(device);
}
-_public_ sd_device *sd_device_unref(sd_device *device) {
- if (device && -- device->n_ref == 0) {
- sd_device_unref(device->parent);
- free(device->syspath);
- free(device->sysname);
- free(device->devtype);
- free(device->devname);
- free(device->subsystem);
- free(device->driver_subsystem);
- free(device->driver);
- free(device->id_filename);
- free(device->properties_strv);
- free(device->properties_nulstr);
-
- ordered_hashmap_free_free_free(device->properties);
- ordered_hashmap_free_free_free(device->properties_db);
- hashmap_free_free_free(device->sysattr_values);
- set_free_free(device->sysattrs);
- set_free_free(device->tags);
- set_free_free(device->devlinks);
-
- free(device);
- }
-
- return NULL;
-}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_device, sd_device, device_free);
int device_add_property_aux(sd_device *device, const char *_key, const char *_value, bool db) {
OrderedHashmap **properties;
prioq_free(d->latest);
}
-static void event_free(sd_event *e) {
+static sd_event *event_free(sd_event *e) {
sd_event_source *s;
assert(e);
hashmap_free(e->child_sources);
set_free(e->post_sources);
- free(e);
+
+ return mfree(e);
}
_public_ int sd_event_new(sd_event** ret) {
return r;
}
-_public_ sd_event* sd_event_ref(sd_event *e) {
-
- if (!e)
- return NULL;
-
- assert(e->n_ref >= 1);
- e->n_ref++;
-
- return e;
-}
-
-_public_ sd_event* sd_event_unref(sd_event *e) {
-
- if (!e)
- return NULL;
-
- assert(e->n_ref >= 1);
- e->n_ref--;
-
- if (e->n_ref <= 0)
- event_free(e);
-
- return NULL;
-}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_event, sd_event, event_free);
static bool event_pid_changed(sd_event *e) {
assert(e);
return r;
}
-_public_ sd_event_source* sd_event_source_ref(sd_event_source *s) {
-
+static sd_event_source* event_source_free(sd_event_source *s) {
if (!s)
return NULL;
- assert(s->n_ref >= 1);
- s->n_ref++;
+ /* Here's a special hack: when we are called from a
+ * dispatch handler we won't free the event source
+ * immediately, but we will detach the fd from the
+ * epoll. This way it is safe for the caller to unref
+ * the event source and immediately close the fd, but
+ * we still retain a valid event source object after
+ * the callback. */
- return s;
-}
-
-_public_ sd_event_source* sd_event_source_unref(sd_event_source *s) {
-
- if (!s)
- return NULL;
-
- assert(s->n_ref >= 1);
- s->n_ref--;
-
- if (s->n_ref <= 0) {
- /* Here's a special hack: when we are called from a
- * dispatch handler we won't free the event source
- * immediately, but we will detach the fd from the
- * epoll. This way it is safe for the caller to unref
- * the event source and immediately close the fd, but
- * we still retain a valid event source object after
- * the callback. */
-
- if (s->dispatching) {
- if (s->type == SOURCE_IO)
- source_io_unregister(s);
+ if (s->dispatching) {
+ if (s->type == SOURCE_IO)
+ source_io_unregister(s);
- source_disconnect(s);
- } else
- source_free(s);
- }
+ source_disconnect(s);
+ } else
+ source_free(s);
return NULL;
}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_event_source, sd_event_source, event_source_free);
+
_public_ int sd_event_source_set_description(sd_event_source *s, const char *description) {
assert_return(s, -EINVAL);
assert_return(!event_pid_changed(s->event), -ECHILD);
return -ENXIO;
}
-static void resolve_free(sd_resolve *resolve) {
+static sd_resolve *resolve_free(sd_resolve *resolve) {
PROTECT_ERRNO;
sd_resolve_query *q;
unsigned i;
/* Close all communication channels */
close_many(resolve->fds, _FD_MAX);
- free(resolve);
-}
-
-_public_ sd_resolve* sd_resolve_ref(sd_resolve *resolve) {
- assert_return(resolve, NULL);
- assert(resolve->n_ref >= 1);
- resolve->n_ref++;
-
- return resolve;
+ return mfree(resolve);
}
-_public_ sd_resolve* sd_resolve_unref(sd_resolve *resolve) {
- if (!resolve)
- return NULL;
-
- assert(resolve->n_ref >= 1);
- resolve->n_ref--;
-
- if (resolve->n_ref <= 0)
- resolve_free(resolve);
-
- return NULL;
-}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_resolve, sd_resolve, resolve_free);
_public_ int sd_resolve_get_fd(sd_resolve *resolve) {
assert_return(resolve, -EINVAL);
return q->getnameinfo_handler(q, q->ret, q->host, q->serv, q->userdata);
}
-_public_ sd_resolve_query* sd_resolve_query_ref(sd_resolve_query *q) {
- assert_return(q, NULL);
-
- assert(q->n_ref >= 1);
- q->n_ref++;
-
- return q;
-}
-
static void resolve_freeaddrinfo(struct addrinfo *ai) {
while (ai) {
struct addrinfo *next = ai->ai_next;
sd_resolve_unref(resolve);
}
-static void resolve_query_free(sd_resolve_query *q) {
+static sd_resolve_query *resolve_query_free(sd_resolve_query *q) {
assert(q);
resolve_query_disconnect(q);
resolve_freeaddrinfo(q->addrinfo);
free(q->host);
free(q->serv);
- free(q);
-}
-
-_public_ sd_resolve_query* sd_resolve_query_unref(sd_resolve_query* q) {
- if (!q)
- return NULL;
-
- assert(q->n_ref >= 1);
- q->n_ref--;
- if (q->n_ref <= 0)
- resolve_query_free(q);
-
- return NULL;
+ return mfree(q);
}
+DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_resolve_query, sd_resolve_query, resolve_query_free);
+
_public_ int sd_resolve_query_is_done(sd_resolve_query *q) {
assert_return(q, -EINVAL);
assert_return(!resolve_pid_changed(q->resolve), -ECHILD);
}
}
-static void netdev_free(NetDev *netdev) {
- if (!netdev)
- return;
+static NetDev *netdev_free(NetDev *netdev) {
+ assert(netdev);
netdev_cancel_callbacks(netdev);
NETDEV_VTABLE(netdev)->done)
NETDEV_VTABLE(netdev)->done(netdev);
- free(netdev);
-}
-
-NetDev *netdev_unref(NetDev *netdev) {
- if (netdev && (-- netdev->n_ref <= 0))
- netdev_free(netdev);
-
- return NULL;
+ return mfree(netdev);
}
-NetDev *netdev_ref(NetDev *netdev) {
- if (netdev)
- assert_se(++ netdev->n_ref >= 2);
-
- return netdev;
-}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(NetDev, netdev, netdev_free);
void netdev_drop(NetDev *netdev) {
if (!netdev || netdev->state == NETDEV_STATE_LINGER)
return 0;
}
-static void link_free(Link *link) {
+static Link *link_free(Link *link) {
Address *address;
Link *carrier;
Route *route;
Iterator i;
- if (!link)
- return;
+ assert(link);
while ((route = set_first(link->routes)))
route_free(route);
hashmap_remove(link->bound_by_links, INT_TO_PTR(carrier->ifindex));
hashmap_free(link->bound_by_links);
- free(link);
+ return mfree(link);
}
-Link *link_unref(Link *link) {
- if (!link)
- return NULL;
-
- assert(link->n_ref > 0);
-
- link->n_ref--;
-
- if (link->n_ref > 0)
- return NULL;
-
- link_free(link);
-
- return NULL;
-}
-
-Link *link_ref(Link *link) {
- if (!link)
- return NULL;
-
- assert(link->n_ref > 0);
-
- link->n_ref++;
-
- return link;
-}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(Link, link, link_free);
int link_get(Manager *m, int ifindex, Link **ret) {
Link *link;
return a;
}
-DnsAnswer *dns_answer_ref(DnsAnswer *a) {
- if (!a)
- return NULL;
-
- assert(a->n_ref > 0);
- a->n_ref++;
- return a;
-}
-
static void dns_answer_flush(DnsAnswer *a) {
DnsResourceRecord *rr;
a->n_rrs = 0;
}
-DnsAnswer *dns_answer_unref(DnsAnswer *a) {
- if (!a)
- return NULL;
-
- assert(a->n_ref > 0);
-
- if (a->n_ref == 1) {
- dns_answer_flush(a);
- free(a);
- } else
- a->n_ref--;
+static DnsAnswer *dns_answer_free(DnsAnswer *a) {
+ assert(a);
- return NULL;
+ dns_answer_flush(a);
+ return mfree(a);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsAnswer, dns_answer, dns_answer_free);
+
static int dns_answer_add_raw(DnsAnswer *a, DnsResourceRecord *rr, int ifindex, DnsAnswerFlags flags) {
assert(rr);
return q;
}
-DnsQuestion *dns_question_ref(DnsQuestion *q) {
- if (!q)
- return NULL;
-
- assert(q->n_ref > 0);
- q->n_ref++;
- return q;
-}
-
-DnsQuestion *dns_question_unref(DnsQuestion *q) {
- if (!q)
- return NULL;
-
- assert(q->n_ref > 0);
-
- if (q->n_ref == 1) {
- size_t i;
+static DnsQuestion *dns_question_free(DnsQuestion *q) {
+ size_t i;
- for (i = 0; i < q->n_keys; i++)
- dns_resource_key_unref(q->keys[i]);
- free(q);
- } else
- q->n_ref--;
+ assert(q);
- return NULL;
+ for (i = 0; i < q->n_keys; i++)
+ dns_resource_key_unref(q->keys[i]);
+ return mfree(q);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsQuestion, dns_question, dns_question_free);
+
int dns_question_add(DnsQuestion *q, DnsResourceKey *key) {
size_t i;
int r;
return dns_resource_record_new(key);
}
-DnsResourceRecord* dns_resource_record_ref(DnsResourceRecord *rr) {
- if (!rr)
- return NULL;
-
- assert(rr->n_ref > 0);
- rr->n_ref++;
-
- return rr;
-}
-
-DnsResourceRecord* dns_resource_record_unref(DnsResourceRecord *rr) {
- if (!rr)
- return NULL;
-
- assert(rr->n_ref > 0);
-
- if (rr->n_ref > 1) {
- rr->n_ref--;
- return NULL;
- }
+static DnsResourceRecord* dns_resource_record_free(DnsResourceRecord *rr) {
+ assert(rr);
if (rr->key) {
switch(rr->key->type) {
return mfree(rr);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsResourceRecord, dns_resource_record, dns_resource_record_free);
+
int dns_resource_record_new_reverse(DnsResourceRecord **ret, int family, const union in_addr_union *address, const char *hostname) {
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
return 0;
}
-DnsSearchDomain* dns_search_domain_ref(DnsSearchDomain *d) {
- if (!d)
- return NULL;
-
- assert(d->n_ref > 0);
- d->n_ref++;
-
- return d;
-}
-
-DnsSearchDomain* dns_search_domain_unref(DnsSearchDomain *d) {
- if (!d)
- return NULL;
-
- assert(d->n_ref > 0);
- d->n_ref--;
-
- if (d->n_ref > 0)
- return NULL;
+static DnsSearchDomain* dns_search_domain_free(DnsSearchDomain *d) {
+ assert(d);
free(d->name);
return mfree(d);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsSearchDomain, dns_search_domain, dns_search_domain_free);
+
void dns_search_domain_unlink(DnsSearchDomain *d) {
assert(d);
assert(d->manager);
return 0;
}
-DnsServer* dns_server_ref(DnsServer *s) {
- if (!s)
- return NULL;
-
- assert(s->n_ref > 0);
- s->n_ref++;
-
- return s;
-}
-
-DnsServer* dns_server_unref(DnsServer *s) {
- if (!s)
- return NULL;
-
- assert(s->n_ref > 0);
- s->n_ref--;
-
- if (s->n_ref > 0)
- return NULL;
+static DnsServer* dns_server_free(DnsServer *s) {
+ assert(s);
dns_stream_unref(s->stream);
return mfree(s);
}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsServer, dns_server, dns_server_free);
+
void dns_server_unlink(DnsServer *s) {
assert(s);
assert(s->manager);
return 0;
}
-DnsStream *dns_stream_unref(DnsStream *s) {
+static DnsStream *dns_stream_free(DnsStream *s) {
DnsPacket *p;
Iterator i;
- if (!s)
- return NULL;
-
- assert(s->n_ref > 0);
- s->n_ref--;
-
- if (s->n_ref > 0)
- return NULL;
+ assert(s);
dns_stream_stop(s);
return mfree(s);
}
-DnsStream *dns_stream_ref(DnsStream *s) {
- if (!s)
- return NULL;
-
- assert(s->n_ref > 0);
- s->n_ref++;
-
- return s;
-}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsStream, dns_stream, dns_stream_free);
int dns_stream_new(Manager *m, DnsStream **ret, DnsProtocol protocol, int fd, const union sockaddr_union *tfo_address) {
_cleanup_(dns_stream_unrefp) DnsStream *s = NULL;
"/usr/lib/portables\0",
};
-Image *image_unref(Image *i) {
- if (!i)
- return NULL;
-
- assert(i->n_ref > 0);
- i->n_ref--;
-
- if (i->n_ref > 0)
- return NULL;
+static Image *image_free(Image *i) {
+ assert(i);
free(i->name);
free(i->path);
return mfree(i);
}
-Image *image_ref(Image *i) {
- if (!i)
- return NULL;
-
- assert(i->n_ref > 0);
- i->n_ref++;
-
- return i;
-}
+DEFINE_TRIVIAL_REF_UNREF_FUNC(Image, image, image_free);
static char **image_settings_path(Image *image) {
_cleanup_strv_free_ char **l = NULL;
projects / thirdparty / systemd.git / commitdiff
