if (r < 0)
return log_error_errno(r, "Failed to get host information from systemd: %s", bus_error_message(&error, r));
- *hi = host;
- host = NULL;
+ *hi = TAKE_PTR(host);
return 0;
}
p->prog_type = prog_type;
p->kernel_fd = -1;
- *ret = p;
- p = NULL;
+ *ret = TAKE_PTR(p);
+
return 0;
}
return 0;
}
- *ret = items;
- items = NULL;
+ *ret = TAKE_PTR(items);
return (int) n_items;
}
return r;
}
- *ret = controllers;
- controllers = NULL;
+ *ret = TAKE_PTR(controllers);
return 0;
}
}
/* On success, sets *cpu_set and returns ncpus for the system. */
- if (c) {
- *cpu_set = c;
- c = NULL;
- }
+ if (c)
+ *cpu_set = TAKE_PTR(c);
return (int) ncpus;
}
if (ret) {
buffer[n] = 0;
- *ret = buffer;
- buffer = NULL;
+ *ret = TAKE_PTR(buffer);
}
return (int) count;
*z = 0;
- *mem = r;
- r = NULL;
+ *mem = TAKE_PTR(r);
*len = (l + 1) / 2;
return 0;
*z = 0;
- *mem = r;
- r = NULL;
+ *mem = TAKE_PTR(r);
*_len = len;
return 0;
if (ret_size)
*ret_size = (size_t) (z - buf);
- *ret = buf;
- buf = NULL;
+ *ret = TAKE_PTR(buf);
return 0;
}
if (copy->fd < 0)
return -errno;
- *ret = copy;
- copy = NULL;
+ *ret = TAKE_PTR(copy);
return 0;
}
strv_sort(l);
- *ret = l;
- l = NULL;
+ *ret = TAKE_PTR(l);
return 0;
}
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
+#include "alloc-util.h"
#include "set.h"
int set_make(Set **ret, const struct hash_ops *hash_ops HASHMAP_DEBUG_PARAMS, void *add, ...) {
va_end(ap);
}
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return 0;
}
if ((socklen_t) (int) n != n)
return -E2BIG;
- *ret = d;
- d = NULL;
+ *ret = TAKE_PTR(d);
return (int) n;
}
} else if (errno != ENOENT)
return -errno;
- *ret = zones;
- zones = NULL;
+ *ret = TAKE_PTR(zones);
return 0;
}
if (r < 0)
return log_error_errno(r, "Failed to connect to bus: %m");
- *ret = bus;
- bus = NULL;
+ *ret = TAKE_PTR(bus);
return 0;
}
return r;
} while (false);
- *ret = p;
- p = NULL;
+ *ret = TAKE_PTR(p);
return 0;
}
return -ENOMEM;
v->base = b;
- v->calendar_spec = c;
- c = NULL;
+ v->calendar_spec = TAKE_PTR(c);
LIST_PREPEND(value, t->values, v);
}
return -ENOMEM;
v->base = TIMER_CALENDAR;
- v->calendar_spec = c;
- c = NULL;
+ v->calendar_spec = TAKE_PTR(c);
LIST_PREPEND(value, t->values, v);
}
if (r < 0)
return log_error_errno(r, "Failed to set up API bus: %m");
- m->api_bus = bus;
- bus = NULL;
+ m->api_bus = TAKE_PTR(bus);
r = manager_enqueue_sync_bus_names(m);
if (r < 0)
if (r < 0)
return log_error_errno(r, "Failed to set up system bus: %m");
- m->system_bus = bus;
- bus = NULL;
+ m->system_bus = TAKE_PTR(bus);
return 0;
}
if (!GREEDY_REALLOC(pass_env, n_bufsize, n_env + 2))
return -ENOMEM;
- pass_env[n_env++] = x;
+ pass_env[n_env++] = TAKE_PTR(x);
pass_env[n_env] = NULL;
- x = NULL;
}
*ret = TAKE_PTR(pass_env);
n = sort_job_list(list, n);
- *ret = list;
- list = NULL;
+ *ret = TAKE_PTR(list);
return (int) n;
}
n = sort_job_list(list, n);
- *ret = list;
- list = NULL;
+ *ret = TAKE_PTR(list);
return (int) n;
}
if (r <= 0)
return 0;
- if (!u->dropin_paths) {
- u->dropin_paths = l;
- l = NULL;
- } else {
+ if (!u->dropin_paths)
+ u->dropin_paths = TAKE_PTR(l);
+ else {
r = strv_extend_strv(&u->dropin_paths, l, true);
if (r < 0)
return log_oom();
if (!GREEDY_REALLOC(n, nbufsize, nlen + 2))
return log_oom();
- n[nlen++] = resolved;
+
+ n[nlen++] = TAKE_PTR(resolved);
n[nlen] = NULL;
- resolved = NULL;
}
if (!n || !n[0]) {
if (!nce)
return log_oom();
- nce->argv = n;
- nce->path = path;
+ nce->argv = TAKE_PTR(n);
+ nce->path = TAKE_PTR(path);
nce->flags = flags;
exec_command_append_list(e, nce);
/* Do not _cleanup_free_ these. */
- n = NULL;
- path = NULL;
nce = NULL;
rvalue = p;
if (!GREEDY_REALLOC(n, nbufsize, nlen + 2))
return log_oom();
- n[nlen++] = k;
+ n[nlen++] = TAKE_PTR(k);
n[nlen] = NULL;
- k = NULL;
}
if (n) {
if (!GREEDY_REALLOC(n, nbufsize, nlen + 2))
return log_oom();
- n[nlen++] = k;
+ n[nlen++] = TAKE_PTR(k);
n[nlen] = NULL;
- k = NULL;
}
if (n) {
return r;
}
- free(u->fragment_path);
- u->fragment_path = filename;
- filename = NULL;
+ free_and_replace(u->fragment_path, filename);
if (u->source_path) {
if (stat(u->source_path, &st) >= 0)
if (r < 0)
return log_error_errno(r, "Failed to disable O_CLOEXEC for serialization fds: %m");
- *_f = f;
- *_fds = fds;
-
- f = NULL;
- fds = NULL;
+ *_f = TAKE_PTR(f);
+ *_fds = TAKE_PTR(fds);
return 0;
}
/* Note that we do not set up the notify fd here. We do that after deserialization,
* since they might have gotten serialized across the reexec. */
- *_m = m;
- m = NULL;
+ *_m = TAKE_PTR(m);
+
return 0;
}
f = safe_fclose(f);
- *ret = dump;
- dump = NULL;
+ *ret = TAKE_PTR(dump);
return 0;
}
*b = c;
c[(*n) ++] = (BindMount) {
- .source = s,
- .destination = d,
+ .source = TAKE_PTR(s),
+ .destination = TAKE_PTR(d),
.read_only = item->read_only,
.recursive = item->recursive,
.ignore_enoent = item->ignore_enoent,
};
- s = d = NULL;
return 0;
}
*t = c;
c[(*n) ++] = (TemporaryFileSystem) {
- .path = p,
- .options = o,
+ .path = TAKE_PTR(p),
+ .options = TAKE_PTR(o),
};
- p = o = NULL;
return 0;
}
return -errno;
}
- *path = x;
- x = NULL;
+ *path = TAKE_PTR(x);
return 0;
}
continue;
if (!rfds) {
- rfds = cfds;
+ rfds = TAKE_PTR(cfds);
rn_socket_fds = cn_fds;
-
- cfds = NULL;
} else {
int *t;
rfd_names[n_fds] = NULL;
}
- *fds = rfds;
- *fd_names = rfd_names;
+ *fds = TAKE_PTR(rfds);
+ *fd_names = TAKE_PTR(rfd_names);
*n_socket_fds = rn_socket_fds;
*n_storage_fds = rn_storage_fds;
- rfds = NULL;
- rfd_names = NULL;
-
return 0;
}
remote->socket = s;
- *p = remote;
- remote = NULL;
+ *p = TAKE_PTR(remote);
return 1;
}
cfd = -1; /* We passed ownership of the fd to the service now. Forget it here. */
s->n_connections++;
- service->peer = p; /* Pass ownership of the peer reference */
- p = NULL;
+ service->peer = TAKE_PTR(p); /* Pass ownership of the peer reference */
r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, &error, NULL);
if (r < 0) {
if (r < 0)
return r;
- *ret = u;
- u = NULL;
+ *ret = TAKE_PTR(u);
+
return r;
}
if (u->type == _UNIT_TYPE_INVALID) {
u->type = t;
u->id = s;
- u->instance = i;
+ u->instance = TAKE_PTR(i);
LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
unit_init(u);
-
- i = NULL;
}
s = NULL;
if (r < 0)
return log_oom();
- c = n;
- n = NULL;
+ c = TAKE_PTR(n);
}
c->n_files++;
if (tmp)
unlink_noerrno(tmp);
- *ret_filename = fn_compressed; /* compressed */
- *ret_node_fd = fd_compressed; /* compressed */
- *ret_data_fd = fd; /* uncompressed */
+ *ret_filename = TAKE_PTR(fn_compressed); /* compressed */
+ *ret_node_fd = TAKE_FD(fd_compressed); /* compressed */
+ *ret_data_fd = TAKE_FD(fd); /* uncompressed */
*ret_size = (uint64_t) st.st_size; /* uncompressed */
- fn_compressed = NULL;
- fd = fd_compressed = -1;
-
return 0;
fail_compressed:
if (r < 0)
goto fail;
- *ret_filename = fn;
- *ret_data_fd = fd;
+ *ret_filename = TAKE_PTR(fn);
+ *ret_data_fd = TAKE_FD(fd);
*ret_node_fd = -1;
*ret_size = (uint64_t) st.st_size;
- fn = NULL;
- fd = -1;
-
return 0;
fail:
return -EIO;
}
- *ret = field;
+ *ret = TAKE_PTR(field);
*ret_size = size + 9;
- field = NULL;
-
return 0;
}
log_debug("Journal filter: %s", filter);
}
- *ret = j;
- j = NULL;
+ *ret = TAKE_PTR(j);
return 0;
}
if (r < 0)
return log_error_errno(r, "Failed to attach bus to event loop: %m");
- *_bus = bus;
- bus = NULL;
+ *_bus = TAKE_PTR(bus);
return 0;
}
if (curl_multi_setopt(g->curl, CURLMOPT_TIMERFUNCTION, curl_glue_timer_callback) != CURLM_OK)
return -EINVAL;
- *glue = g;
- g = NULL;
+ *glue = TAKE_PTR(g);
return 0;
}
return r;
}
- *ret = e;
- e = NULL;
+ *ret = TAKE_PTR(e);
return 0;
}
return r;
}
- *ret = e;
- e = NULL;
+ *ret = TAKE_PTR(e);
return 0;
}
return r;
}
- *ret = i;
- i = NULL;
+ *ret = TAKE_PTR(i);
return 0;
}
return r;
}
- *ret = i;
- i = NULL;
+ *ret = TAKE_PTR(i);
return 0;
}
t->manager = m;
t->id = id;
- *ret = t;
- t = NULL;
+ *ret = TAKE_PTR(t);
return 0;
}
if (r < 0)
return r;
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 0;
}
job->on_finished = on_finished;
job->compressed_max = job->uncompressed_max = 1ULL * 1024ULL * 1024ULL;
- *ret = job;
- job = NULL;
+ *ret = TAKE_PTR(job);
return 0;
}
if (!j->url)
return -ENOMEM;
- *ret = j;
- j = NULL;
+ *ret = TAKE_PTR(j);
return 0;
}
i->glue->on_finished = pull_job_curl_on_finished;
i->glue->userdata = i;
- *ret = i;
- i = NULL;
+ *ret = TAKE_PTR(i);
return 0;
}
i->glue->on_finished = pull_job_curl_on_finished;
i->glue->userdata = i;
- *ret = i;
- i = NULL;
+ *ret = TAKE_PTR(i);
return 0;
}
return r;
}
- *writer = w;
- w = NULL;
+ *writer = TAKE_PTR(w);
+
return 0;
}
log_debug("Connection from %s", buf);
- if (hostname) {
- *hostname = buf;
- buf = NULL;
- }
+ if (hostname)
+ *hostname = TAKE_PTR(buf);
r = verify_cert_authorized(session);
if (r < 0) {
if (r < 0)
return r;
- f->post_change_timer = timer;
- timer = NULL;
+ f->post_change_timer = TAKE_PTR(timer);
f->post_change_timer_period = t;
return r;
goto finish;
}
- list[n_list].filename = p;
+ list[n_list].filename = TAKE_PTR(p);
list[n_list].usage = size;
list[n_list].seqnum = seqnum;
list[n_list].realtime = realtime;
list[n_list].have_seqnum = have_seqnum;
n_list++;
- p = NULL;
sum += size;
}
if (!v)
return log_oom();
- if (!arg_output_fields) {
- arg_output_fields = v;
- v = NULL;
- } else {
+ if (!arg_output_fields)
+ arg_output_fields = TAKE_PTR(v);
+ else {
r = strv_extend_strv(&arg_output_fields, v, true);
if (r < 0)
return log_oom();
if (r < 0)
return r;
- *ret = next_boot;
- next_boot = NULL;
+ *ret = TAKE_PTR(next_boot);
return 0;
}
}
}
LIST_INSERT_AFTER(boot_list, head, tail, current);
- tail = current;
- current = NULL;
+ tail = TAKE_PTR(current);
count++;
}
}
}
}
- *units = found;
- found = NULL;
+ *units = TAKE_PTR(found);
+
return 0;
}
free(c->extra_fields_iovec);
free(c->extra_fields_data);
- c->extra_fields_iovec = iovec;
+ c->extra_fields_iovec = TAKE_PTR(iovec);
c->extra_fields_n_iovec = n_iovec;
- c->extra_fields_data = data;
+ c->extra_fields_data = TAKE_PTR(data);
c->extra_fields_mtime = timespec_load_nsec(&st.st_mtim);
- iovec = NULL;
- data = NULL;
-
return 0;
}
if (r < 0)
return r;
- *ret = n;
- n = NULL;
+ *ret = TAKE_PTR(n);
return r;
}
if (r < 0)
return r;
- *ret = rt;
- rt = NULL;
+ *ret = TAKE_PTR(rt);
return r;
}
return 0;
}
- *ret = l;
- l = NULL;
+ *ret = TAKE_PTR(l);
return k;
}
*_optlen = optlen;
*_optoffset = optoffset;
- *ret = packet;
- packet = NULL;
+ *ret = TAKE_PTR(packet);
return 0;
}
}
sd_dhcp_lease_unref(client->lease);
- client->lease = lease;
- lease = NULL;
+ client->lease = TAKE_PTR(lease);
log_dhcp_client(client, "OFFER");
client->lease = sd_dhcp_lease_unref(client->lease);
}
- client->lease = lease;
- lease = NULL;
+ client->lease = TAKE_PTR(lease);
log_dhcp_client(client, "ACK");
if (!client->req_opts)
return -ENOMEM;
- *ret = client;
- client = NULL;
+ *ret = TAKE_PTR(client);
return 0;
}
return r;
}
- *ret = lease;
- lease = NULL;
+ *ret = TAKE_PTR(lease);
return 0;
}
server->default_lease_time = DIV_ROUND_UP(DHCP_DEFAULT_LEASE_TIME_USEC, USEC_PER_SEC);
server->max_lease_time = DIV_ROUND_UP(DHCP_MAX_LEASE_TIME_USEC, USEC_PER_SEC);
- *ret = server;
- server = NULL;
+ *ret = TAKE_PTR(server);
return 0;
}
memcpy(&packet->dhcp.chaddr, &req->message->chaddr, ETH_ALEN);
*_optoffset = optoffset;
- *ret = packet;
- packet = NULL;
+ *ret = TAKE_PTR(packet);
return 0;
}
for (t = 0; t < client->req_opts_len; t++)
client->req_opts[t] = htobe16(default_req_opts[t]);
- *ret = client;
- client = NULL;
+ *ret = TAKE_PTR(client);
return 0;
}
acd->ifindex = -1;
acd->fd = -1;
- *ret = acd;
- acd = NULL;
+ *ret = TAKE_PTR(acd);
return 0;
}
(void) sd_event_source_set_description(timer, "ipv4acd-timer");
sd_event_source_unref(acd->timer_event_source);
- acd->timer_event_source = timer;
- timer = NULL;
+ acd->timer_event_source = TAKE_PTR(timer);
return 0;
}
if (r < 0)
return r;
- *ret = ll;
- ll = NULL;
+ *ret = TAKE_PTR(ll);
return 0;
}
if (r < 0)
return r;
- *ret = lldp;
- lldp = NULL;
+ *ret = TAKE_PTR(lldp);
return 0;
}
nd->n_ref = 1;
nd->fd = -1;
- *ret = nd;
- nd = NULL;
+ *ret = TAKE_PTR(nd);
return 0;
}
LIST_HEAD_INIT(ra->prefixes);
- *ret = ra;
- ra = NULL;
+ *ret = TAKE_PTR(ra);
return 0;
}
memcpy(opt_rdnss + 1, dns, n_dns * sizeof(struct in6_addr));
- free(ra->rdnss);
- ra->rdnss = opt_rdnss;
- opt_rdnss = NULL;
+ free_and_replace(ra->rdnss, opt_rdnss);
ra->n_rdnss = n_dns;
len -= r;
}
- free(ra->dnssl);
- ra->dnssl = opt_dnssl;
- opt_dnssl = NULL;
+ free_and_replace(ra->dnssl, opt_dnssl);
return 0;
}
LIST_INIT(prefix, p);
- *ret = p;
- p = NULL;
+ *ret = TAKE_PTR(p);
return 0;
}
if (r < 0)
return r;
- *activatable = y;
- y = NULL;
+ *activatable = TAKE_PTR(y);
}
- if (acquired) {
- *acquired = x;
- x = NULL;
- }
+ if (acquired)
+ *acquired = TAKE_PTR(x);
return 0;
}
return r;
}
- if (creds) {
- *creds = c;
- c = NULL;
- }
+ if (creds)
+ *creds = TAKE_PTR(c);
return 0;
}
if (r < 0)
return r;
- *ret = c;
- c = NULL;
+ *ret = TAKE_PTR(c);
+
return 0;
}
if (r < 0)
return r;
- *ret = n;
- n = NULL;
+ *ret = TAKE_PTR(n);
+
return 0;
}
}
components[n_components].type = t;
- components[n_components].value_str = value;
+ components[n_components].value_str = TAKE_PTR(value);
components[n_components].value_u8 = u;
n_components++;
- value = NULL;
if (q[quoted] == 0)
break;
}
m->bus = sd_bus_ref(bus);
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 0;
}
return r;
sd_bus_message_unref(*m);
- *m = n;
- n = NULL;
+ *m = TAKE_PTR(n);
return 0;
}
/* Insert at the very front */
memmove(bus->rqueue + 1, bus->rqueue, sizeof(sd_bus_message*) * bus->rqueue_size);
- bus->rqueue[0] = m;
- m = NULL;
+ bus->rqueue[0] = TAKE_PTR(m);
bus->rqueue_size++;
return 0;
if (r < 0)
return r;
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
+
return 1;
}
bus->exit_triggered = true;
(void) bus_exit_now(bus);
- if (ret) {
- *ret = m;
- m = NULL;
- }
+ if (ret)
+ *ret = TAKE_PTR(m);
r = 1;
enumerator->n_ref = 1;
enumerator->type = _DEVICE_ENUMERATION_TYPE_INVALID;
- *ret = enumerator;
- enumerator = NULL;
+ *ret = TAKE_PTR(enumerator);
return 0;
}
if (r < 0)
return r;
- *ret = device;
- device = NULL;
+ *ret = TAKE_PTR(device);
return 0;
}
if (r < 0)
return r;
- *ret = device;
- device = NULL;
+ *ret = TAKE_PTR(device);
return 0;
}
ret->devnum = old_device->devnum;
- *new_device = ret;
- ret = NULL;
+ *new_device = TAKE_PTR(ret);
return 0;
}
ret->sealed = true;
- *new_device = ret;
- ret = NULL;
+ *new_device = TAKE_PTR(ret);
return 0;
}
if (r < 0)
return r;
- *new_device = ret;
- ret = NULL;
+ *new_device = TAKE_PTR(ret);
return 0;
}
#include "util.h"
int device_new_aux(sd_device **ret) {
- _cleanup_(sd_device_unrefp) sd_device *device = NULL;
+ sd_device *device = NULL;
assert(ret);
device->watch_handle = -1;
*ret = device;
- device = NULL;
return 0;
}
if (r < 0)
return r;
- *ret = device;
- device = NULL;
+ *ret = TAKE_PTR(device);
return 0;
}
if (ifr.ifr_ifindex != ifindex)
return -ENODEV;
- *ret = device;
- device = NULL;
+ *ret = TAKE_PTR(device);
return 0;
}
if (r < 0)
return r;
- *_value = value;
- value = NULL;
+ *_value = TAKE_PTR(value);
return 0;
}
log_debug("strings %8"PRIu64" bytes", le64toh(hwdb->head->strings_len));
log_debug("nodes %8"PRIu64" bytes", le64toh(hwdb->head->nodes_len));
- *ret = hwdb;
- hwdb = NULL;
+ *ret = TAKE_PTR(hwdb);
return 0;
}
r = strv_length(a);
- if (sessions) {
- *sessions = a;
- a = NULL;
- }
+ if (sessions)
+ *sessions = TAKE_PTR(a);
- if (uids) {
- *uids = b;
- b = NULL;
- }
+ if (uids)
+ *uids = TAKE_PTR(b);
if (n_uids)
*n_uids = n;
r++;
}
- if (users) {
- *users = l;
- l = NULL;
- }
+ if (users)
+ *users = TAKE_PTR(l);
return r;
}
genl->cmd = cmd;
genl->version = genl_families[family].version;
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 0;
}
qsort_safe(list, n_list, sizeof(struct local_address), address_compare);
- *ret = list;
- list = NULL;
+ *ret = TAKE_PTR(list);
return (int) n_list;
}
if (n_list > 0)
qsort(list, n_list, sizeof(struct local_address), address_compare);
- *ret = list;
- list = NULL;
+ *ret = TAKE_PTR(list);
return (int) n_list;
}
m->hdr->nlmsg_len = size;
m->hdr->nlmsg_type = type;
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 0;
}
/* push the message onto the multi-part message stack */
if (first)
m->next = first;
- first = m;
- m = NULL;
+ first = TAKE_PTR(m);
}
if (len > 0)
if (r < 0)
return r;
- rtnl->rqueue[rtnl->rqueue_size++] = first;
- first = NULL;
+ rtnl->rqueue[rtnl->rqueue_size++] = TAKE_PTR(first);
if (multi_part && (i < rtnl->rqueue_partial_size)) {
/* remove the message form the partial read queue */
/* we only got a partial multi-part message, push it on the
partial read queue */
if (i < rtnl->rqueue_partial_size)
- rtnl->rqueue_partial[i] = first;
+ rtnl->rqueue_partial[i] = TAKE_PTR(first);
else {
r = rtnl_rqueue_partial_make_room(rtnl);
if (r < 0)
return r;
- rtnl->rqueue_partial[rtnl->rqueue_partial_size++] = first;
+ rtnl->rqueue_partial[rtnl->rqueue_partial_size++] = TAKE_PTR(first);
}
- first = NULL;
return 0;
}
* responses with notifications from the kernel */
rtnl->serial = 1;
- *ret = rtnl;
- rtnl = NULL;
+ *ret = TAKE_PTR(rtnl);
return 0;
}
rtnl->fd = fd;
- *ret = rtnl;
- rtnl = NULL;
+ *ret = TAKE_PTR(rtnl);
return 0;
}
return r;
}
- *ret = rtnl;
- rtnl = NULL;
+ *ret = TAKE_PTR(rtnl);
return 0;
}
}
if (ret) {
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 1;
}
return 0;
}
- if (ret) {
- *ret = incoming;
- incoming = NULL;
- }
+ if (ret)
+ *ret = TAKE_PTR(incoming);
return 1;
}
}
hwdb->refcount = 1;
- hwdb->hwdb = hwdb_internal;
- hwdb_internal = NULL;
+ hwdb->hwdb = TAKE_PTR(hwdb_internal);
udev_list_init(udev, &hwdb->properties_list, true);
if (streq(lang, a[0])) {
assert(strv_length(a) == 2);
- *language = a[1];
- a[1] = NULL;
+ *language = TAKE_PTR(a[1]);
return 1;
}
}
if (r < 0)
return log_error_errno(r, "Failed to attach bus to event loop: %m");
- *_bus = bus;
- bus = NULL;
+ *_bus = TAKE_PTR(bus);
return 0;
}
}
}
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return 1;
}
}
}
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return 1;
}
}
}
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return 1;
}
if (r < 0)
return r;
- *out = u;
- u = NULL;
+ *out = TAKE_PTR(u);
+
return 0;
}
return r;
}
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return 1;
}
if (r < 0)
return r;
- *ret = bus;
- bus = NULL;
+ *ret = TAKE_PTR(bus);
break;
}
} else {
if (!path_is_absolute(path))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Specified path '%s' is not absolute", path);
- args = args_wire;
- args_wire = NULL;
+ args = TAKE_PTR(args_wire);
if (strv_isempty(args)) {
args = strv_free(args);
if (!m->create_message)
return 0;
- c = m->create_message;
- m->create_message = NULL;
+ c = TAKE_PTR(m->create_message);
if (error)
return sd_bus_reply_method_error(c, error);
t->leader = 1;
t->id = mid;
- t->root_directory = rd;
- t->unit = unit;
- rd = unit = NULL;
+ t->root_directory = TAKE_PTR(rd);
+ t->unit = TAKE_PTR(unit);
dual_timestamp_from_boottime_or_monotonic(&t->timestamp, 0);
if (!port)
return log_oom();
- endpoint->peer = peer;
- endpoint->host = host;
- endpoint->port = port;
+ endpoint->peer = TAKE_PTR(peer);
+ endpoint->host = TAKE_PTR(host);
+ endpoint->port = TAKE_PTR(port);
endpoint->netdev = netdev_ref(data);
LIST_PREPEND(endpoints, w->unresolved_endpoints, endpoint);
-
- peer = NULL;
- host = NULL;
- port = NULL;
endpoint = NULL;
return 0;
qsort_safe(links, c, sizeof(LinkInfo), link_info_compare);
- *ret = links;
- links = NULL;
+ *ret = TAKE_PTR(links);
return (int) c;
}
qsort_safe(links, c, sizeof(LinkInfo), link_info_compare);
- *ret = links;
- links = NULL;
+ *ret = TAKE_PTR(links);
return (int) c;
}
if (!addrlabel)
return -ENOMEM;
- *ret = addrlabel;
- addrlabel = NULL;
+ *ret = TAKE_PTR(addrlabel);
return 0;
}
label = hashmap_get(network->address_labels_by_section, n);
if (label) {
- *ret = label;
- label = NULL;
+ *ret = TAKE_PTR(label);
return 0;
}
if (r < 0)
return r;
- label->section = n;
- n = NULL;
+ label->section = TAKE_PTR(n);
r = hashmap_put(network->address_labels_by_section, label->section, label);
if (r < 0)
LIST_APPEND(labels, network->address_labels, label);
network->n_address_labels++;
- *ret = label;
- label = NULL;
+ *ret = TAKE_PTR(label);
return 0;
}
address->cinfo.ifa_prefered = CACHE_INFO_INFINITY_LIFE_TIME;
address->cinfo.ifa_valid = CACHE_INFO_INFINITY_LIFE_TIME;
- *ret = address;
- address = NULL;
+ *ret = TAKE_PTR(address);
return 0;
}
address = hashmap_get(network->addresses_by_section, n);
if (address) {
- *ret = address;
- address = NULL;
+ *ret = TAKE_PTR(address);
return 0;
}
return r;
if (filename) {
- address->section = n;
- n = NULL;
+ address->section = TAKE_PTR(n);
r = hashmap_put(network->addresses_by_section, address->section, address);
if (r < 0)
LIST_APPEND(addresses, network->static_addresses, address);
network->n_static_addresses++;
- *ret = address;
- address = NULL;
+ *ret = TAKE_PTR(address);
return 0;
}
LIST_PREPEND(addresses, link->pool_addresses, na);
- *ret = na;
- na = NULL;
+ *ret = TAKE_PTR(na);
return 0;
}
if (section) {
fdb_entry = hashmap_get(network->fdb_entries_by_section, UINT_TO_PTR(section));
if (fdb_entry) {
- *ret = fdb_entry;
- fdb_entry = NULL;
+ *ret = TAKE_PTR(fdb_entry);
return 0;
}
}
/* return allocated FDB structure. */
- *ret = fdb_entry;
- fdb_entry = NULL;
+ *ret = TAKE_PTR(fdb_entry);
return 0;
}
if (r < 0)
return r;
- *ret = link;
- link = NULL;
+ *ret = TAKE_PTR(link);
return 0;
}
route->lifetime = lifetime;
sd_event_source_unref(route->expire);
- route->expire = expire;
- expire = NULL;
+ route->expire = TAKE_PTR(expire);
}
}
assert(p == (uint8_t*) packet + l);
- *ret = packet;
+ *ret = TAKE_PTR(packet);
*sz = l;
- packet = NULL;
return 0;
}
(void) routing_policy_load_rules(m->state_file, &m->rules_saved);
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 0;
}
if (section_line) {
prefix = hashmap_get(network->prefixes_by_section, n);
if (prefix) {
- *ret = prefix;
- prefix = NULL;
+ *ret = TAKE_PTR(prefix);
return 0;
}
return r;
if (filename) {
- prefix->section = n;
- n = NULL;
+ prefix->section = TAKE_PTR(n);
r = hashmap_put(network->prefixes_by_section, prefix->section,
prefix);
LIST_APPEND(prefixes, network->static_prefixes, prefix);
network->n_static_prefixes++;
- *ret = prefix;
- prefix = NULL;
+ *ret = TAKE_PTR(prefix);
return 0;
}
route->lifetime = USEC_INFINITY;
route->quickack = -1;
- *ret = route;
- route = NULL;
+ *ret = TAKE_PTR(route);
return 0;
}
route = hashmap_get(network->routes_by_section, n);
if (route) {
- *ret = route;
- route = NULL;
+ *ret = TAKE_PTR(route);
return 0;
}
route->protocol = RTPROT_STATIC;
if (filename) {
- route->section = n;
- n = NULL;
+ route->section = TAKE_PTR(n);
r = hashmap_put(network->routes_by_section, route->section, route);
if (r < 0)
LIST_PREPEND(routes, network->static_routes, route);
network->n_static_routes++;
- *ret = route;
- route = NULL;
+ *ret = TAKE_PTR(route);
return 0;
}
}
sd_event_source_unref(route->expire);
- route->expire = expire;
- expire = NULL;
+ route->expire = TAKE_PTR(expire);
return 0;
}
rule = hashmap_get(network->rules_by_section, n);
if (rule) {
- *ret = rule;
- rule = NULL;
+ *ret = TAKE_PTR(rule);
return 0;
}
LIST_APPEND(rules, network->rules, rule);
network->n_rules++;
- *ret = rule;
- rule = NULL;
+ *ret = TAKE_PTR(rule);
return 0;
}
if (r < 0)
return r;
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 0;
}
if (r < 0)
return log_error_errno(r, "Failed to add to even loop: %m");
- *ret = rtnl;
- rtnl = NULL;
+ *ret = TAKE_PTR(rtnl);
return 0;
}
if (!m)
return -ENOMEM;
- m->destination = path;
- m->options = opts;
+ m->destination = TAKE_PTR(path);
+ m->options = TAKE_PTR(opts);
- path = opts = NULL;
return 0;
}
if (!m)
return -ENOMEM;
- m->destination = destination;
- m->source = upper;
- m->lower = lower;
+ m->destination = TAKE_PTR(destination);
+ m->source = TAKE_PTR(upper);
+ m->lower = TAKE_PTR(lower);
m->read_only = read_only;
- upper = destination = NULL;
- lower = NULL;
-
return 0;
}
return r;
}
- *ret = controllers;
- controllers = NULL;
+ *ret = TAKE_PTR(controllers);
return 0;
}
return -errno;
}
- *ret = copy;
- copy = NULL;
+ *ret = TAKE_PTR(copy);
return !!*ret;
}
if (s->userns_chown >= 0 && s->userns_mode == _USER_NAMESPACE_MODE_INVALID)
s->userns_mode = USER_NAMESPACE_NO;
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return 0;
}
if (setresuid(uid, uid, uid) < 0)
return log_error_errno(errno, "setresuid() failed: %m");
- if (_home) {
- *_home = home;
- home = NULL;
- }
+ if (_home)
+ *_home = TAKE_PTR(home);
return 0;
}
f = fopen(j, "re");
if (f) {
- p = j;
- j = NULL;
+ p = TAKE_PTR(j);
/* By default, we trust configuration from /etc and /run */
if (arg_settings_trusted < 0)
arg_start_mode = settings->start_mode;
strv_free(arg_parameters);
- arg_parameters = settings->parameters;
- settings->parameters = NULL;
+ arg_parameters = TAKE_PTR(settings->parameters);
}
if ((arg_settings_mask & SETTING_PIVOT_ROOT) == 0 &&
}
if ((arg_settings_mask & SETTING_WORKING_DIRECTORY) == 0 &&
- settings->working_directory) {
- free(arg_chdir);
- arg_chdir = settings->working_directory;
- settings->working_directory = NULL;
- }
+ settings->working_directory)
+ free_and_replace(arg_chdir, settings->working_directory);
if ((arg_settings_mask & SETTING_ENVIRONMENT) == 0 &&
settings->environment) {
strv_free(arg_setenv);
- arg_setenv = settings->environment;
- settings->environment = NULL;
+ arg_setenv = TAKE_PTR(settings->environment);
}
if ((arg_settings_mask & SETTING_USER) == 0 &&
- settings->user) {
- free(arg_user);
- arg_user = settings->user;
- settings->user = NULL;
- }
+ settings->user)
+ free_and_replace(arg_user, settings->user);
if ((arg_settings_mask & SETTING_CAPABILITY) == 0) {
uint64_t plus;
log_warning("Ignoring TemporaryFileSystem=, Bind= and BindReadOnly= settings, file %s is not trusted.", p);
else {
custom_mount_free_all(arg_custom_mounts, arg_n_custom_mounts);
- arg_custom_mounts = settings->custom_mounts;
+ arg_custom_mounts = TAKE_PTR(settings->custom_mounts);
arg_n_custom_mounts = settings->n_custom_mounts;
-
- settings->custom_mounts = NULL;
settings->n_custom_mounts = 0;
}
}
arg_private_network = settings_private_network(settings);
strv_free(arg_network_interfaces);
- arg_network_interfaces = settings->network_interfaces;
- settings->network_interfaces = NULL;
+ arg_network_interfaces = TAKE_PTR(settings->network_interfaces);
strv_free(arg_network_macvlan);
- arg_network_macvlan = settings->network_macvlan;
- settings->network_macvlan = NULL;
+ arg_network_macvlan = TAKE_PTR(settings->network_macvlan);
strv_free(arg_network_ipvlan);
- arg_network_ipvlan = settings->network_ipvlan;
- settings->network_ipvlan = NULL;
+ arg_network_ipvlan = TAKE_PTR(settings->network_ipvlan);
strv_free(arg_network_veth_extra);
- arg_network_veth_extra = settings->network_veth_extra;
- settings->network_veth_extra = NULL;
+ arg_network_veth_extra = TAKE_PTR(settings->network_veth_extra);
- free(arg_network_bridge);
- arg_network_bridge = settings->network_bridge;
- settings->network_bridge = NULL;
-
- free(arg_network_zone);
- arg_network_zone = settings->network_zone;
- settings->network_zone = NULL;
+ free_and_replace(arg_network_bridge, settings->network_bridge);
+ free_and_replace(arg_network_zone, settings->network_zone);
}
}
log_warning("Ignoring Port= setting, file %s is not trusted.", p);
else {
expose_port_free_all(arg_expose_ports);
- arg_expose_ports = settings->expose_ports;
- settings->expose_ports = NULL;
+ arg_expose_ports = TAKE_PTR(settings->expose_ports);
}
}
strv_free(arg_syscall_whitelist);
strv_free(arg_syscall_blacklist);
- arg_syscall_whitelist = settings->syscall_whitelist;
- arg_syscall_blacklist = settings->syscall_blacklist;
-
- settings->syscall_whitelist = settings->syscall_blacklist = NULL;
+ arg_syscall_whitelist = TAKE_PTR(settings->syscall_whitelist);
+ arg_syscall_blacklist = TAKE_PTR(settings->syscall_blacklist);
}
}
goto finish;
}
- free(arg_directory);
- arg_directory = np;
- np = NULL;
+ free_and_replace(arg_directory, np);
remove_directory = true;
goto finish;
}
- free(arg_image);
- arg_image = np;
- np = NULL;
+ free_and_replace(arg_image, np);
remove_image = true;
} else {
r = split_pair(word, "=", &key, &value);
if (r == -ENOMEM)
return log_oom();
- if (r == -EINVAL) {
- key = word;
- word = NULL;
- }
+ if (r == -EINVAL)
+ key = TAKE_PTR(word);
if (!ascii_is_valid(key)) {
log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid syntax, ignoring: %s", key);
if (r < 0)
return r;
- *ret = k;
- k = NULL;
+ *ret = TAKE_PTR(k);
return 0;
}
}
dns_answer_unref(*a);
- *a = copy;
- copy = NULL;
+ *a = TAKE_PTR(copy);
return 1;
}
}
dns_answer_unref(*a);
- *a = copy;
- copy = NULL;
+ *a = TAKE_PTR(copy);
return 1;
}
return r;
dns_answer_unref(*a);
- *a = n;
- n = NULL;
+ *a = TAKE_PTR(n);
return 0;
}
if (after_rindex != 0)
p->rindex= after_rindex;
- *_ret = ret;
- ret = NULL;
+ *_ret = TAKE_PTR(ret);
if (start)
*start = rewinder.saved_rindex;
if (p->rindex != offset + rdlength)
return -EBADMSG;
- *ret = rr;
- rr = NULL;
+ *ret = TAKE_PTR(rr);
if (ret_cache_flush)
*ret_cache_flush = cache_flush;
}
}
- *ret_question = question;
- question = NULL;
+ *ret_question = TAKE_PTR(question);
+
return 0;
}
if (bad_opt)
p->opt = dns_resource_record_unref(p->opt);
- *ret_answer = answer;
- answer = NULL;
+ *ret_answer = TAKE_PTR(answer);
+
return 0;
}
if (r < 0)
return r;
- p->question = question;
- question = NULL;
-
- p->answer = answer;
- answer = NULL;
+ p->question = TAKE_PTR(question);
+ p->answer = TAKE_PTR(answer);
p->extracted = true;
dns_query_reset_answer(q);
- q->answer = answer;
- answer = NULL;
+ q->answer = TAKE_PTR(answer);
q->answer_rcode = DNS_RCODE_SUCCESS;
q->answer_protocol = dns_synthesize_protocol(q->flags);
q->answer_family = dns_synthesize_family(q->flags);
dns_query_reset_answer(q);
- q->answer = answer;
- answer = NULL;
+ q->answer = TAKE_PTR(answer);
q->answer_rcode = DNS_RCODE_SUCCESS;
q->answer_protocol = dns_synthesize_protocol(q->flags);
q->answer_family = dns_synthesize_family(q->flags);
q->flags |= SD_RESOLVED_NO_SEARCH;
dns_question_unref(q->question_idna);
- q->question_idna = nq_idna;
- nq_idna = NULL;
+ q->question_idna = TAKE_PTR(nq_idna);
dns_question_unref(q->question_utf8);
- q->question_utf8 = nq_utf8;
- nq_utf8 = NULL;
+ q->question_utf8 = TAKE_PTR(nq_utf8);
dns_query_free_candidates(q);
dns_query_reset_answer(q);
return r;
}
- *ret = n;
- n = NULL;
+ *ret = TAKE_PTR(n);
return 1;
}
return r;
}
- *ret = q;
- q = NULL;
+ *ret = TAKE_PTR(q);
return 0;
}
if (r < 0)
return r;
- *ret = q;
- q = NULL;
+ *ret = TAKE_PTR(q);
return 0;
}
return r;
}
- *ret = q;
- q = NULL;
+ *ret = TAKE_PTR(q);
return 0;
}
if (!rr->ptr.name)
return -ENOMEM;
- *ret = rr;
- rr = NULL;
+ *ret = TAKE_PTR(rr);
return 0;
}
break;
}
- t = copy;
- copy = NULL;
+ t = TAKE_PTR(copy);
return t;
}
return r;
DNS_PACKET_HEADER(p)->arcount = htobe16(dns_answer_size(soa));
- *ret = p;
- p = NULL;
+ *ret = TAKE_PTR(p);
return 0;
}
if (r < 0)
return r;
- *ret = p;
- p = NULL;
+ *ret = TAKE_PTR(p);
return 0;
}
s->fd = fd;
m->n_dns_streams++;
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return 0;
}
if (found) {
- if (ret) {
- *ret = answer;
- answer = NULL;
- }
+ if (ret)
+ *ret = TAKE_PTR(answer);
return 1;
} else if (nxdomain)
}
DNS_PACKET_HEADER(p)->nscount = htobe16(nscount);
- t->sent = p;
- p = NULL;
+ t->sent = TAKE_PTR(p);
return 0;
}
DNS_PACKET_HEADER(p)->qdcount = htobe16(1);
DNS_PACKET_HEADER(p)->id = t->id;
- t->sent = p;
- p = NULL;
+ t->sent = TAKE_PTR(p);
return 0;
}
}
dns_answer_unref(t->answer);
- t->answer = validated;
- validated = NULL;
+ t->answer = TAKE_PTR(validated);
/* At this point the answer only contains validated
* RRsets. Now, let's see if it actually answers the question
rr->ds.algorithm = a;
rr->ds.digest_type = dt;
rr->ds.digest_size = l;
- rr->ds.digest = dd;
- dd = NULL;
+ rr->ds.digest = TAKE_PTR(dd);
} else if (strcaseeq(type, "DNSKEY")) {
_cleanup_free_ char *flags = NULL, *protocol = NULL, *algorithm = NULL, *key = NULL;
rr->dnskey.protocol = 3;
rr->dnskey.algorithm = a;
rr->dnskey.key_size = l;
- rr->dnskey.key = k;
- k = NULL;
+ rr->dnskey.key = TAKE_PTR(k);
} else {
log_warning("RR type %s is not supported, ignoring line %s:%u.", type, path, line);
if (!ret_tentative && tentative)
goto return_empty;
- *ret_answer = answer;
- answer = NULL;
+ *ret_answer = TAKE_PTR(answer);
- if (ret_soa) {
- *ret_soa = soa;
- soa = NULL;
- }
+ if (ret_soa)
+ *ret_soa = TAKE_PTR(soa);
if (ret_tentative)
*ret_tentative = tentative;
manager_cleanup_saved_user(m);
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 0;
}
p->ifindex = manager_find_ifindex(m, p->family, &p->destination);
}
- *ret = p;
- p = NULL;
+ *ret = TAKE_PTR(p);
return 1;
}
assert(n == size);
qsort_safe(list, size, sizeof(DnsResourceRecord*), mdns_rr_compare);
- *ret_rrs = list;
- list = NULL;
+ *ret_rrs = TAKE_PTR(list);
return size;
}
if (!item)
return -ENOMEM;
- item->file = state_file;
+ item->file = TAKE_PTR(state_file);
item->rfkill_idx = event->idx;
item->state = event->soft;
- state_file = NULL;
LIST_APPEND(queue, *write_queue, item);
r = acl_get_entry(acl, ACL_NEXT_ENTRY, &entry);
}
- if (ret_groups) {
- *ret_groups = g;
- g = NULL;
- }
+ if (ret_groups)
+ *ret_groups = TAKE_PTR(g);
return ret;
}
}
}
- *acl_access = a_acl;
- *acl_default = d_acl;
- a_acl = d_acl = NULL;
+ *acl_access = TAKE_PTR(a_acl);
+ *acl_default = TAKE_PTR(d_acl);
return 0;
}
if (r < 0)
return -errno;
- *acl = old;
- old = NULL;
+ *acl = TAKE_PTR(old);
+
return 0;
}
if (r < 0)
return r;
- *ret = d;
- d = NULL;
+ *ret = TAKE_PTR(d);
return 0;
}
if (r < 0)
return r;
- *_bus = bus;
- bus = NULL;
+ *_bus = TAKE_PTR(bus);
return 0;
}
if (r < 0)
return r;
- *_bus = bus;
- bus = NULL;
+ *_bus = TAKE_PTR(bus);
return 0;
}
if (r < 0)
return r;
- *ret = bus;
- bus = NULL;
+ *ret = TAKE_PTR(bus);
return 0;
}
if (r < 0)
return r;
- *ret = bus;
- bus = NULL;
+ *ret = TAKE_PTR(bus);
return 0;
}
return log_oom();
*ret = t;
- } else {
- *ret = root;
- root = NULL;
- }
+ } else
+ *ret = TAKE_PTR(root);
return 0;
}
}
strv_free_free(*ret);
- *ret = controllers;
- controllers = NULL;
+ *ret = TAKE_PTR(controllers);
return 0;
}
.rw = true,
.partno = -1,
.architecture = _ARCHITECTURE_INVALID,
- .fstype = t,
- .node = n,
+ .fstype = TAKE_PTR(t),
+ .node = TAKE_PTR(n),
};
- t = n = NULL;
-
m->encrypted = streq(fstype, "crypto_LUKS");
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 0;
}
.partno = nr,
.rw = rw,
.architecture = architecture,
- .node = n,
- .fstype = t,
+ .node = TAKE_PTR(n),
+ .fstype = TAKE_PTR(t),
.uuid = id,
};
-
- n = t = NULL;
}
} else if (is_mbr) {
.rw = generic_rw,
.partno = generic_nr,
.architecture = _ARCHITECTURE_INVALID,
- .node = generic_node,
+ .node = TAKE_PTR(generic_node),
.uuid = generic_uuid,
};
-
- generic_node = NULL;
}
}
p->rw = false;
}
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 0;
#else
if (!node)
return -ENOMEM;
- *ret_name = name;
- *ret_node = node;
+ *ret_name = TAKE_PTR(name);
+ *ret_node = TAKE_PTR(node);
- name = node = NULL;
return 0;
}
return r == -EPERM ? -EKEYREJECTED : r;
}
- d->decrypted[d->n_decrypted].name = name;
- name = NULL;
-
- d->decrypted[d->n_decrypted].device = cd;
- cd = NULL;
+ d->decrypted[d->n_decrypted].name = TAKE_PTR(name);
+ d->decrypted[d->n_decrypted].device = TAKE_PTR(cd);
d->n_decrypted++;
- m->decrypted_node = node;
- node = NULL;
+ m->decrypted_node = TAKE_PTR(node);
return 0;
}
if (r < 0)
return r;
- d->decrypted[d->n_decrypted].name = name;
- name = NULL;
-
- d->decrypted[d->n_decrypted].device = cd;
- cd = NULL;
+ d->decrypted[d->n_decrypted].name = TAKE_PTR(name);
+ d->decrypted[d->n_decrypted].device = TAKE_PTR(cd);
d->n_decrypted++;
- m->decrypted_node = node;
- node = NULL;
+ m->decrypted_node = TAKE_PTR(node);
return 0;
}
}
}
- *ret = d;
- d = NULL;
+ *ret = TAKE_PTR(d);
return 1;
#else
if (l < sizeof(sd_id128_t))
return -EINVAL;
- *ret = k;
+ *ret = TAKE_PTR(k);
*ret_size = l;
- k = NULL;
-
return 1;
}
if (a)
p = a;
- else if (b) {
- p = b;
- b = NULL;
- } else
+ else if (b)
+ p = TAKE_PTR(b);
+ else
goto finish;
for (;;) {
if (b) {
/* Now continue with the second string, if there is one */
- p = b;
- b = NULL;
+ p = TAKE_PTR(b);
continue;
}
}
ret[n] = 0;
- *_ret = ret;
- ret = NULL;
+ *_ret = TAKE_PTR(ret);
}
return 0;
/* Not the same, let's jump back, and try with the next label again */
s = old_suffix;
- n = saved_after;
- saved_after = saved_before = NULL;
+ n = TAKE_PTR(saved_after);
+ saved_before = NULL;
}
}
if (r < 0)
return r;
- if (_domain) {
- *_domain = domain;
- domain = NULL;
- }
+ if (_domain)
+ *_domain = TAKE_PTR(domain);
- if (_type) {
- *_type = type;
- type = NULL;
- }
+ if (_type)
+ *_type = TAKE_PTR(type);
- if (_name) {
- *_name = name;
- name = NULL;
- }
+ if (_name)
+ *_name = TAKE_PTR(name);
return 0;
}
}
}
- *ret = t;
- t = NULL;
+ *ret = TAKE_PTR(t);
+
return 1; /* *ret has been written */
}
return -ENOMEM;
buf[n] = 0;
- *ret = buf;
- buf = NULL;
+ *ret = TAKE_PTR(buf);
return 1;
#else
}
}
- if (title) {
- *title = s;
- s = NULL;
- }
+ if (title)
+ *title = TAKE_PTR(s);
if (part_uuid)
*part_uuid = p_uuid;
- if (path) {
- *path = p;
- p = NULL;
- }
+ if (path)
+ *path = TAKE_PTR(p);
if (active)
*active = !!(header->attr & LOAD_OPTION_ACTIVE);
qsort_safe(list, count, sizeof(uint16_t), cmp_uint16);
- *options = list;
- list = NULL;
+ *options = TAKE_PTR(list);
+
return count;
}
if (!GREEDY_REALLOC0(todo, n_allocated, n_todo + 2))
return -ENOMEM;
- todo[n_todo++] = dropin;
- dropin = NULL;
+ todo[n_todo++] = TAKE_PTR(dropin);
}
}
}
if (!GREEDY_REALLOC0(todo, n_allocated, n_todo + 2))
return -ENOMEM;
- todo[n_todo++] = path;
- path = NULL;
+ todo[n_todo++] = TAKE_PTR(path);
}
}
}
return -ENOMEM;
*d = (LoopDevice) {
- .fd = loop,
- .node = loopdev,
+ .fd = TAKE_FD(loop),
+ .node = TAKE_PTR(loopdev),
.nr = nr,
};
- loop = -1;
- loopdev = NULL;
-
*ret = d;
return (*ret)->fd;
path_kill_slashes(i->path);
- *ret = i;
- i = NULL;
+ *ret = TAKE_PTR(i);
return 0;
}
if (!z)
return -ENOMEM;
- *generator = x;
- *generator_early = y;
- *generator_late = z;
+ *generator = TAKE_PTR(x);
+ *generator_early = TAKE_PTR(y);
+ *generator_late = TAKE_PTR(z);
- x = y = z = NULL;
return 0;
}
if (!a || !b)
return -ENOMEM;
- *persistent = a;
- *runtime = b;
- a = b = NULL;
+ *persistent = TAKE_PTR(a);
+ *runtime = TAKE_PTR(b);
return 0;
}
r = strv_extend_strv(&paths, add, true);
if (r < 0)
return r;
- } else {
+ } else
/* Small optimization: if paths is NULL (and it usually is), we can simply assign 'add' to it,
* and don't have to copy anything */
- paths = add;
- add = NULL;
- }
+ paths = TAKE_PTR(add);
}
r = patch_root_prefix(&persistent_config, root);
p->search_path = strv_uniq(paths);
paths = NULL;
- p->persistent_config = persistent_config;
- p->runtime_config = runtime_config;
- persistent_config = runtime_config = NULL;
-
- p->generator = generator;
- p->generator_early = generator_early;
- p->generator_late = generator_late;
- generator = generator_early = generator_late = NULL;
+ p->persistent_config = TAKE_PTR(persistent_config);
+ p->runtime_config = TAKE_PTR(runtime_config);
- p->transient = transient;
- transient = NULL;
+ p->generator = TAKE_PTR(generator);
+ p->generator_early = TAKE_PTR(generator_early);
+ p->generator_late = TAKE_PTR(generator_late);
- p->persistent_control = persistent_control;
- p->runtime_control = runtime_control;
- persistent_control = runtime_control = NULL;
+ p->transient = TAKE_PTR(transient);
- p->root_dir = root;
- root = NULL;
+ p->persistent_control = TAKE_PTR(persistent_control);
+ p->runtime_control = TAKE_PTR(runtime_control);
- p->temporary_dir = tempdir;
- tempdir = NULL;
+ p->root_dir = TAKE_PTR(root);
+ p->temporary_dir = TAKE_PTR(tempdir);
return 0;
}
(void) sd_event_source_set_description(f->sigwinch_event_source, "ptyfwd-sigwinch");
- *ret = f;
- f = NULL;
+ *ret = TAKE_PTR(f);
return 0;
}
return -ENOMEM;
}
- *archs = _archs;
- _archs = NULL;
+ *archs = TAKE_PTR(_archs);
return 0;
}
if (r < 0)
return bus_log_parse_error(r);
- *_reply = reply;
- reply = NULL;
+ *_reply = TAKE_PTR(reply);
return c;
}
}
}
- *_machines = machines;
- machines = NULL;
+ *_machines = TAKE_PTR(machines);
} else
*_machines = NULL;
- *_unit_infos = unit_infos;
- unit_infos = NULL;
+ *_unit_infos = TAKE_PTR(unit_infos);
- *_replies = replies;
- replies = NULL;
+ *_replies = TAKE_PTR(replies);
return c;
}
.id = u->id,
.next_elapse = m,
.last_trigger = last,
- .triggered = triggered,
+ .triggered = TAKE_PTR(triggered),
};
-
- triggered = NULL; /* avoid cleanup */
}
qsort_safe(timer_infos, c, sizeof(struct timer_info),
info.dep[i] = strv_free(info.dep[i]);
}
- *deps = ret;
- ret = NULL;
+ *deps = TAKE_PTR(ret);
return 0;
}
r = 0;
if (!isempty(path)) {
- *fragment_path = path;
- path = NULL;
+ *fragment_path = TAKE_PTR(path);
r = 1;
}
if (dropin_paths && !strv_isempty(dropins)) {
- *dropin_paths = dropins;
- dropins = NULL;
+ *dropin_paths = TAKE_PTR(dropins);
r = 1;
}
not_found:
}
}
- *ret = mangled;
- mangled = NULL; /* do not free */
+ *ret = TAKE_PTR(mangled);
return 0;
}
if (r < 0)
return r;
- *tmpfile = passwd;
- *tmpfile_path = passwd_tmp;
- passwd = NULL;
- passwd_tmp = NULL;
+ *tmpfile = TAKE_PTR(passwd);
+ *tmpfile_path = TAKE_PTR(passwd_tmp);
+
return 0;
}
if (r < 0)
return r;
- *tmpfile = shadow;
- *tmpfile_path = shadow_tmp;
- shadow = NULL;
- shadow_tmp = NULL;
+ *tmpfile = TAKE_PTR(shadow);
+ *tmpfile_path = TAKE_PTR(shadow_tmp);
+
return 0;
}
return r;
if (group_changed) {
- *tmpfile = group;
- *tmpfile_path = group_tmp;
- group = NULL;
- group_tmp = NULL;
+ *tmpfile = TAKE_PTR(group);
+ *tmpfile_path = TAKE_PTR(group_tmp);
}
return 0;
}
return r;
if (group_changed) {
- *tmpfile = gshadow;
- *tmpfile_path = gshadow_tmp;
- gshadow = NULL;
- gshadow_tmp = NULL;
+ *tmpfile = TAKE_PTR(gshadow);
+ *tmpfile_path = TAKE_PTR(gshadow_tmp);
}
return 0;
#else
if (resolved_id) {
if (path_is_absolute(resolved_id)) {
- i->uid_path = resolved_id;
- resolved_id = NULL;
+ i->uid_path = TAKE_PTR(resolved_id);
path_kill_slashes(i->uid_path);
} else {
}
}
- i->description = description;
- description = NULL;
-
- i->home = home;
- home = NULL;
-
- i->shell = resolved_shell;
- resolved_shell = NULL;
+ i->description = TAKE_PTR(description);
+ i->home = TAKE_PTR(home);
+ i->shell = TAKE_PTR(resolved_shell);
h = users;
break;
if (resolved_id) {
if (path_is_absolute(resolved_id)) {
- i->gid_path = resolved_id;
- resolved_id = NULL;
+ i->gid_path = TAKE_PTR(resolved_id);
path_kill_slashes(i->gid_path);
} else {
}
i->type = action[0];
- i->name = resolved_name;
- resolved_name = NULL;
+ i->name = TAKE_PTR(resolved_name);
existing = ordered_hashmap_get(h, i->name);
if (existing) {
return log_oom();
service->sysv_start_priority = -1;
- service->name = name;
- service->path = fpath;
- name = fpath = NULL;
+ service->name = TAKE_PTR(name);
+ service->path = TAKE_PTR(fpath);
r = hashmap_put(all_services, service->name, service);
if (r < 0)
if (r < 0)
return log_error_errno(r, "Failed to attach bus to event loop: %m");
- *_bus = bus;
- bus = NULL;
+ *_bus = TAKE_PTR(bus);
return 0;
}
.msg_namelen = sizeof(server_addr),
};
struct cmsghdr *cmsg;
- struct timespec *recv_time;
+ struct timespec *recv_time = NULL;
ssize_t len;
double origin, receive, trans, dest;
double delay, offset;
return 0;
}
- recv_time = NULL;
CMSG_FOREACH(cmsg, &msghdr) {
if (cmsg->cmsg_level != SOL_SOCKET)
continue;
manager_network_read_link_servers(m);
- *ret = m;
- m = NULL;
+ *ret = TAKE_PTR(m);
return 0;
}
ctx->enable_name_policy = true;
- *ret = ctx;
- ctx = NULL;
+ *ret = TAKE_PTR(ctx);
return 0;
}
sigset_t mask;
/* take initial device from queue */
- dev = event->dev;
- event->dev = NULL;
+ dev = TAKE_PTR(event->dev);
unsetenv("NOTIFY_SOCKET");
if (r < 0)
return log_error_errno(r, "error creating post event source: %m");
- *ret = manager;
- manager = NULL;
+ *ret = TAKE_PTR(manager);
return 0;
}
projects / thirdparty / systemd.git / commitdiff
