--- /dev/null
+@@
+local idexpression p;
+expression q;
+@@
+- p = q;
+- q = NULL;
+- return p;
++ return TAKE_PTR(q);
+@@
+expression p, q;
+@@
+- p = q;
+- q = NULL;
++ p = TAKE_PTR(q);
_new_ = alloca_align(_size_, (align)); \
(void*)memset(_new_, 0, _size_); \
})
+
+/* Takes inspiration from Rusts's Option::take() method: reads and returns a pointer, but at the same time resets it to
+ * NULL. See: https://doc.rust-lang.org/std/option/enum.Option.html#method.take */
+#define TAKE_PTR(ptr) \
+ ({ \
+ typeof(ptr) _ptr_ = (ptr); \
+ (ptr) = NULL; \
+ _ptr_; \
+ })
str[n > 0 ? n - 1 : 0] = '\0'; /* truncate the last space, if it's there */
- *s = str;
- str = NULL;
+ *s = TAKE_PTR(str);
return 0;
}
if (r < 0)
return r;
- if (c == raw) {
- *cgroup = raw;
- raw = NULL;
- } else {
+ if (c == raw)
+ *cgroup = TAKE_PTR(raw);
+ else {
char *n;
n = strdup(c);
if (!strextend(&s, e, NULL))
return -ENOMEM;
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return 0;
}
assert(s);
s[n] = 0;
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return 0;
}
finish_force_next:
s[sz] = 0;
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return 1;
}
}
buf[l] = 0;
- *contents = buf;
- buf = NULL; /* do not free */
+ *contents = TAKE_PTR(buf);
if (size)
*size = l;
if (fd < 0)
return -errno;
- *ret_path = tmp;
- tmp = NULL;
+ *ret_path = TAKE_PTR(tmp);
return fd;
}
return -ENOMEM;
}
- *ret = x;
- x = NULL;
+ *ret = TAKE_PTR(x);
return 0;
}
n++;
}
- if (list) {
- *list = l;
- l = NULL; /* avoid freeing */
- }
+ if (list)
+ *list = TAKE_PTR(l);
return n;
}
}
/* If this is not a symlink, then let's just add the name we read to what we already verified. */
- if (!done) {
- done = first;
- first = NULL;
- } else {
+ if (!done)
+ done = TAKE_PTR(first);
+ else {
/* If done is "/", as first also contains slash at the head, then remove this redundant slash. */
if (streq(done, "/"))
*done = '\0';
return -ENOMEM;
}
- if (ret) {
- *ret = done;
- done = NULL;
- }
+ if (ret)
+ *ret = TAKE_PTR(done);
if (flags & CHASE_OPEN) {
int q;
strv_sort(l);
- *ret = l;
- l = NULL;
+ *ret = TAKE_PTR(l);
return 0;
}
if (name_to_handle_at(fd, path, h, &mnt_id, flags) >= 0) {
- if (ret_handle) {
- *ret_handle = h;
- h = NULL;
- }
+ if (ret_handle)
+ *ret_handle = TAKE_PTR(h);
if (ret_mnt_id)
*ret_mnt_id = mnt_id;
}
*ret_mount_flags = mount_flags;
- *ret_remaining_options = ret;
- ret = NULL;
+ *ret_remaining_options = TAKE_PTR(ret);
return 0;
}
return -EINVAL;
*error = e;
- *name = n;
- n = NULL;
+ *name = TAKE_PTR(n);
return 0;
}
r = chase_symlinks(t, root, 0, &u);
if (r == -ENOENT) {
if (root) {
- u = orig;
- orig = NULL;
+ u = TAKE_PTR(orig);
free(t);
} else
u = t;
}
}
- if (value) {
- *value = ret;
- ret = NULL;
- }
+ if (value)
+ *value = TAKE_PTR(ret);
return found;
}
} else
outcome[sz] = '\0';
- *env = outcome;
- outcome = NULL;
+ *env = TAKE_PTR(outcome);
return 0;
}
if (len != 0)
str[len - 1] = '\0';
- *s = str;
- str = NULL;
+ *s = TAKE_PTR(str);
return 0;
}
if (isempty(s))
return -EOPNOTSUPP;
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return 0;
}
if (!GREEDY_REALLOC(l, allocated, n + 2))
return -ENOMEM;
- l[n++] = word;
- word = NULL;
+ l[n++] = TAKE_PTR(word);
l[n] = NULL;
}
return -ENOMEM;
}
- *t = l;
- l = NULL;
+ *t = TAKE_PTR(l);
return (int) n;
}
tty = active;
}
- if (tty == active) {
- *ret = active;
- active = NULL;
- } else {
+ if (tty == active)
+ *ret = TAKE_PTR(active);
+ else {
char *tmp;
tmp = strdup(tty);
goto fallback;
}
- *ret = l;
- l = NULL;
+ *ret = TAKE_PTR(l);
return 0;
if (r < 0)
return r;
- *ret = l;
- l = NULL;
+ *ret = TAKE_PTR(l);
return 0;
}
*t = 0;
- *ret = r;
- r = NULL;
+ *ret = TAKE_PTR(r);
return 0;
}
free(node_path);
- if (name[0] == '/') {
- node_path = name;
- name = NULL;
- } else {
+ if (name[0] == '/')
+ node_path = TAKE_PTR(name);
+ else {
if (endswith(prefix, "/"))
node_path = strappend(prefix, name);
unit_release_cgroup(u);
- u->cgroup_path = p;
- p = NULL;
+ u->cgroup_path = TAKE_PTR(p);
return 1;
}
if (r < 0)
return -ENOMEM;
}
- } else {
- s = name;
- name = NULL;
- }
+ } else
+ s = TAKE_PTR(name);
r = strv_consume(&l, s);
if (r < 0)
return -ENOMEM;
}
- c->argv = argv;
- argv = NULL;
+ c->argv = TAKE_PTR(argv);
c->flags = b ? EXEC_COMMAND_IGNORE_FAILURE : 0;
assert(j);
- deserialized_clients = j->deserialized_clients;
- j->deserialized_clients = NULL;
+ deserialized_clients = TAKE_PTR(j->deserialized_clients);
if (strv_isempty(deserialized_clients))
return 0;
assert(hashmap_size(m->jobs) == k);
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return k;
}
k++;
}
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return k;
}
if (check_uid != uid) /* lock file doesn't match our own idea */
return -ESRCH;
- *ret = user;
- user = NULL;
+ *ret = TAKE_PTR(user);
return 0;
}
our_env[n_env++] = NULL;
assert(n_env <= 12);
- *ret = our_env;
- our_env = NULL;
+ *ret = TAKE_PTR(our_env);
return 0;
}
x = NULL;
}
- *ret = pass_env;
- pass_env = NULL;
+ *ret = TAKE_PTR(pass_env);
return 0;
}
*ret_bind_mounts = bind_mounts;
*ret_n_bind_mounts = n;
- *ret_empty_directories = empty_directories;
-
- empty_directories = NULL;
+ *ret_empty_directories = TAKE_PTR(empty_directories);
return (int) n;
}
}
- *ret = list;
- list = NULL;
+ *ret = TAKE_PTR(list);
return 0;
}
}
if (!c->cpuset) {
- c->cpuset = cpuset;
- cpuset = NULL;
+ c->cpuset = TAKE_PTR(cpuset);
c->cpuset_ncpus = (unsigned) ncpus;
return 0;
}
if (c->cpuset_ncpus < (unsigned) ncpus) {
CPU_OR_S(CPU_ALLOC_SIZE(c->cpuset_ncpus), cpuset, c->cpuset, cpuset);
CPU_FREE(c->cpuset);
- c->cpuset = cpuset;
- cpuset = NULL;
+ c->cpuset = TAKE_PTR(cpuset);
c->cpuset_ncpus = (unsigned) ncpus;
return 0;
}
return -ENOEXEC;
}
- n = k;
- k = NULL;
+ n = TAKE_PTR(k);
}
free(*user);
"Failed to resolve specifiers, ignoring: %s", word);
continue;
}
- } else {
- k = word;
- word = NULL;
- }
+ } else
+ k = TAKE_PTR(word);
if (!env_assignment_is_valid(k)) {
log_syntax(unit, LOG_ERR, filename, line, 0,
"Failed to resolve specifiers, ignoring: %s", word);
continue;
}
- } else {
- k = word;
- word = NULL;
- }
+ } else
+ k = TAKE_PTR(word);
if (!env_name_is_valid(k)) {
log_syntax(unit, LOG_ERR, filename, line, 0,
"Failed to resolve specifiers, ignoring: %s", word);
continue;
}
- } else {
- k = word;
- word = NULL;
- }
+ } else
+ k = TAKE_PTR(word);
if (!env_assignment_is_valid(k) && !env_name_is_valid(k)) {
log_syntax(unit, LOG_ERR, filename, line, 0,
if (!a)
return log_oom();
- a->path = path;
- path = NULL;
+ a->path = TAKE_PTR(path);
a->r = !!strchr(m, 'r');
a->w = !!strchr(m, 'w');
a->m = !!strchr(m, 'm');
if (!w)
return log_oom();
- w->path = path;
- path = NULL;
+ w->path = TAKE_PTR(path);
w->weight = u;
if (!l)
return log_oom();
- l->path = path;
- path = NULL;
+ l->path = TAKE_PTR(path);
for (ttype = 0; ttype < _CGROUP_IO_LIMIT_TYPE_MAX; ttype++)
l->limits[ttype] = cgroup_io_limit_defaults[ttype];
if (!w)
return log_oom();
- w->path = path;
- path = NULL;
+ w->path = TAKE_PTR(path);
w->weight = u;
if (!b)
return log_oom();
- b->path = path;
- path = NULL;
+ b->path = TAKE_PTR(path);
b->rbps = CGROUP_LIMIT_MAX;
b->wbps = CGROUP_LIMIT_MAX;
options = strv_join(*k, ",");
if (!options)
return log_oom();
- } else {
- options = controller;
- controller = NULL;
- }
+ } else
+ options = TAKE_PTR(controller);
where = strappend("/sys/fs/cgroup/", options);
if (!where)
state = STATE_EXEC_COMMAND_PATH;
break;
case STATE_EXEC_COMMAND_PATH:
- path = arg;
- arg = NULL;
+ path = TAKE_PTR(arg);
state = STATE_EXEC_COMMAND_ARGS;
if (!path_is_absolute(path))
if (*s)
return set_move(*s, *other);
- else {
- *s = *other;
- *other = NULL;
- }
+ else
+ *s = TAKE_PTR(*other);
return 0;
}
if (*s)
return hashmap_move(*s, *other);
- else {
- *s = *other;
- *other = NULL;
- }
+ else
+ *s = TAKE_PTR(*other);
return 0;
}
return r;
if (valid_user_group_name(n)) {
- *ret = n;
- n = NULL;
+ *ret = TAKE_PTR(n);
return 0;
}
char* unit_concat_strv(char **l, UnitWriteFlags flags) {
_cleanup_free_ char *result = NULL;
size_t n = 0, allocated = 0;
- char **i, *ret;
+ char **i;
/* Takes a list of strings, escapes them, and concatenates them. This may be used to format command lines in a
* way suitable for ExecStart= stanzas */
result[n] = 0;
- ret = result;
- result = NULL;
-
- return ret;
+ return TAKE_PTR(result);
}
int unit_write_setting(Unit *u, UnitWriteFlags flags, const char *name, const char *data) {
if (errno > 0)
return -errno;
- *open_fds = buffer;
- buffer = NULL;
+ *open_fds = TAKE_PTR(buffer);
return 0;
}
return log_error_errno(errno, "File \"%s\" is not readable: %m", filename);
if (path && !endswith(filename, ".xz") && !endswith(filename, ".lz4")) {
- *path = filename;
- filename = NULL;
+ *path = TAKE_PTR(filename);
return 0;
}
c.f = safe_fclose(c.f);
- *ret = buf;
- buf = NULL;
+ *ret = TAKE_PTR(buf);
r = 0;
*p = c;
}
- *ret = passwords;
- passwords = NULL;
+ *ret = TAKE_PTR(passwords);
return 0;
}
if (r < 0)
return r;
- *ret = dirs;
- dirs = NULL;
+ *ret = TAKE_PTR(dirs);
return 0;
}
continue;
}
- arg_root_password = a;
- a = NULL;
+ arg_root_password = TAKE_PTR(a);
break;
}
k++;
}
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return 1;
}
return r;
}
- *etags = l;
- l = NULL;
+ *etags = TAKE_PTR(l);
return 0;
}
if (!c->window)
return;
- w = c->window;
- c->window = NULL;
+ w = TAKE_PTR(c->window);
LIST_REMOVE(by_window, w->contexts, c);
if (!w->contexts && !w->keep_always) {
if (message_type == 0)
return -ENOMSG;
- if (_error_message && IN_SET(message_type, DHCP_NAK, DHCP_DECLINE)) {
- *_error_message = error_message;
- error_message = NULL;
- }
+ if (_error_message && IN_SET(message_type, DHCP_NAK, DHCP_DECLINE))
+ *_error_message = TAKE_PTR(error_message);
return message_type;
}
idx++;
}
- *str_arr = names;
- names = NULL;
+ *str_arr = TAKE_PTR(names);
return idx;
}
free(*s);
- if (*n) {
- *s = n;
- n = NULL;
- } else
+ if (*n)
+ *s = TAKE_PTR(n);
+ else
*s = NULL;
return 0;
size++;
}
- *ret = addresses;
- addresses = NULL;
+ *ret = TAKE_PTR(addresses);
return size;
}
size++;
}
- *ret = addresses;
- addresses = NULL;
+ *ret = TAKE_PTR(addresses);
return size;
}
*ret_size = size;
*ret_allocated = allocated;
- *ret = routes;
- routes = NULL;
+ *ret = TAKE_PTR(routes);
return 0;
}
pos = next_chunk;
}
- *domains = names;
- names = NULL;
+ *domains = TAKE_PTR(names);
return cnt;
}
return NULL;
n->parent = parent;
- n->path = s;
- s = NULL; /* do not free */
+ n->path = TAKE_PTR(s);
r = hashmap_put(bus->nodes, n->path, n);
if (r < 0) {
if (asprintf(&s, DEFAULT_USER_BUS_ADDRESS_FMT, ee) < 0)
return -ENOMEM;
- b->address = s;
- s = NULL;
+ b->address = TAKE_PTR(s);
return 0;
}
return r;
}
- *names = l;
- l = NULL;
+ *names = TAKE_PTR(l);
return n_fds;
}
}
}
- device->id_filename = id;
- id = NULL;
+ device->id_filename = TAKE_PTR(id);
}
*ret = device->id_filename;
if (isempty(s))
return -ENODATA;
- *session = s;
- s = NULL;
+ *session = TAKE_PTR(s);
return 0;
}
if (!p)
return -ENOMEM;
- *_p = p;
- p = NULL;
+ *_p = TAKE_PTR(p);
return 0;
}
if (isempty(s))
return -EIO;
- *state = s;
- s = NULL;
+ *state = TAKE_PTR(s);
return 0;
}
if (isempty(s))
return -ENODATA;
- *value = s;
- s = NULL;
+ *value = TAKE_PTR(s);
return 0;
}
return r;
}
- if (session && s) {
- *session = s;
- s = NULL;
- }
+ if (session && s)
+ *session = TAKE_PTR(s);
return 0;
}
*b = NULL;
}
- if (machines) {
- *machines = l;
- l = NULL;
- }
+ if (machines)
+ *machines = TAKE_PTR(l);
+
return r;
}
if (!c)
return -EIO;
- *class = c;
- c = NULL;
+ *class = TAKE_PTR(c);
return 0;
}
attributes[type].net_byteorder = RTA_FLAGS(rta) & NLA_F_NET_BYTEORDER;
}
- container->attributes = attributes;
- attributes = NULL;
+ container->attributes = TAKE_PTR(attributes);
container->n_attributes = count;
return 0;
if (isempty(s))
return -ENODATA;
- *state = s;
- s = NULL;
+ *state = TAKE_PTR(s);
return 0;
}
strv_uniq(a);
r = strv_length(a);
- *ret = a;
- a = NULL;
+ *ret = TAKE_PTR(a);
return r;
}
if (isempty(s))
return -ENODATA;
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return 0;
}
strv_uniq(a);
r = strv_length(a);
- *ret = a;
- a = NULL;
+ *ret = TAKE_PTR(a);
return r;
}
if (ifis)
ifis[c] = 0; /* Let's add a 0 ifindex to the end, to be nice */
- *ret = ifis;
- ifis = NULL;
+ *ret = TAKE_PTR(ifis);
return c;
}
**/
_public_ struct udev_enumerate *udev_enumerate_new(struct udev *udev) {
_cleanup_free_ struct udev_enumerate *udev_enumerate = NULL;
- struct udev_enumerate *ret;
int r;
assert_return_errno(udev, NULL, EINVAL);
udev_list_init(udev, &udev_enumerate->devices_list, false);
- ret = udev_enumerate;
- udev_enumerate = NULL;
-
- return ret;
+ return TAKE_PTR(udev_enumerate);
}
/**
if (r < 0)
return r;
- *settings = l;
- l = NULL;
+ *settings = TAKE_PTR(l);
return 0;
}
log_debug("Found converted keymap %s at %s",
n, uncompressed ? p : pz);
- *new_keymap = n;
- n = NULL;
+ *new_keymap = TAKE_PTR(n);
return 1;
}
}
if (!s->pending_switch)
return;
- session = s->pending_switch;
- s->pending_switch = NULL;
+ session = TAKE_PTR(s->pending_switch);
seat_set_active(s, session);
}
}
session_release_controller(s, true);
- s->controller = name;
- name = NULL;
+ s->controller = TAKE_PTR(name);
session_save(s);
return 0;
return r;
*dev = makedev(major, minor);
- *session_id = id;
- id = NULL;
+ *session_id = TAKE_PTR(id);
return 0;
}
return r;
}
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return 1;
}
if (!GREEDY_REALLOC(l, bufsize, n + 2))
return log_oom();
- l[n++] = where;
- where = NULL;
+ l[n++] = TAKE_PTR(where);
}
if (!GREEDY_REALLOC(l, bufsize, n + 1))
return log_oom();
l[n] = NULL;
- *list = l;
- l = NULL; /* avoid freeing */
+ *list = TAKE_PTR(l);
return n;
}
if (!l)
return -ENXIO;
- *loop_dev = l;
- l = NULL; /* avoid freeing */
+ *loop_dev = TAKE_PTR(l);
return 0;
}
mac->ether_addr_octet[0] &= 0xfe; /* clear multicast bit */
mac->ether_addr_octet[0] |= 0x02; /* set local assignment bit (IEEE802) */
- *ret = mac;
- mac = NULL;
+ *ret = TAKE_PTR(mac);
return 0;
}
w->resolve_retry_event_source = sd_event_source_unref(w->resolve_retry_event_source);
- w->unresolved_endpoints = w->failed_endpoints;
- w->failed_endpoints = NULL;
+ w->unresolved_endpoints = TAKE_PTR(w->failed_endpoints);
resolve_endpoints(netdev);
}
l[c] = NULL;
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return 1;
}
return r;
}
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return 1;
}
strcpy(cs->filename, filename);
cs->line = line;
- *s = cs;
- cs = NULL;
+ *s = TAKE_PTR(cs);
return 0;
}
if (sd_radv_prefix_new(&prefix->radv_prefix) < 0)
return -ENOMEM;
- *ret = prefix;
- prefix = NULL;
+ *ret = TAKE_PTR(prefix);
return 0;
}
}
if (addresses) {
- *dns = addresses;
- addresses = NULL;
+ *dns = TAKE_PTR(addresses);
*n_dns = n_addresses;
}
if (size <= 0)
return -ENODATA;
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return size;
}
!source_path_is_valid(lower[1]))
return -EINVAL;
- upper = lower[1];
- lower[1] = NULL;
+ upper = TAKE_PTR(lower[1]);
destination = strdup(upper[0] == '+' ? upper+1 : upper); /* take the destination without "+" prefix */
if (!destination)
* the "upper", and all before that the "lower" directories. */
destination = lower[k - 1];
- upper = lower[k - 2];
- lower[k - 2] = NULL;
+ upper = TAKE_PTR(lower[k - 2]);
STRV_FOREACH(i, lower)
if (!source_path_is_valid(*i))
* accept this here, and silently make "--ephemeral --template=" equivalent to "--ephemeral
* --directory=". */
- arg_directory = arg_template;
- arg_template = NULL;
+ arg_directory = TAKE_PTR(arg_template);
}
if (arg_template && !(arg_directory || arg_machine)) {
d->n_ref = 1;
d->manager = m;
d->type = type;
- d->name = normalized;
- normalized = NULL;
+ d->name = TAKE_PTR(normalized);
switch (type) {
if (!i->probe_transaction)
return;
- t = i->probe_transaction;
- i->probe_transaction = NULL;
+ t = TAKE_PTR(i->probe_transaction);
set_remove(t->notify_zone_items, i);
set_remove(t->notify_zone_items_done, i);
}
l[c] = NULL;
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return 1;
}
return -EINVAL;
}
- *ret_name = name;
- name = NULL;
+ *ret_name = TAKE_PTR(name);
return 0;
}
}
i->length = length;
- *ret_item = i;
- i = NULL;
+ *ret_item = TAKE_PTR(i);
return 0;
}
}
i->length = length;
- *ret_item = i;
- i = NULL;
+ *ret_item = TAKE_PTR(i);
return 0;
}
}
set_free_free(l->dnssec_negative_trust_anchors);
- l->dnssec_negative_trust_anchors = ns;
- ns = NULL;
+ l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
(void) link_save_user(l);
}
l[c] = NULL;
- *nodes = l;
- l = NULL;
+ *nodes = TAKE_PTR(l);
return 1;
}
return r;
set_free_free(l->dnssec_negative_trust_anchors);
- l->dnssec_negative_trust_anchors = ns;
- ns = NULL;
+ l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
return 0;
if (r < 0)
goto fail;
- l->dnssec_negative_trust_anchors = ns;
- ns = NULL;
+ l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
}
return 0;
if (r < 0)
return log_error_errno(r, "Failed to determine mDNS hostname: %m");
- *llmnr_hostname = n;
- n = NULL;
-
- *full_hostname = h;
- h = NULL;
+ *llmnr_hostname = TAKE_PTR(n);
+ *full_hostname = TAKE_PTR(h);
return 0;
}
if (!h)
return log_oom();
- *llmnr_hostname = n;
- n = NULL;
-
- *mdns_hostname = m;
- m = NULL;
+ *llmnr_hostname = TAKE_PTR(n);
+ *mdns_hostname = TAKE_PTR(m);
*full_hostname = h;
if (keyname)
(void) add_to_keyring_and_log(keyname, flags, l);
- *ret = l;
- l = NULL;
+ *ret = TAKE_PTR(l);
r = 0;
finish:
return r;
strv_free(*p);
- *p = l;
- l = NULL;
+ *p = TAKE_PTR(l);
return 0;
}
free(last);
}
- last = k;
- k = NULL;
+ last = TAKE_PTR(k);
}
if (r < 0)
if (r < 0)
return r;
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return r;
}
/* Not the same, let's jump back, and try with the next label again */
s = suffix;
- n = saved_n;
- saved_n = NULL;
+ n = TAKE_PTR(saved_n);
}
}
}
((char*) buf)[st.st_size - 4] = 0;
((char*) buf)[st.st_size - 4 + 1] = 0;
- *value = buf;
- buf = NULL;
+ *value = TAKE_PTR(buf);
*size = (size_t) st.st_size - 4;
if (attribute)
l / sizeof(uint16_t) > INT_MAX)
return -EINVAL;
- *order = buf;
- buf = NULL;
+ *order = TAKE_PTR(buf);
return (int) (l / sizeof(uint16_t));
}
#include "sd-daemon.h"
+#include "alloc-util.h"
#include "dirent-util.h"
#include "fd-util.h"
#include "fdset.h"
}
r = 0;
- *_s = s;
- s = NULL;
+ *_s = TAKE_PTR(s);
finish:
/* We won't close the fds here! */
*filtered = f;
}
- if (value) {
- *value = v;
- v = NULL;
- }
+ if (value)
+ *value = TAKE_PTR(v);
return !!n;
}
return r;
}
- *values = res;
- res = NULL;
+ *values = TAKE_PTR(res);
return !!*values;
}
break;
}
- *ret = q;
- q = NULL;
+ *ret = TAKE_PTR(q);
return 0;
}
if (!ans)
return -ENOMEM;
*ret = ans;
- } else {
- *ret = prefix;
- prefix = NULL;
- }
+ } else
+ *ret = TAKE_PTR(prefix);
return 0;
}
r = unit_file_load_or_readlink(c, info, path, paths->root_dir, flags);
if (r >= 0) {
- info->path = path;
- path = NULL;
+ info->path = TAKE_PTR(path);
result = r;
found_unit = true;
break;
r = unit_file_load_or_readlink(c, info, path, paths->root_dir, flags);
if (r >= 0) {
- info->path = path;
- path = NULL;
+ info->path = TAKE_PTR(path);
result = r;
found_unit = true;
break;
if (r < 0)
return r;
- path = instance.path;
- instance.path = NULL;
+ path = TAKE_PTR(instance.path);
if (instance.type == UNIT_FILE_TYPE_MASKED) {
unit_file_changes_add(changes, n_changes, -ERFKILL, path, NULL);
static char **image_settings_path(Image *image) {
_cleanup_strv_free_ char **l = NULL;
- char **ret;
const char *fn, *s;
unsigned i = 0;
if (!l[i])
return NULL;
- ret = l;
- l = NULL;
-
- return ret;
+ return TAKE_PTR(l);
}
static char *image_roothash_path(Image *image) {
return -ENOMEM;
}
- *ret = s;
- s = NULL;
+ *ret = TAKE_PTR(s);
return 0;
}
_cleanup_strv_free_ char **config_dirs = NULL, **data_dirs = NULL;
_cleanup_free_ char *data_home = NULL;
_cleanup_strv_free_ char **res = NULL;
- char **tmp;
int r;
r = xdg_user_dirs(&config_dirs, &data_dirs);
if (path_strv_make_absolute_cwd(res) < 0)
return NULL;
- tmp = res;
- res = NULL;
-
- return tmp;
+ return TAKE_PTR(res);
}
bool path_is_user_data_dir(const char *path) {
*runtime = NULL;
}
- *persistent = a;
- a = NULL;
+ *persistent = TAKE_PTR(a);
return 0;
if (!b)
return -ENOMEM;
- *runtime = b;
- b = NULL;
+ *runtime = TAKE_PTR(b);
break;
}
assert_not_reached("Hmm, unexpected scope value.");
}
- *persistent = a;
- a = NULL;
+ *persistent = TAKE_PTR(a);
return 0;
}
*(t++) = '%';
*t = 0;
- *_ret = ret;
- ret = NULL;
+ *_ret = TAKE_PTR(ret);
return 0;
}
return log_oom();
machine_infos[c].is_host = true;
- machine_infos[c].name = hn;
- hn = NULL;
+ machine_infos[c].name = TAKE_PTR(hn);
(void) get_machine_properties(bus, &machine_infos[c]);
c++;
if (r < 0)
return log_error_errno(r, "Failed to access path '%s': %m", path);
- if (unit_path) {
- *unit_path = lpath;
- lpath = NULL;
- }
+ if (unit_path)
+ *unit_path = TAKE_PTR(lpath);
+
return 1;
}
if (r < 0)
return r;
- if (template) {
- *template = _template;
- _template = NULL;
- }
+ if (template)
+ *template = TAKE_PTR(_template);
+
return r;
}
} else if (r < 0)
return log_error_errno(r, "Failed to create temporary file for \"%s\": %m", new_path);
- *ret_tmp_fn = t;
- t = NULL;
+ *ret_tmp_fn = TAKE_PTR(t);
return 0;
}
return -EEXIST;
}
- *ret_path = run;
- run = NULL;
- } else {
- *ret_path = path;
- path = NULL;
- }
+ *ret_path = TAKE_PTR(run);
+ } else
+ *ret_path = TAKE_PTR(path);
return 0;
}
if (!path_strv_resolve_uniq(l, NULL))
return log_oom();
- *ret = l;
- l = NULL;
+ *ret = TAKE_PTR(l);
return 0;
}
if (r < 0)
return r;
- *ret = res;
- res = NULL;
+ *ret = TAKE_PTR(res);
return 0;
}
if (r < 0)
return -errno;
- *gstrings = strings;
- strings = NULL;
+ *gstrings = TAKE_PTR(strings);
return 0;
}
}
free_and_replace(*path, new);
- } else {
- *path = pre;
- pre = NULL;
- }
+ } else
+ *path = TAKE_PTR(pre);
}
/*
if (r < 0)
return r;
- *ret = worker;
- worker = NULL;
+ *ret = TAKE_PTR(worker);
return 0;
}
/* all checks passed, return this one as a source console */
*ret_idx = i;
- *ret_path = path;
- path = NULL;
+ *ret_path = TAKE_PTR(path);
ret_fd = fd;
fd = -1;
return ret_fd;
projects / thirdparty / systemd.git / commitdiff
