_printf_(7, 8)
static int log_helper(void *userdata, int level, int error, const char *file, int line, const char *func, const char *format, ...) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
va_list ap;
int r;
- assert(u);
-
/* "upgrade" debug messages */
level = MIN(LOG_INFO, level);
uint64_t *ret_badness,
char **ret_description) {
- const bool *b = data;
+ const bool *b = ASSERT_PTR(data);
- assert(b);
assert(ret_badness);
assert(ret_description);
sd_bus_error *error,
void *userdata) {
- SecurityInfo *info = userdata;
+ SecurityInfo *info = ASSERT_PTR(userdata);
int r;
uint64_t namespaces;
assert(bus);
assert(member);
assert(m);
- assert(info);
r = sd_bus_message_read(m, "t", &namespaces);
if (r < 0)
sd_bus_error *error,
void *userdata) {
- SecurityInfo *info = userdata;
+ SecurityInfo *info = ASSERT_PTR(userdata);
int r;
uint32_t umask;
assert(bus);
assert(member);
assert(m);
- assert(info);
r = sd_bus_message_read(m, "u", &umask);
if (r < 0)
sd_bus_error *error,
void *userdata) {
- SecurityInfo *info = userdata;
+ SecurityInfo *info = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(member);
assert(m);
- assert(info);
r = sd_bus_message_enter_container(m, 'a', "s");
if (r < 0)
#include "unit-serialize.h"
static void log_syntax_callback(const char *unit, int level, void *userdata) {
- Set **s = userdata;
+ Set **s = ASSERT_PTR(userdata);
int r;
- assert(userdata);
assert(unit);
if (level > LOG_WARNING)
const char *key, char *value,
void *userdata) {
- char ***env = userdata;
+ char ***env = ASSERT_PTR(userdata);
char *expanded_value;
- assert(env);
-
if (!value) {
log_error("%s:%u: invalid syntax (around \"%s\"), ignoring.", strna(filename), line, key);
return 0;
}
int set_put_strsplit(Set *s, const char *v, const char *separators, ExtractFlags flags) {
- const char *p = v;
+ const char *p = ASSERT_PTR(v);
int r;
assert(s);
- assert(v);
for (;;) {
char *word;
}
ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
- uint8_t *p = buf;
+ uint8_t *p = ASSERT_PTR(buf);
ssize_t n = 0;
assert(fd >= 0);
- assert(buf);
/* If called with nbytes == 0, let's call read() at least
* once, to validate the operation */
}
int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
- const uint8_t *p = buf;
+ const uint8_t *p = ASSERT_PTR(buf);
assert(fd >= 0);
- assert(buf);
if (_unlikely_(nbytes > (size_t) SSIZE_MAX))
return -EINVAL;
char *path_simplify(char *path) {
bool add_slash = false;
- char *f = path;
+ char *f = ASSERT_PTR(path);
int r;
- assert(path);
-
/* Removes redundant inner and trailing slashes. Also removes unnecessary dots.
* Modifies the passed string in-place.
*
void siphash24_compress(const void *_in, size_t inlen, struct siphash *state) {
- const uint8_t *in = _in;
+ const uint8_t *in = ASSERT_PTR(_in);
const uint8_t *end = in + inlen;
size_t left = state->inlen & 7;
uint64_t m;
- assert(in);
assert(state);
/* Update total length */
{ "us", 1 },
};
- char *p = buf;
+ char *p = ASSERT_PTR(buf);
bool something = false;
- assert(buf);
assert(l > 0);
if (t == USEC_INFINITY) {
#define DEFINE_STRCPY(type, name) \
type *name(type * restrict dest, const type * restrict src) { \
- assert(dest); \
- type *ret = dest; \
+ type *ret = ASSERT_PTR(dest); \
\
if (!src) { \
*dest = '\0'; \
} state = STATE_NODE;
_cleanup_free_ char *node_path = NULL, *argument_type = NULL, *argument_direction = NULL;
- const char *np = prefix;
+ const char *np = ASSERT_PTR(prefix);
int r;
assert(context);
- assert(prefix);
if (n_depth > NODE_DEPTH_MAX)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "<node> depth too high.");
}
static int on_path(const char *path, void *userdata) {
- Set *paths = userdata;
+ Set *paths = ASSERT_PTR(userdata);
int r;
- assert(paths);
-
r = set_put_strdup(&paths, path);
if (r < 0)
return log_oom();
static int on_interface(const char *interface, uint64_t flags, void *userdata) {
_cleanup_(member_freep) Member *m = NULL;
- Set *members = userdata;
+ Set *members = ASSERT_PTR(userdata);
int r;
assert(interface);
- assert(members);
m = new(Member, 1);
if (!m)
}
static int on_cgroup_empty_event(sd_event_source *s, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Unit *u;
int r;
assert(s);
- assert(m);
u = m->cgroup_empty_queue;
if (!u)
}
static int on_cgroup_oom_event(sd_event_source *s, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Unit *u;
int r;
assert(s);
- assert(m);
u = m->cgroup_oom_queue;
if (!u)
}
static int on_cgroup_inotify_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(s);
assert(fd >= 0);
- assert(m);
for (;;) {
union inotify_event_buffer buffer;
void *userdata) {
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(link);
- assert(m);
if (json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
};
_cleanup_free_ char *found_name = NULL;
uid_t found_uid = UID_INVALID, uid;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *un;
int r;
assert(parameters);
- assert(m);
r = json_dispatch(parameters, dispatch_table, NULL, 0, &p);
if (r < 0)
};
_cleanup_free_ char *found_name = NULL;
uid_t found_gid = GID_INVALID, gid;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *gn;
int r;
assert(parameters);
- assert(m);
r = json_dispatch(parameters, dispatch_table, NULL, 0, &p);
if (r < 0)
}
static void vl_disconnect(VarlinkServer *s, Varlink *link, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(s);
assert(link);
}
static int vl_reply(Varlink *link, JsonVariant *parameters, const char *error_id, VarlinkReplyFlags flags, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
- assert(m);
-
if (error_id)
log_debug("varlink systemd-oomd client error: %s", error_id);
void *userdata,
sd_bus_error *error) {
- CGroupContext *c = userdata;
+ CGroupContext *c = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(c);
if (!c->delegate)
return sd_bus_message_append(reply, "as", 0);
void *userdata,
sd_bus_error *error) {
- CPUSet *cpus = userdata;
+ CPUSet *cpus = ASSERT_PTR(userdata);
_cleanup_free_ uint8_t *array = NULL;
size_t allocated;
assert(bus);
assert(reply);
- assert(cpus);
(void) cpu_set_to_dbus(cpus, &array, &allocated);
return sd_bus_message_append_array(reply, 'y', array, allocated);
void *userdata,
sd_bus_error *error) {
- CGroupContext *c = userdata;
+ CGroupContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'a', "(st)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- CGroupContext *c = userdata;
+ CGroupContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'a', "(st)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- CGroupContext *c = userdata;
+ CGroupContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'a', "(st)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- CGroupContext *c = userdata;
+ CGroupContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'a', "(st)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- CGroupContext *c = userdata;
+ CGroupContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'a', "(st)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- CGroupContext *c = userdata;
+ CGroupContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'a', "(ss)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Set **prefixes = userdata;
+ Set **prefixes = ASSERT_PTR(userdata);
struct in_addr_prefix *i;
int r;
- assert(prefixes);
-
r = sd_bus_message_open_container(reply, 'a', "(iayu)");
if (r < 0)
return r;
void *userdata,
sd_bus_error *error) {
- CGroupSocketBindItem **items = userdata;
+ CGroupSocketBindItem **items = ASSERT_PTR(userdata);
int r;
- assert(items);
-
r = sd_bus_message_open_container(reply, 'a', "(iiqq)");
if (r < 0)
return r;
void *userdata,
sd_bus_error *error) {
int r;
- CGroupContext *c = userdata;
+ CGroupContext *c = ASSERT_PTR(userdata);
char *iface;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'r', "bas");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'a', "(sb)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int r, n;
assert(bus);
assert(reply);
- assert(c);
if (c->oom_score_adjust_set)
n = c->oom_score_adjust;
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
uint64_t n;
int r;
assert(bus);
assert(reply);
- assert(c);
if (c->coredump_filter_set)
n = c->coredump_filter;
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int32_t n;
assert(bus);
assert(reply);
- assert(c);
if (c->nice_set)
n = c->nice;
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int32_t n;
assert(bus);
assert(reply);
- assert(c);
if (c->cpu_sched_set)
n = c->cpu_sched_policy;
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int32_t n;
assert(bus);
assert(reply);
- assert(c);
if (c->cpu_sched_set)
n = c->cpu_sched_priority;
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
_cleanup_(cpu_set_reset) CPUSet s = {};
_cleanup_free_ uint8_t *array = NULL;
size_t allocated;
assert(bus);
assert(reply);
- assert(c);
if (c->cpu_affinity_from_numa) {
int r;
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
_cleanup_free_ uint8_t *array = NULL;
size_t allocated;
assert(bus);
assert(reply);
- assert(c);
(void) cpu_set_to_dbus(&c->numa_policy.nodes, &array, &allocated);
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int32_t policy;
assert(bus);
assert(reply);
- assert(c);
policy = numa_policy_get_type(&c->numa_policy);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
uint64_t u;
assert(bus);
assert(reply);
- assert(c);
if (c->timer_slack_nsec != NSEC_INFINITY)
u = (uint64_t) c->timer_slack_nsec;
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
_cleanup_strv_free_ char **l = NULL;
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'r', "bas");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
_cleanup_strv_free_ char **l = NULL;
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'r', "bas");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
_cleanup_strv_free_ char **l = NULL;
int r;
assert(bus);
assert(reply);
- assert(c);
#if HAVE_SECCOMP
void *id;
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(c);
return sd_bus_message_append(reply, "(bs)", c->selinux_context_ignore, c->selinux_context);
}
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(c);
return sd_bus_message_append(reply, "(bs)", c->apparmor_profile_ignore, c->apparmor_profile);
}
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(c);
return sd_bus_message_append(reply, "(bs)", c->smack_process_label_ignore, c->smack_process_label);
}
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
_cleanup_strv_free_ char **l = NULL;
void *af;
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'r', "bas");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
const char *wd;
assert(bus);
assert(reply);
- assert(c);
if (c->working_directory_home)
wd = "~";
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int fileno;
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
_cleanup_free_ char **l = NULL;
int r;
assert(bus);
assert(reply);
- assert(c);
r = sd_bus_message_open_container(reply, 'r', "bas");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
bool ro;
int r;
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
ExecSetCredential *sc;
int r;
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
ExecLoadCredential *lc;
int r;
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecContext *c = userdata;
+ ExecContext *c = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(c);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecDirectory *d = userdata;
+ ExecDirectory *d = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(d);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- ExecDirectory *d = userdata;
+ ExecDirectory *d = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(d);
assert(property);
assert(reply);
sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Job *j = userdata;
+ Job *j = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(j);
p = unit_dbus_path(j->unit);
if (!p)
}
int bus_job_method_cancel(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Job *j = userdata;
+ Job *j = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(j);
r = mac_selinux_unit_access_check(j->unit, message, "stop", error);
if (r < 0)
};
static int bus_job_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Job *j;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
r = manager_get_job_from_dbus_path(m, path, &j);
if (r < 0)
static int send_new_signal(sd_bus *bus, void *userdata) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_free_ char *p = NULL;
- Job *j = userdata;
+ Job *j = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(j);
p = job_dbus_path(j);
if (!p)
static int send_changed_signal(sd_bus *bus, void *userdata) {
_cleanup_free_ char *p = NULL;
- Job *j = userdata;
+ Job *j = ASSERT_PTR(userdata);
assert(bus);
- assert(j);
p = job_dbus_path(j);
if (!p)
static int send_removed_signal(sd_bus *bus, void *userdata) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_free_ char *p = NULL;
- Job *j = userdata;
+ Job *j = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(j);
p = job_dbus_path(j);
if (!p)
}
static int bus_job_track_handler(sd_bus_track *t, void *userdata) {
- Job *j = userdata;
+ Job *j = ASSERT_PTR(userdata);
assert(t);
- assert(j);
j->bus_track = sd_bus_track_unref(j->bus_track); /* make sure we aren't called again */
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
- KillContext *c = userdata;
+ KillContext *c = ASSERT_PTR(userdata);
int s;
- assert(c);
-
s = restart_kill_signal(c);
return sd_bus_message_append_basic(reply, 'i', &s);
}
sd_bus_error *error) {
_cleanup_free_ char *s = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(m);
s = manager_taint_string(m);
if (!s)
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
double d;
assert(bus);
assert(reply);
- assert(m);
if (MANAGER_IS_FINISHED(m))
d = 1.0;
sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(m);
r = manager_get_effective_environment(m, &l);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(bus);
assert(reply);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(bus);
assert(reply);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(bus);
assert(reply);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(bus);
assert(reply);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(bus);
assert(reply);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(bus);
assert(reply);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
char *governor;
int r;
- assert(m);
-
r = sd_bus_message_read(value, "s", &governor);
if (r < 0)
return r;
void *userdata,
sd_bus_error *error) {
- _unused_ Manager *m = userdata;
+ _unused_ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(bus);
assert(value);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r, n;
- assert(m);
assert(bus);
assert(reply);
}
static int method_get_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
Unit *u;
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
}
static int method_get_unit_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
pid_t pid;
Unit *u;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(pid_t) == sizeof(uint32_t));
static int method_get_unit_by_invocation_id(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *path = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
sd_id128_t id;
const void *a;
Unit *u;
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
}
static int method_load_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
Unit *u;
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
}
static int method_start_unit_replace(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *old_name;
Unit *u;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &old_name);
if (r < 0)
static int method_list_units_by_names(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
_cleanup_strv_free_ char **units = NULL;
assert(message);
- assert(m);
r = sd_bus_message_read_strv(message, &units);
if (r < 0)
static int method_start_transient_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *name, *smode;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
JobMode mode;
Unit *u;
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "start", error);
if (r < 0)
static int method_get_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *path = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint32_t id;
Job *j;
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
}
static int method_cancel_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint32_t id;
Job *j;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "u", &id);
if (r < 0)
}
static int method_clear_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "reload", error);
if (r < 0)
}
static int method_reset_failed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "reload", error);
if (r < 0)
static int list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *k;
Unit *u;
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
static int method_list_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Job *j;
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
}
static int method_subscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
}
static int method_unsubscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
static int dump_impl(sd_bus_message *message, void *userdata, sd_bus_error *error, int (*reply)(sd_bus_message *, char *)) {
_cleanup_free_ char *dump = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
}
static int method_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = verify_run_space("Refusing to reload", error);
if (r < 0)
}
static int method_reexecute(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = verify_run_space("Refusing to reexecute", error);
if (r < 0)
}
static int method_exit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "halt", error);
if (r < 0)
}
static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "reboot", error);
if (r < 0)
}
static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "halt", error);
if (r < 0)
}
static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "halt", error);
if (r < 0)
}
static int method_kexec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "reboot", error);
if (r < 0)
static int method_switch_root(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *ri = NULL, *rt = NULL;
const char *root, *init;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
struct statvfs svfs;
uint64_t available;
int r;
assert(message);
- assert(m);
if (statvfs("/run/systemd", &svfs) < 0)
return sd_bus_error_set_errnof(error, errno, "Failed to statvfs(/run/systemd): %m");
static int method_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_strv_free_ char **plus = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "reload", error);
if (r < 0)
static int method_unset_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_strv_free_ char **minus = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "reload", error);
if (r < 0)
static int method_unset_and_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_strv_free_ char **minus = NULL, **plus = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "reload", error);
if (r < 0)
}
static int method_set_exit_code(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint8_t code;
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "exit", error);
if (r < 0)
}
static int method_lookup_dynamic_user_by_name(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
uid_t uid;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read_basic(message, 's', &name);
if (r < 0)
static int method_lookup_dynamic_user_by_uid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *name = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uid_t uid;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(uid_t) == sizeof(uint32_t));
r = sd_bus_message_read_basic(message, 'u', &uid);
static int method_get_dynamic_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
DynamicUser *d;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(uid_t) == sizeof(uint32_t));
}
static int method_enqueue_marked_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "start", error);
if (r < 0)
static int list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
UnitFileList *item;
Hashmap *h;
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
}
static int method_get_unit_file_state(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
UnitFileState state;
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
static int method_get_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *default_target = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
/* Anyone can call this method */
_cleanup_strv_free_ char **l = NULL;
UnitFileChange *changes = NULL;
size_t n_changes = 0;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
UnitFilePresetMode preset_mode;
int runtime, force, r;
UnitFileFlags flags;
const char *mode;
assert(message);
- assert(m);
r = sd_bus_message_read_strv(message, &l);
if (r < 0)
_cleanup_strv_free_ char **l = NULL;
UnitFileChange *changes = NULL;
size_t n_changes = 0;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = sd_bus_message_read_strv(message, &l);
if (r < 0)
static int method_set_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
UnitFileChange *changes = NULL;
size_t n_changes = 0;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
int force, r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "enable", error);
if (r < 0)
static int method_preset_all_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
UnitFileChange *changes = NULL;
size_t n_changes = 0;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
UnitFilePresetMode preset_mode;
const char *mode;
UnitFileFlags flags;
int force, runtime, r;
assert(message);
- assert(m);
r = mac_selinux_access_check(message, "enable", error);
if (r < 0)
static int method_add_dependency_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
UnitFileChange *changes = NULL;
size_t n_changes = 0;
int runtime, force, r;
UnitFileFlags flags;
assert(message);
- assert(m);
r = bus_verify_manage_unit_files_async(m, message, error);
if (r < 0)
}
static int method_get_job_waiting(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint32_t id;
Job *j;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "u", &id);
if (r < 0)
}
static int method_abandon_scope(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
Unit *u;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
}
static int method_set_show_status(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
ShowStatus mode = _SHOW_STATUS_INVALID;
const char *t;
int r;
- assert(m);
assert(message);
r = mac_selinux_access_check(message, "reload", error);
static int send_finished(sd_bus *bus, void *userdata) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
- usec_t *times = userdata;
+ usec_t *times = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(times);
r = sd_bus_message_new_signal(bus,
&message,
void *userdata,
sd_bus_error *error) {
- Path *p = userdata;
+ Path *p = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(p);
r = sd_bus_message_open_container(reply, 'a', "(ss)");
if (r < 0)
#include "unit.h"
int bus_scope_method_abandon(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Scope *s = userdata;
+ Scope *s = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(s);
r = mac_selinux_unit_access_check(UNIT(s), message, "stop", error);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- const ExitStatusSet *status_set = userdata;
+ const ExitStatusSet *status_set = ASSERT_PTR(userdata);
unsigned n;
int r;
assert(bus);
assert(reply);
- assert(status_set);
r = sd_bus_message_open_container(reply, 'r', "aiai");
if (r < 0)
_cleanup_(mount_options_free_allp) MountOptions *options = NULL;
const char *dest, *src, *propagate_directory;
int read_only, make_file_or_directory;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
ExecContext *c;
pid_t unit_pid;
int r;
assert(message);
- assert(u);
if (!MANAGER_IS_SYSTEM(u->manager))
return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Adding bind mounts at runtime is only supported for system managers.");
void *userdata,
sd_bus_error *error) {
- Timer *t = userdata;
+ Timer *t = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(t);
r = sd_bus_message_open_container(reply, 'a', "(stt)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Timer *t = userdata;
+ Timer *t = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(t);
r = sd_bus_message_open_container(reply, 'a', "(sst)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Timer *t = userdata;
+ Timer *t = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(t);
return sd_bus_message_append(reply, "t",
(uint64_t) usec_shift_clock(t->next_elapse_monotonic_or_boottime,
void *userdata,
sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
const char *t;
int r;
assert(bus);
assert(reply);
- assert(u);
r = sd_bus_message_open_container(reply, 'a', "s");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Hashmap **h = userdata;
+ Hashmap **h = ASSERT_PTR(userdata);
const char *p;
void *v;
int r;
assert(bus);
assert(reply);
- assert(h);
r = sd_bus_message_open_container(reply, 'a', "s");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(u);
r = unit_get_unit_file_preset(u);
sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Job **j = userdata;
+ Job **j = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(j);
if (!*j)
return sd_bus_message_append(reply, "(uo)", 0, "/");
sd_bus_error *error) {
const char *(*to_string)(ConditionType type) = NULL;
- Condition **list = userdata;
+ Condition **list = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(list);
to_string = streq(property, "Asserts") ? assert_type_to_string : condition_type_to_string;
sd_bus_error *error) {
_cleanup_(sd_bus_error_free) sd_bus_error e = SD_BUS_ERROR_NULL;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(u);
r = bus_unit_validate_load_state(u, &e);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- unsigned *markers = userdata;
+ unsigned *markers = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(markers);
r = sd_bus_message_open_container(reply, 'a', "s");
if (r < 0)
int bus_unit_method_enqueue_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
BusUnitQueueFlags flags = BUS_UNIT_QUEUE_VERBOSE_REPLY;
const char *jtype, *smode;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
JobType type;
JobMode mode;
int r;
assert(message);
- assert(u);
r = sd_bus_message_read(message, "ss", &jtype, &smode);
if (r < 0)
}
int bus_unit_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
const char *swho;
int32_t signo;
KillWho who;
int r;
assert(message);
- assert(u);
r = mac_selinux_unit_access_check(u, message, "stop", error);
if (r < 0)
}
int bus_unit_method_reset_failed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(u);
r = mac_selinux_unit_access_check(u, message, "reload", error);
if (r < 0)
}
int bus_unit_method_set_properties(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int runtime, r;
assert(message);
- assert(u);
r = mac_selinux_unit_access_check(u, message, "start", error);
if (r < 0)
}
int bus_unit_method_ref(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(u);
r = mac_selinux_unit_access_check(u, message, "start", error);
if (r < 0)
}
int bus_unit_method_unref(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(u);
r = bus_unit_track_remove_sender(u, message);
if (r == -EUNATCH)
int bus_unit_method_clean(sd_bus_message *message, void *userdata, sd_bus_error *error) {
ExecCleanMask mask = 0;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(u);
r = mac_selinux_unit_access_check(u, message, "stop", error);
if (r < 0)
static int bus_unit_method_freezer_generic(sd_bus_message *message, void *userdata, sd_bus_error *error, FreezerAction action) {
const char* perm;
int (*method)(Unit*);
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
bool reply_no_delay = false;
int r;
assert(message);
- assert(u);
assert(IN_SET(action, FREEZER_FREEZE, FREEZER_THAW));
if (action == FREEZER_FREEZE) {
void *userdata,
sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(u);
return sd_bus_message_append(reply, "s", unit_slice_name(u));
}
sd_bus_error *error) {
uint64_t sz = UINT64_MAX;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(u);
r = unit_get_memory_current(u, &sz);
if (r < 0 && r != -ENODATA)
sd_bus_error *error) {
uint64_t sz = UINT64_MAX;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(u);
r = unit_get_memory_available(u, &sz);
if (r < 0 && r != -ENODATA)
sd_bus_error *error) {
uint64_t cn = UINT64_MAX;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(u);
r = unit_get_tasks_current(u, &cn);
if (r < 0 && r != -ENODATA)
sd_bus_error *error) {
nsec_t ns = NSEC_INFINITY;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(u);
r = unit_get_cpu_usage(u, &ns);
if (r < 0 && r != -ENODATA)
void *userdata,
sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
_cleanup_(cpu_set_reset) CPUSet cpus = {};
_cleanup_free_ uint8_t *array = NULL;
size_t allocated;
assert(bus);
assert(reply);
- assert(u);
(void) unit_get_cpuset(u, &cpus, "cpuset.cpus.effective");
(void) cpu_set_to_dbus(&cpus, &array, &allocated);
void *userdata,
sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
_cleanup_(cpu_set_reset) CPUSet mems = {};
_cleanup_free_ uint8_t *array = NULL;
size_t allocated;
assert(bus);
assert(reply);
- assert(u);
(void) unit_get_cpuset(u, &mems, "cpuset.mems.effective");
(void) cpu_set_to_dbus(&mems, &array, &allocated);
void *userdata,
sd_bus_error *error) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
const char *t = NULL;
assert(bus);
assert(reply);
- assert(u);
/* Three cases: a) u->cgroup_path is NULL, in which case the
* unit has no control group, which we report as the empty
};
uint64_t value = UINT64_MAX;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
ssize_t metric;
assert(bus);
assert(reply);
assert(property);
- assert(u);
assert_se((metric = string_table_lookup(table, ELEMENTSOF(table), property)) >= 0);
(void) unit_get_ip_accounting(u, metric, &value);
};
uint64_t value = UINT64_MAX;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
ssize_t metric;
assert(bus);
assert(reply);
assert(property);
- assert(u);
assert_se((metric = string_table_lookup(table, ELEMENTSOF(table), property)) >= 0);
(void) unit_get_io_accounting(u, metric, false, &value);
static int send_new_signal(sd_bus *bus, void *userdata) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_free_ char *p = NULL;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(u);
p = unit_dbus_path(u);
if (!p)
static int send_changed_signal(sd_bus *bus, void *userdata) {
_cleanup_free_ char *p = NULL;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(u);
p = unit_dbus_path(u);
if (!p)
static int send_removed_signal(sd_bus *bus, void *userdata) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_free_ char *p = NULL;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(bus);
- assert(u);
p = unit_dbus_path(u);
if (!p)
}
static int bus_unit_track_handler(sd_bus_track *t, void *userdata) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
assert(t);
- assert(u);
u->bus_track = sd_bus_track_unref(u->bus_track); /* make sure we aren't called again */
static int signal_agent_released(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *cgroup;
uid_t sender_uid;
int r;
assert(message);
- assert(m);
/* only accept org.freedesktop.systemd1.Agent from UID=0 */
r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
}
static int signal_disconnected(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
sd_bus *bus;
assert(message);
- assert(m);
assert_se(bus = sd_bus_message_get_bus(message));
if (bus == m->api_bus)
static int signal_activation_request(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
Unit *u;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0) {
}
static int bus_unit_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(bus);
assert(path);
assert(interface);
assert(found);
- assert(m);
return find_unit(m, bus, path, (Unit**) found, error);
}
static int bus_unit_interface_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Unit *u;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
r = find_unit(m, bus, path, &u, error);
if (r <= 0)
}
static int bus_unit_cgroup_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Unit *u;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
r = find_unit(m, bus, path, &u, error);
if (r <= 0)
}
static int bus_cgroup_context_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
CGroupContext *c;
Unit *u;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
r = find_unit(m, bus, path, &u, error);
if (r <= 0)
}
static int bus_exec_context_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
ExecContext *c;
Unit *u;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
r = find_unit(m, bus, path, &u, error);
if (r <= 0)
}
static int bus_kill_context_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
KillContext *c;
Unit *u;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
r = find_unit(m, bus, path, &u, error);
if (r <= 0)
static int bus_on_connection(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_(sd_bus_close_unrefp) sd_bus *bus = NULL;
_cleanup_close_ int nfd = -1;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
sd_id128_t id;
int r;
assert(s);
- assert(m);
nfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
if (nfd < 0) {
_cleanup_free_ char *tmp_dir = NULL, *var_tmp_dir = NULL;
char *id = NULL;
int r, netns_fdpair[] = {-1, -1}, ipcns_fdpair[] = {-1, -1};
- const char *p, *v = value;
+ const char *p, *v = ASSERT_PTR(value);
size_t n;
assert(m);
- assert(value);
assert(fds);
n = strcspn(v, " ");
}
static int job_dispatch_timer(sd_event_source *s, uint64_t monotonic, void *userdata) {
- Job *j = userdata;
+ Job *j = ASSERT_PTR(userdata);
Unit *u;
- assert(j);
assert(s == j->timer_event_source);
log_unit_warning(j->unit, "Job %s/%s timed out.", j->unit->id, job_type_to_string(j->type));
void *userdata) {
_cleanup_free_ char *k = NULL;
- const Unit *u = userdata;
+ const Unit *u = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
r = unit_full_printf(u, rvalue, &k);
if (r < 0) {
void *data,
void *userdata) {
- const Unit *u = userdata;
+ const Unit *u = ASSERT_PTR(userdata);
_cleanup_free_ char *k = NULL;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
r = unit_full_printf(u, rvalue, &k);
if (r < 0) {
void *userdata) {
_cleanup_free_ char *k = NULL;
- const Unit *u = userdata;
+ const Unit *u = ASSERT_PTR(userdata);
int r;
bool fatal = ltype;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
r = unit_path_printf(u, rvalue, &k);
if (r < 0) {
const char *rvalue,
void *data,
void *userdata) {
- char ***sv = data;
+ char ***sv = ASSERT_PTR(data);
const Unit *u = userdata;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *userdata) {
char ***x = data;
- const Unit *u = userdata;
+ const Unit *u = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
if (isempty(rvalue)) {
*x = strv_free(*x);
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
int priority, r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->nice_set = false;
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
int oa, r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->oom_score_adjust_set = false;
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->coredump_filter = 0;
void *data,
void *userdata) {
- ExecCommand **e = data;
+ ExecCommand **e = ASSERT_PTR(data);
const Unit *u = userdata;
const char *p;
bool semicolon;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(e);
e += ltype;
void *data,
void *userdata) {
- Socket *s = data;
+ Socket *s = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue) || streq(rvalue, "*")) {
s->bind_to_device = mfree(s->bind_to_device);
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
const char *n;
ExecInput ei;
int r;
- assert(data);
assert(filename);
assert(line);
assert(rvalue);
void *userdata) {
_cleanup_free_ char *unescaped = NULL, *resolved = NULL;
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
int r;
- assert(data);
assert(filename);
assert(line);
assert(rvalue);
void *userdata) {
_cleanup_free_ void *p = NULL;
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
size_t sz;
void *q;
int r;
- assert(data);
assert(filename);
assert(line);
assert(rvalue);
_cleanup_free_ char *resolved = NULL;
const char *n;
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
bool obsolete = false;
ExecOutput eo;
int r;
- assert(data);
assert(filename);
assert(line);
assert(lvalue);
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
int x;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->ioprio_set = false;
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
int i, r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->ioprio_set = false;
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
int x;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->cpu_sched_set = false;
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
int k;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->mount_apivfs_set = false;
void *data,
void *userdata) {
int r;
- NUMAPolicy *p = data;
+ NUMAPolicy *p = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (streq(rvalue, "all")) {
r = numa_mask_add_all(&p->nodes);
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
int i, min, max, r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = safe_atoi(rvalue, &i);
if (r < 0) {
_cleanup_(mount_options_free_allp) MountOptions *options = NULL;
_cleanup_strv_free_ char **l = NULL;
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->root_image_options = mount_options_free_all(c->root_image_options);
void *userdata) {
_cleanup_free_ void *roothash_decoded = NULL;
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
size_t roothash_decoded_size = 0;
int r;
- assert(data);
assert(filename);
assert(line);
assert(rvalue);
_cleanup_free_ void *roothash_sig_decoded = NULL;
char *value;
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
size_t roothash_sig_decoded_size = 0;
int r;
- assert(data);
assert(filename);
assert(line);
assert(rvalue);
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
_cleanup_free_ char *k = NULL;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (streq(rvalue, "numa")) {
c->cpu_affinity_from_numa = true;
void *data,
void *userdata) {
- uint64_t *capability_set = data;
+ uint64_t *capability_set = ASSERT_PTR(data);
uint64_t sum = 0, initial = 0;
bool invert = false;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (rvalue[0] == '~') {
invert = true;
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
bool ignore;
char *k;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->selinux_context = mfree(c->selinux_context);
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
bool ignore;
char *k;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->apparmor_profile = mfree(c->apparmor_profile);
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
bool ignore;
char *k;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
c->smack_process_label = mfree(c->smack_process_label);
_cleanup_(calendar_spec_freep) CalendarSpec *c = NULL;
_cleanup_free_ char *k = NULL;
const Unit *u = userdata;
- Timer *t = data;
+ Timer *t = ASSERT_PTR(data);
usec_t usec = 0;
TimerValue *v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets list */
void *userdata) {
_cleanup_free_ char *p = NULL;
- Unit *u = data;
+ Unit *u = ASSERT_PTR(data);
UnitType type;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (UNIT_TRIGGER(u)) {
log_syntax(unit, LOG_WARNING, filename, line, 0, "Multiple units to trigger specified, ignoring: %s", rvalue);
void *data,
void *userdata) {
- Path *p = data;
+ Path *p = ASSERT_PTR(data);
PathSpec *s;
PathType b;
_cleanup_free_ char *k = NULL;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment clears list */
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *p = NULL;
- Socket *s = data;
+ Socket *s = ASSERT_PTR(data);
Unit *x;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = unit_name_printf(UNIT(s), rvalue, &p);
if (r < 0) {
void *userdata) {
_cleanup_free_ char *p = NULL;
- Socket *s = data;
+ Socket *s = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
s->fdname = mfree(s->fdname);
void *data,
void *userdata) {
- Service *s = data;
+ Service *s = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
for (const char *p = rvalue;;) {
_cleanup_free_ char *word = NULL, *k = NULL;
void *userdata) {
_cleanup_free_ char *k = NULL;
- const Unit *u = userdata;
+ const Unit *u = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
r = unit_full_printf_full(u, rvalue, SD_BUS_MAXIMUM_NAME_LENGTH, &k);
if (r < 0) {
void *data,
void *userdata) {
- Service *s = userdata;
+ Service *s = ASSERT_PTR(userdata);
usec_t usec;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(s);
/* This is called for two cases: TimeoutSec= and TimeoutStartSec=. */
void *data,
void *userdata) {
- usec_t *ret = data;
+ usec_t *ret = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(ret);
/* Note: apart from setting the arg, this returns an extra bit of information in the return value. */
void *data,
void *userdata) {
- Service *s = userdata;
+ Service *s = ASSERT_PTR(userdata);
int r;
- assert(s);
-
r = config_parse_timeout_abort(unit, filename, line, section, section_line, lvalue, ltype, rvalue,
&s->timeout_abort_usec, s);
if (r >= 0)
_cleanup_free_ char *k = NULL;
char **user = data;
- const Unit *u = userdata;
+ const Unit *u = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
if (isempty(rvalue)) {
*user = mfree(*user);
void *userdata) {
char ***users = data;
- const Unit *u = userdata;
+ const Unit *u = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
if (isempty(rvalue)) {
*users = strv_free(*users);
void *data,
void *userdata) {
- ExecContext *c = data;
- const Unit *u = userdata;
+ ExecContext *c = ASSERT_PTR(data);
+ const Unit *u = ASSERT_PTR(userdata);
bool missing_ok;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(c);
- assert(u);
if (isempty(rvalue)) {
c->working_directory_home = false;
void *data,
void *userdata) {
- char ***env = data;
+ char ***env = ASSERT_PTR(data);
const Unit *u = userdata;
_cleanup_free_ char *n = NULL;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment frees the list */
void *userdata) {
const Unit *u = userdata;
- char ***env = data;
+ char ***env = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
_cleanup_strv_free_ char **n = NULL;
const Unit *u = userdata;
- char*** passenv = data;
+ char*** passenv = ASSERT_PTR(data);
size_t nlen = 0;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *userdata) {
_cleanup_strv_free_ char **n = NULL;
- char*** unsetenv = data;
+ char*** unsetenv = ASSERT_PTR(data);
const Unit *u = userdata;
size_t nlen = 0;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(c);
if (isempty(rvalue)) {
exec_context_free_log_extra_fields(c);
void *userdata) {
_cleanup_free_ char *k = NULL;
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(c);
if (isempty(rvalue)) {
c->log_namespace = mfree(c->log_namespace);
void *userdata) {
_cleanup_free_ char *p = NULL;
- Condition **list = data, *c;
+ Condition **list = ASSERT_PTR(data), *c;
ConditionType t = ltype;
bool trigger, negate;
const Unit *u = userdata;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *userdata) {
_cleanup_free_ char *s = NULL;
- Condition **list = data, *c;
+ Condition **list = ASSERT_PTR(data), *c;
ConditionType t = ltype;
bool trigger, negate;
const Unit *u = userdata;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *data,
void *userdata) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
char **a, **b;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *userdata) {
ExecContext *c = data;
- _unused_ const Unit *u = userdata;
+ _unused_ const Unit *u = ASSERT_PTR(userdata);
bool invert = false;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *userdata) {
ExecContext *c = data;
- _unused_ const Unit *u = userdata;
+ _unused_ const Unit *u = ASSERT_PTR(userdata);
bool invert = false;
const char *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
const char *rvalue,
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
bool invert = false;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
_cleanup_free_ char *path = NULL, *resolved = NULL;
CGroupIODeviceWeight *w;
CGroupContext *c = data;
- const char *p = rvalue;
+ const char *p = ASSERT_PTR(rvalue);
uint64_t u;
int r;
assert(filename);
assert(lvalue);
- assert(rvalue);
if (isempty(rvalue)) {
while (c->io_device_weights)
_cleanup_free_ char *path = NULL, *resolved = NULL;
CGroupIODeviceLatency *l;
CGroupContext *c = data;
- const char *p = rvalue;
+ const char *p = ASSERT_PTR(rvalue);
usec_t usec;
int r;
assert(filename);
assert(lvalue);
- assert(rvalue);
if (isempty(rvalue)) {
while (c->io_device_latencies)
CGroupIODeviceLimit *l = NULL;
CGroupContext *c = data;
CGroupIOLimitType type;
- const char *p = rvalue;
+ const char *p = ASSERT_PTR(rvalue);
uint64_t num;
int r;
assert(filename);
assert(lvalue);
- assert(rvalue);
type = cgroup_io_limit_type_from_string(lvalue);
assert(type >= 0);
_cleanup_free_ char *path = NULL, *resolved = NULL;
CGroupBlockIODeviceWeight *w;
CGroupContext *c = data;
- const char *p = rvalue;
+ const char *p = ASSERT_PTR(rvalue);
uint64_t u;
int r;
assert(filename);
assert(lvalue);
- assert(rvalue);
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Unit uses %s=; please use IO*= settings instead. Support for %s= will be removed soon.",
_cleanup_free_ char *path = NULL, *resolved = NULL;
CGroupBlockIODeviceBandwidth *b = NULL;
CGroupContext *c = data;
- const char *p = rvalue;
+ const char *p = ASSERT_PTR(rvalue);
uint64_t bytes;
bool read;
int r;
assert(filename);
assert(lvalue);
- assert(rvalue);
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Unit uses %s=; please use IO*= settings instead. Support for %s= will be removed soon.",
void *data,
void *userdata) {
- ExecDirectory *ed = data;
+ ExecDirectory *ed = ASSERT_PTR(data);
const Unit *u = userdata;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
_cleanup_free_ char *word = NULL, *k = NULL;
_cleanup_free_ void *d = NULL;
- ExecContext *context = data;
+ ExecContext *context = ASSERT_PTR(data);
ExecSetCredential *old;
Unit *u = userdata;
bool encrypted = ltype;
- const char *p = rvalue;
+ const char *p = ASSERT_PTR(rvalue);
size_t size;
int r;
assert(filename);
assert(lvalue);
- assert(rvalue);
- assert(context);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *userdata) {
_cleanup_free_ char *word = NULL, *k = NULL, *q = NULL;
- ExecContext *context = data;
+ ExecContext *context = ASSERT_PTR(data);
ExecLoadCredential *old;
bool encrypted = ltype;
Unit *u = userdata;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(context);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *data,
void *userdata) {
- ExitStatusSet *status_set = data;
+ ExitStatusSet *status_set = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(status_set);
/* Empty assignment resets the list */
if (isempty(rvalue)) {
void *userdata) {
const Unit *u = userdata;
- char*** sv = data;
+ char*** sv = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *userdata) {
const Unit *u = userdata;
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *data,
void *userdata) {
- ExecContext *c = data;
+ ExecContext *c = ASSERT_PTR(data);
const Unit *u = userdata;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *data,
void *userdata) {
- Unit *u = data;
+ Unit *u = ASSERT_PTR(data);
usec_t usec;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
r = parse_sec_fix_0(rvalue, &usec);
if (r < 0) {
void *data,
void *userdata) {
- Unit *u = data;
+ Unit *u = ASSERT_PTR(data);
usec_t usec;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
r = parse_sec_fix_0(rvalue, &usec);
if (r < 0) {
void *userdata) {
Manager *m = NULL;
- EmergencyAction *x = data;
+ EmergencyAction *x = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (unit)
m = ((Unit*) userdata)->manager;
void *userdata) {
_cleanup_free_ char *k = NULL, *n = NULL;
- const Unit *u = userdata;
+ const Unit *u = ASSERT_PTR(userdata);
char **s = data;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(u);
if (isempty(rvalue)) {
/* An empty assignment removes already set value. */
_cleanup_free_ char *resolved = NULL;
const Unit *u = userdata;
- char ***paths = data;
+ char ***paths = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(paths);
if (isempty(rvalue)) {
*paths = strv_free(*paths);
void *userdata) {
_cleanup_free_ char *resolved = NULL, *word = NULL;
CGroupContext *c = data;
- const char *p = rvalue;
+ const char *p = ASSERT_PTR(rvalue);
Unit *u = userdata;
int attach_type, r;
assert(filename);
assert(lvalue);
- assert(rvalue);
if (isempty(rvalue)) {
while (c->bpf_foreign_programs)
const char *rvalue,
void *data,
void *userdata) {
- CGroupContext *c = data;
+ CGroupContext *c = ASSERT_PTR(data);
bool is_allow_rule = true;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *data,
void *userdata) {
- CPUSet *affinity = data;
-
- assert(affinity);
+ CPUSet *affinity = ASSERT_PTR(data);
(void) parse_cpu_set_extend(rvalue, affinity, true, unit, filename, line, lvalue);
void *userdata) {
int k;
- ShowStatus *b = data;
+ ShowStatus *b = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
k = parse_show_status(rvalue, b);
if (k < 0)
void *data,
void *userdata) {
- ExecOutput t, *eo = data;
+ ExecOutput t, *eo = ASSERT_PTR(data);
bool obsolete = false;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (streq(rvalue, "syslog")) {
t = EXEC_OUTPUT_JOURNAL;
void *data,
void *userdata) {
- Swap *s = userdata;
+ Swap *s = ASSERT_PTR(userdata);
int r, priority;
- assert(s);
assert(filename);
assert(lvalue);
assert(rvalue);
static int manager_dispatch_ask_password_fd(sd_event_source *source,
int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
-
- assert(m);
+ Manager *m = ASSERT_PTR(userdata);
(void) flush_fd(fd);
}
static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Job *j;
assert(source);
- assert(m);
while ((j = prioq_peek(m->run_queue))) {
assert(j->installed);
static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
_cleanup_fdset_free_ FDSet *fds = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
char buf[NOTIFY_BUFFER_MAX+1];
struct iovec iovec = {
.iov_base = buf,
bool found = false;
ssize_t n;
- assert(m);
assert(m->notify_fd == fd);
if (revents != EPOLLIN) {
}
static int manager_dispatch_sigchld(sd_event_source *source, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
siginfo_t si = {};
int r;
assert(source);
- assert(m);
/* First we call waitid() for a PID and do not reap the zombie. That way we can still access
* /proc/$PID for it while it is a zombie. */
}
static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
ssize_t n;
struct signalfd_siginfo sfsi;
int r;
- assert(m);
assert(m->signal_fd == fd);
if (revents != EPOLLIN) {
}
static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Unit *u;
- assert(m);
-
log_struct(LOG_DEBUG,
"MESSAGE_ID=" SD_MESSAGE_TIME_CHANGE_STR,
LOG_MESSAGE("Time has been changed"));
const struct inotify_event *e,
void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int changed;
Unit *u;
- assert(m);
-
log_debug("inotify event for /etc/localtime");
changed = manager_read_timezone_stat(m);
}
static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(m->idle_pipe[2] == fd);
/* There's at least one Type=idle child that just gave up on us waiting for the boot process to
}
static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
- assert(m);
assert(source);
manager_print_jobs_in_progress(m);
}
static int mount_on_ratelimit_expire(sd_event_source *s, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Job *j;
- assert(m);
-
/* Let's enqueue all start jobs that were previously skipped because of active ratelimit. */
HASHMAP_FOREACH(j, m->jobs) {
if (j->unit->type != UNIT_MOUNT)
}
static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(revents & EPOLLIN);
return mount_process_proc_self_mountinfo(m);
}
static int on_fd_store_io(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
- ServiceFDStore *fs = userdata;
+ ServiceFDStore *fs = ASSERT_PTR(userdata);
assert(e);
- assert(fs);
/* If we get either EPOLLHUP or EPOLLERR, it's time to remove this entry from the fd store */
log_unit_debug(UNIT(fs->service),
}
static int service_dispatch_inotify_io(sd_event_source *source, int fd, uint32_t events, void *userdata) {
- PathSpec *p = userdata;
+ PathSpec *p = ASSERT_PTR(userdata);
Service *s;
- assert(p);
-
s = SERVICE(p->unit);
assert(s);
static int bus_name_pid_lookup_callback(sd_bus_message *reply, void *userdata, sd_bus_error *ret_error) {
const sd_bus_error *e;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
uint32_t pid;
Service *s;
int r;
assert(reply);
- assert(u);
s = SERVICE(u);
s->bus_name_pid_lookup_slot = sd_bus_slot_unref(s->bus_name_pid_lookup_slot);
}
static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
- SocketPort *p = userdata;
+ SocketPort *p = ASSERT_PTR(userdata);
int cfd = -1;
- assert(p);
assert(fd >= 0);
if (p->socket->state != SOCKET_LISTENING)
}
static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(revents & EPOLLPRI);
return swap_process_proc_swaps(m);
}
static int on_rewatch_pids_event(sd_event_source *s, void *userdata) {
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
assert(s);
- assert(u);
unit_tidy_watch_pids(u);
unit_watch_all_pids(u);
static int signal_name_owner_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *new_owner;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(u);
r = sd_bus_message_read(message, "sss", NULL, NULL, &new_owner);
if (r < 0) {
static int get_name_owner_handler(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const sd_bus_error *e;
const char *new_owner;
- Unit *u = userdata;
+ Unit *u = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(u);
u->get_name_owner_slot = sd_bus_slot_unref(u->get_name_owner_slot);
static int kill_common_log(pid_t pid, int signo, void *userdata) {
_cleanup_free_ char *comm = NULL;
- Unit *u = userdata;
-
- assert(u);
+ Unit *u = ASSERT_PTR(userdata);
(void) get_process_comm(pid, &comm);
log_unit_info(u, "Sending signal SIG%s to process " PID_FMT " (%s) on client request.",
CK_TOKEN_INFO updated_token_info;
int r;
_cleanup_free_ char *token_label = NULL;
- struct luks2_pkcs11_callback_data *data = userdata;
+ struct luks2_pkcs11_callback_data *data = ASSERT_PTR(userdata);
assert(m);
assert(slot_info);
assert(token_info);
assert(uri);
- assert(data);
token_label = pkcs11_token_label(token_info);
if (!token_label)
/* Process LEN bytes of BUFFER, accumulating context into CTX.
It is assumed that LEN % 64 == 0. */
static void sha256_process_block(const void *buffer, size_t len, struct sha256_ctx *ctx) {
- const uint32_t *words = buffer;
+ const uint32_t *words = ASSERT_PTR(buffer);
size_t nwords = len / sizeof(uint32_t);
- assert(buffer);
assert(ctx);
uint32_t a = ctx->H[0];
}
static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- struct iovec *iov = userdata;
+ struct iovec *iov = ASSERT_PTR(userdata);
bool write_eof = false, read_eof = false;
assert(s);
assert(fd >= 0);
- assert(iov);
if ((revents & (EPOLLOUT|EPOLLHUP|EPOLLERR)) && iov->iov_len > 0) {
ssize_t n;
void *data,
void *userdata) {
- char **s = data;
+ char **s = ASSERT_PTR(data);
assert(rvalue);
- assert(s);
if (!isempty(rvalue) && !supported_fstype(rvalue)) {
log_syntax(unit, LOG_WARNING, filename, line, 0, "Unsupported file system, ignoring: %s", rvalue);
void *userdata,
sd_bus_error *error) {
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(h);
return sd_bus_message_append(
reply, "(suusss)",
void *userdata,
sd_bus_error *error) {
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(h);
return sd_bus_message_append(reply, "s", home_state_to_string(home_get_state(h)));
}
sd_bus_error *error) {
_cleanup_free_ char *json = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
bool incomplete;
int r;
assert(bus);
assert(reply);
- assert(h);
r = bus_home_get_record_json(h, sd_bus_get_current_message(bus), &json, &incomplete);
if (r < 0)
sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *secret = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = bus_message_read_secret(message, &secret, error);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = home_deactivate(h, false, error);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = bus_verify_polkit_async(
message,
sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *secret = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = bus_message_read_secret(message, &secret, error);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = bus_verify_polkit_async(
message,
sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *secret = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = bus_message_read_secret(message, &secret, error);
if (r < 0)
sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *secret = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = bus_message_read_secret(message, &secret, error);
if (r < 0)
sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = bus_message_read_home_record(message, USER_RECORD_REQUIRE_REGULAR|USER_RECORD_REQUIRE_SECRET|USER_RECORD_ALLOW_PRIVILEGED|USER_RECORD_ALLOW_PER_MACHINE|USER_RECORD_ALLOW_SIGNATURE|USER_RECORD_PERMISSIVE, &hr, error);
if (r < 0)
sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *secret = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
uint64_t sz;
int r;
assert(message);
- assert(h);
r = sd_bus_message_read(message, "t", &sz);
if (r < 0)
sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *new_secret = NULL, *old_secret = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = bus_message_read_secret(message, &new_secret, error);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = home_lock(h, error);
if (r < 0)
sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *secret = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
r = bus_message_read_secret(message, &secret, error);
if (r < 0)
_cleanup_(operation_unrefp) Operation *o = NULL;
_cleanup_close_ int fd = -1;
int r, please_suspend;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
assert(message);
- assert(h);
r = bus_message_read_secret(message, &secret, error);
if (r < 0)
sd_bus_error *error) {
_cleanup_close_ int fd = -1;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
HomeState state;
int please_suspend, r;
assert(message);
- assert(h);
r = sd_bus_message_read(message, "b", &please_suspend);
if (r < 0)
sd_bus_error *error) {
_cleanup_(operation_unrefp) Operation *o = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(h);
o = operation_new(OPERATION_RELEASE, message);
if (!o)
static int on_deferred_change(sd_event_source *s, void *userdata) {
_cleanup_free_ char *path = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int r;
- assert(h);
-
h->deferred_change_event_source = sd_event_source_disable_unref(h->deferred_change_event_source);
r = bus_home_path(h, &path);
static void home_start_retry_deactivate(Home *h);
static int home_on_retry_deactivate(sd_event_source *s, uint64_t usec, void *userdata) {
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
HomeState state;
assert(s);
- assert(h);
/* 15s after the last attempt to deactivate the home directory passed. Let's try it one more time. */
static int home_on_worker_process(sd_event_source *s, const siginfo_t *si, void *userdata) {
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
int ret;
assert(s);
assert(si);
- assert(h);
assert(h->worker_pid == si->si_pid);
assert(h->worker_event_source);
static int on_home_ref_eof(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_(operation_unrefp) Operation *o = NULL;
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
assert(s);
- assert(h);
if (h->ref_event_source_please_suspend == s)
h->ref_event_source_please_suspend = sd_event_source_disable_unref(h->ref_event_source_please_suspend);
}
static int on_pending(sd_event_source *s, void *userdata) {
- Home *h = userdata;
+ Home *h = ASSERT_PTR(userdata);
Operation *o;
int r;
assert(s);
- assert(h);
o = ordered_set_first(h->pending_operations);
if (o) {
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Home *h;
int r;
assert(bus);
assert(reply);
- assert(m);
r = sd_bus_message_open_container(reply, 'a', "(sso)");
if (r < 0)
_cleanup_free_ char *path = NULL;
const char *user_name;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Home *h;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &user_name);
if (r < 0)
sd_bus_error *error) {
_cleanup_free_ char *path = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint32_t uid;
int r;
Home *h;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "u", &uid);
if (r < 0)
sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Home *h;
int r;
assert(message);
- assert(m);
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
sd_bus_error *error) {
_cleanup_free_ char *json = NULL, *path = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *user_name;
bool incomplete;
Home *h;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &user_name);
if (r < 0)
sd_bus_error *error) {
_cleanup_free_ char *json = NULL, *path = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
bool incomplete;
uint32_t uid;
Home *h;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "u", &uid);
if (r < 0)
sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Home *h;
int r;
assert(message);
- assert(m);
r = bus_message_read_home_record(message, USER_RECORD_LOAD_EMBEDDED|USER_RECORD_PERMISSIVE, &hr, error);
if (r < 0)
sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Home *h;
int r;
assert(message);
- assert(m);
r = bus_message_read_home_record(message, USER_RECORD_REQUIRE_REGULAR|USER_RECORD_ALLOW_SECRET|USER_RECORD_ALLOW_PRIVILEGED|USER_RECORD_ALLOW_PER_MACHINE|USER_RECORD_ALLOW_SIGNATURE, &hr, error);
if (r < 0)
static int method_update_home(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(user_record_unrefp) UserRecord *hr = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Home *h;
int r;
assert(message);
- assert(m);
r = bus_message_read_home_record(message, USER_RECORD_REQUIRE_REGULAR|USER_RECORD_ALLOW_SECRET|USER_RECORD_ALLOW_PRIVILEGED|USER_RECORD_ALLOW_PER_MACHINE|USER_RECORD_ALLOW_SIGNATURE|USER_RECORD_PERMISSIVE, &hr, error);
if (r < 0)
static int method_lock_all_homes(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(operation_unrefp) Operation *o = NULL;
bool waiting = false;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Home *h;
int r;
- assert(m);
-
/* This is called from logind when we are preparing for system suspend. We enqueue a lock operation
* for every suitable home we have and only when all of them completed we send a reply indicating
* completion. */
static int method_deactivate_all_homes(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(operation_unrefp) Operation *o = NULL;
bool waiting = false;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Home *h;
int r;
- assert(m);
-
/* This is called from systemd-homed-activate.service's ExecStop= command to ensure that all home
* directories are shutdown before the system goes down. Note that we don't do this from
* systemd-homed.service itself since we want to allow restarting of it without tearing down all home
}
static int method_rebalance(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
- assert(m);
-
r = manager_schedule_rebalance(m, /* immediately= */ true);
if (r == 0)
return sd_bus_reply_method_errorf(message, BUS_ERROR_REBALANCE_NOT_NEEDED, "No home directories need rebalancing.");
};
static int on_deferred_auto_login(sd_event_source *s, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
- assert(m);
-
m->deferred_auto_login_event_source = sd_event_source_disable_unref(m->deferred_auto_login_event_source);
r = sd_bus_emit_properties_changed(
static int on_home_inotify(sd_event_source *s, const struct inotify_event *event, void *userdata) {
_cleanup_free_ char *j = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *e, *n;
- assert(m);
assert(event);
if ((event->mask & (IN_Q_OVERFLOW|IN_MOVE_SELF|IN_DELETE_SELF|IN_IGNORED|IN_UNMOUNT)) != 0) {
_cleanup_free_ void *datagram = NULL;
_cleanup_close_ int passed_fd = -1;
struct ucred sender = UCRED_INVALID;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
ssize_t n;
Home *h;
assert(s);
- assert(m);
n = read_datagram(fd, &sender, &datagram, &passed_fd);
if (n < 0) {
}
static int manager_on_device(sd_device_monitor *monitor, sd_device *d, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
- assert(m);
assert(d);
if (device_for_action(d, SD_DEVICE_REMOVE)) {
}
static int on_deferred_rescan(sd_event_source *s, void *userdata) {
- Manager *m = userdata;
-
- assert(m);
+ Manager *m = ASSERT_PTR(userdata);
m->deferred_rescan_event_source = sd_event_source_disable_unref(m->deferred_rescan_event_source);
}
static int on_deferred_gc(sd_event_source *s, void *userdata) {
- Manager *m = userdata;
-
- assert(m);
+ Manager *m = ASSERT_PTR(userdata);
m->deferred_gc_event_source = sd_event_source_disable_unref(m->deferred_gc_event_source);
}
static int on_rebalance_timer(sd_event_source *s, usec_t t, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(s);
- assert(m);
assert(IN_SET(m->rebalance_state, REBALANCE_WAITING, REBALANCE_PENDING, REBALANCE_SHRINKING, REBALANCE_GROWING));
(void) manager_rebalance_now(m);
LookupParameters p = {
.uid = UID_INVALID,
};
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
bool trusted;
Home *h;
int r;
assert(parameters);
- assert(m);
r = json_dispatch(parameters, dispatch_table, NULL, 0, &p);
if (r < 0)
LookupParameters p = {
.gid = GID_INVALID,
};
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Home *h;
int r;
assert(parameters);
- assert(m);
r = json_dispatch(parameters, dispatch_table, NULL, 0, &p);
if (r < 0)
{}
};
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
LookupParameters p = {};
Home *h;
int r;
assert(parameters);
- assert(m);
r = json_dispatch(parameters, dispatch_table, NULL, 0, &p);
if (r < 0)
}
static int device_monitor_handler(sd_device_monitor *monitor, sd_device *device, void *userdata) {
- HomeSetup *setup = userdata;
+ HomeSetup *setup = ASSERT_PTR(userdata);
int r;
- assert(setup);
-
if (!device_for_action(device, SD_DEVICE_REMOVE))
return 0;
void *userdata) {
_cleanup_(erase_and_freep) void *decrypted_key = NULL;
- struct pkcs11_callback_data *data = userdata;
+ struct pkcs11_callback_data *data = ASSERT_PTR(userdata);
_cleanup_free_ char *token_label = NULL;
CK_TOKEN_INFO updated_token_info;
size_t decrypted_key_size;
assert(slot_info);
assert(token_info);
assert(uri);
- assert(data);
/* Special return values:
*
void *userdata,
sd_bus_error *error) {
- Context *c = userdata;
- assert(c);
+ Context *c = ASSERT_PTR(userdata);
context_read_etc_hostname(c);
void *userdata,
sd_bus_error *error) {
- Context *c = userdata;
- assert(c);
+ Context *c = ASSERT_PTR(userdata);
context_read_etc_hostname(c);
context_determine_hostname_source(c);
}
static int method_set_hostname(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
const char *name;
int interactive, r;
assert(m);
- assert(c);
r = sd_bus_message_read(m, "sb", &name, &interactive);
if (r < 0)
}
static int method_set_static_hostname(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
const char *name;
int interactive;
int r;
assert(m);
- assert(c);
r = sd_bus_message_read(m, "sb", &name, &interactive);
if (r < 0)
static int method_get_product_uuid(sd_bus_message *m, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
int interactive, r;
sd_id128_t uuid;
assert(m);
- assert(c);
r = sd_bus_message_read(m, "b", &interactive);
if (r < 0)
static int method_get_hardware_serial(sd_bus_message *m, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_free_ char *serial = NULL;
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
int r;
assert(m);
- assert(c);
r = bus_verify_polkit_async(
m,
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
sd_id128_t product_uuid = SD_ID128_NULL;
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
bool privileged;
struct utsname u;
int r;
assert(m);
- assert(c);
r = bus_verify_polkit_async(
m,
}
static int curl_glue_on_io(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- CurlGlue *g = userdata;
+ CurlGlue *g = ASSERT_PTR(userdata);
int action, k = 0;
assert(s);
- assert(g);
if (FLAGS_SET(revents, EPOLLIN | EPOLLOUT))
action = CURL_POLL_INOUT;
static int curl_glue_socket_callback(CURL *curl, curl_socket_t s, int action, void *userdata, void *socketp) {
sd_event_source *io = socketp;
- CurlGlue *g = userdata;
+ CurlGlue *g = ASSERT_PTR(userdata);
uint32_t events = 0;
int r;
assert(curl);
- assert(g);
if (action == CURL_POLL_REMOVE) {
if (io) {
}
static int curl_glue_on_timer(sd_event_source *s, uint64_t usec, void *userdata) {
- CurlGlue *g = userdata;
+ CurlGlue *g = ASSERT_PTR(userdata);
int k = 0;
assert(s);
- assert(g);
if (curl_multi_socket_action(g->curl, CURL_SOCKET_TIMEOUT, 0, &k) != CURLM_OK)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
}
static int curl_glue_timer_callback(CURLM *curl, long timeout_ms, void *userdata) {
- CurlGlue *g = userdata;
+ CurlGlue *g = ASSERT_PTR(userdata);
usec_t usec;
assert(curl);
- assert(g);
if (timeout_ms < 0) {
if (g->timer) {
}
static int progress_path(const char *path, const struct stat *st, void *userdata) {
- ProgressInfo *p = userdata;
+ ProgressInfo *p = ASSERT_PTR(userdata);
int r;
- assert(p);
-
r = free_and_strdup(&p->path, path);
if (r < 0)
return r;
}
static int progress_bytes(uint64_t nbytes, void *userdata) {
- ProgressInfo *p = userdata;
+ ProgressInfo *p = ASSERT_PTR(userdata);
- assert(p);
assert(p->size != UINT64_MAX);
p->size += nbytes;
}
static int raw_import_write(const void *p, size_t sz, void *userdata) {
- RawImport *i = userdata;
+ RawImport *i = ASSERT_PTR(userdata);
bool too_much = false;
int r;
- assert(i);
assert(p);
assert(sz > 0);
}
static int transfer_on_pid(sd_event_source *s, const siginfo_t *si, void *userdata) {
- Transfer *t = userdata;
+ Transfer *t = ASSERT_PTR(userdata);
bool success = false;
assert(s);
- assert(t);
if (si->si_code == CLD_EXITED) {
if (si->si_status != 0)
}
static int transfer_on_log(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Transfer *t = userdata;
+ Transfer *t = ASSERT_PTR(userdata);
ssize_t l;
assert(s);
- assert(t);
l = read(fd, t->log_message + t->log_message_size, sizeof(t->log_message) - t->log_message_size);
if (l < 0)
_cleanup_(transfer_unrefp) Transfer *t = NULL;
int fd, force, read_only, r;
const char *local, *object;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
TransferType type;
struct stat st;
uint32_t id;
assert(msg);
- assert(m);
r = bus_verify_polkit_async(
msg,
_cleanup_(transfer_unrefp) Transfer *t = NULL;
int fd, force, read_only, r;
const char *local, *object;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint32_t id;
assert(msg);
- assert(m);
r = bus_verify_polkit_async(
msg,
_cleanup_(transfer_unrefp) Transfer *t = NULL;
int fd, r;
const char *local, *object, *format;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
TransferType type;
struct stat st;
uint32_t id;
assert(msg);
- assert(m);
r = bus_verify_polkit_async(
msg,
static int method_pull_tar_or_raw(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
_cleanup_(transfer_unrefp) Transfer *t = NULL;
const char *remote, *local, *verify, *object;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
ImportVerify v;
TransferType type;
int force, r;
uint32_t id;
assert(msg);
- assert(m);
r = bus_verify_polkit_async(
msg,
static int method_list_transfers(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Transfer *t;
int r;
assert(msg);
- assert(m);
r = sd_bus_message_new_method_return(msg, &reply);
if (r < 0)
}
static int method_cancel(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
- Transfer *t = userdata;
+ Transfer *t = ASSERT_PTR(userdata);
int r;
assert(msg);
- assert(t);
r = bus_verify_polkit_async(
msg,
}
static int method_cancel_transfer(sd_bus_message *msg, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Transfer *t;
uint32_t id;
int r;
assert(msg);
- assert(m);
r = bus_verify_polkit_async(
msg,
void *userdata,
sd_bus_error *error) {
- Transfer *t = userdata;
+ Transfer *t = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(t);
return sd_bus_message_append(reply, "d", transfer_percent_as_double(t));
}
void **found,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Transfer *t;
const char *p;
uint32_t id;
assert(path);
assert(interface);
assert(found);
- assert(m);
p = startswith(path, "/org/freedesktop/import1/transfer/_");
if (!p)
}
static int pull_job_write_uncompressed(const void *p, size_t sz, void *userdata) {
- PullJob *j = userdata;
+ PullJob *j = ASSERT_PTR(userdata);
bool too_much = false;
int r;
- assert(j);
assert(p);
assert(sz > 0);
}
static size_t pull_job_write_callback(void *contents, size_t size, size_t nmemb, void *userdata) {
- PullJob *j = userdata;
+ PullJob *j = ASSERT_PTR(userdata);
size_t sz = size * nmemb;
int r;
assert(contents);
- assert(j);
switch (j->state) {
static size_t pull_job_header_callback(void *contents, size_t size, size_t nmemb, void *userdata) {
_cleanup_free_ char *length = NULL, *last_modified = NULL, *etag = NULL;
size_t sz = size * nmemb;
- PullJob *j = userdata;
+ PullJob *j = ASSERT_PTR(userdata);
CURLcode code;
long status;
int r;
assert(contents);
- assert(j);
if (IN_SET(j->state, PULL_JOB_DONE, PULL_JOB_FAILED)) {
r = -ESTALE;
}
static int pull_job_progress_callback(void *userdata, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow) {
- PullJob *j = userdata;
+ PullJob *j = ASSERT_PTR(userdata);
unsigned percent;
usec_t n;
- assert(j);
-
if (dltotal <= 0)
return 0;
char *buf,
size_t max) {
- RequestMeta *m = cls;
+ RequestMeta *m = ASSERT_PTR(cls);
int r;
size_t n, k;
- assert(m);
assert(buf);
assert(max > 0);
assert(pos >= m->delta);
const char *key,
const char *value) {
- RequestMeta *m = cls;
+ RequestMeta *m = ASSERT_PTR(cls);
_cleanup_free_ char *p = NULL;
int r;
- assert(m);
-
if (isempty(key)) {
m->argument_parse_error = -EINVAL;
return MHD_NO;
void *connection_cls) {
_cleanup_(MHD_destroy_responsep) struct MHD_Response *response = NULL;
- RequestMeta *m = connection_cls;
+ RequestMeta *m = ASSERT_PTR(connection_cls);
int r;
assert(connection);
- assert(m);
r = open_journal(m);
if (r < 0)
char *buf,
size_t max) {
- RequestMeta *m = cls;
+ RequestMeta *m = ASSERT_PTR(cls);
int r;
size_t n, k;
- assert(m);
assert(buf);
assert(max > 0);
assert(pos >= m->delta);
void *connection_cls) {
_cleanup_(MHD_destroy_responsep) struct MHD_Response *response = NULL;
- RequestMeta *m = connection_cls;
+ RequestMeta *m = ASSERT_PTR(connection_cls);
int r;
assert(connection);
- assert(m);
r = open_journal(m);
if (r < 0)
void *connection_cls) {
_cleanup_(MHD_destroy_responsep) struct MHD_Response *response = NULL;
- RequestMeta *m = connection_cls;
+ RequestMeta *m = ASSERT_PTR(connection_cls);
int r;
_cleanup_free_ char* hostname = NULL, *os_name = NULL;
uint64_t cutoff_from = 0, cutoff_to = 0, usage = 0;
_cleanup_free_ char *v = NULL, *json = NULL;
assert(connection);
- assert(m);
r = open_journal(m);
if (r < 0)
int fd,
uint32_t revents,
void *userdata) {
- MHDDaemonWrapper *d = userdata;
+ MHDDaemonWrapper *d = ASSERT_PTR(userdata);
int r;
MHD_UNSIGNED_LONG_LONG timeout = ULLONG_MAX;
- assert(d);
-
r = MHD_run(d->daemon);
if (r == MHD_NO)
// FIXME: unregister daemon
}
static size_t journal_input_callback(void *buf, size_t size, size_t nmemb, void *userp) {
- Uploader *u = userp;
+ Uploader *u = ASSERT_PTR(userp);
int r;
sd_journal *j;
size_t filled = 0;
ssize_t w;
- assert(u);
assert(nmemb <= SSIZE_MAX / size);
check_update_watchdog(u);
int fd,
uint32_t revents,
void *userp) {
- Uploader *u = userp;
-
- assert(u);
+ Uploader *u = ASSERT_PTR(userp);
if (u->uploading)
return 0;
size_t size,
size_t nmemb,
void *userp) {
- Uploader *u = userp;
-
- assert(u);
+ Uploader *u = ASSERT_PTR(userp);
log_debug("The server answers (%zu bytes): %.*s",
size*nmemb, (int)(size*nmemb), buf);
}
static size_t fd_input_callback(void *buf, size_t size, size_t nmemb, void *userp) {
- Uploader *u = userp;
+ Uploader *u = ASSERT_PTR(userp);
ssize_t n;
- assert(u);
assert(nmemb < SSIZE_MAX / size);
if (u->input < 0)
int fd,
uint32_t revents,
void *userp) {
- Uploader *u = userp;
+ Uploader *u = ASSERT_PTR(userp);
- assert(u);
assert(fd >= 0);
if (revents & EPOLLHUP) {
static int dispatch_sigterm(sd_event_source *event,
const struct signalfd_siginfo *si,
void *userdata) {
- Uploader *u = userdata;
-
- assert(u);
+ Uploader *u = ASSERT_PTR(userdata);
log_received_signal(LOG_INFO, si);
_cleanup_free_ char *n = NULL;
bool fatal = ltype;
- char **s = data;
+ char **s = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue))
goto finalize;
}
static int dispatch_dev_kmsg(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
assert(es);
assert(fd == s->dev_kmsg_fd);
- assert(s);
if (revents & EPOLLERR)
log_warning("/dev/kmsg buffer overrun, some messages lost.");
void *userdata) {
size_t label_len = 0, m;
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
struct ucred *ucred = NULL;
struct timeval *tv = NULL;
struct cmsghdr *cmsg;
.msg_namelen = sizeof(sa),
};
- assert(s);
assert(fd == s->native_fd || fd == s->syslog_fd || fd == s->audit_fd);
if (revents != EPOLLIN)
}
static int dispatch_sigusr1(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
- Server *s = userdata;
-
- assert(s);
+ Server *s = ASSERT_PTR(userdata);
if (s->namespace) {
log_error("Received SIGUSR1 signal from PID %u, but flushing runtime journals not supported for namespaced instances.", si->ssi_pid);
}
static int dispatch_sigusr2(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
- Server *s = userdata;
-
- assert(s);
+ Server *s = ASSERT_PTR(userdata);
log_info("Received SIGUSR2 signal from PID %u, as request to rotate journal, rotating.", si->ssi_pid);
server_full_rotate(s);
static int dispatch_sigterm(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
_cleanup_(sd_event_source_disable_unrefp) sd_event_source *news = NULL;
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
int r;
- assert(s);
-
log_received_signal(LOG_INFO, si);
(void) sd_event_source_set_enabled(es, SD_EVENT_OFF); /* Make sure this handler is called at most once */
}
static int dispatch_sigrtmin1(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
- Server *s = userdata;
-
- assert(s);
+ Server *s = ASSERT_PTR(userdata);
log_debug("Received SIGRTMIN1 signal from PID %u, as request to sync.", si->ssi_pid);
server_full_sync(s);
}
static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
- Server *s = data;
+ Server *s = ASSERT_PTR(data);
int r;
- assert(s);
-
if (proc_cmdline_key_streq(key, "systemd.journald.forward_to_syslog")) {
r = value ? parse_boolean(value) : true;
}
static int server_dispatch_sync(sd_event_source *es, usec_t t, void *userdata) {
- Server *s = userdata;
-
- assert(s);
+ Server *s = ASSERT_PTR(userdata);
server_sync(s);
return 0;
}
static int dispatch_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
- Server *s = userdata;
-
- assert(s);
+ Server *s = ASSERT_PTR(userdata);
server_cache_hostname(s);
return 0;
}
static int dispatch_notify_event(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
int r;
- assert(s);
assert(s->notify_event_source == es);
assert(s->notify_fd == fd);
}
static int dispatch_watchdog(sd_event_source *es, uint64_t usec, void *userdata) {
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
int r;
- assert(s);
-
s->send_watchdog = true;
r = sd_event_source_set_enabled(s->notify_event_source, SD_EVENT_ON);
}
static int synchronize_second_half(sd_event_source *event_source, void *userdata) {
- Varlink *link = userdata;
+ Varlink *link = ASSERT_PTR(userdata);
Server *s;
int r;
- assert(link);
assert_se(s = varlink_get_userdata(link));
/* This is the "second half" of the Synchronize() varlink method. This function is called as deferred
static int vl_method_synchronize(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
_cleanup_(sd_event_source_unrefp) sd_event_source *event_source = NULL;
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
int r;
assert(link);
- assert(s);
if (json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
}
static int vl_method_rotate(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
assert(link);
- assert(s);
if (json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
}
static int vl_method_flush_to_var(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
assert(link);
- assert(s);
if (json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
}
static int vl_method_relinquish_var(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
assert(link);
- assert(s);
if (json_variant_elements(parameters) > 0)
return varlink_error_invalid_parameter(link, parameters);
}
static int vl_connect(VarlinkServer *server, Varlink *link, void *userdata) {
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
assert(server);
assert(link);
- assert(s);
(void) server_start_or_stop_idle_timer(s); /* maybe we are no longer idle */
}
static void vl_disconnect(VarlinkServer *server, Varlink *link, void *userdata) {
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
assert(server);
assert(link);
- assert(s);
(void) server_start_or_stop_idle_timer(s); /* maybe we are idle now */
}
}
static int server_idle_handler(sd_event_source *source, uint64_t usec, void *userdata) {
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
assert(source);
- assert(s);
log_debug("Server is idle, exiting.");
sd_event_exit(s->event, 0);
void *data,
void *userdata) {
- size_t *sz = data;
+ size_t *sz = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue))
/* Empty assignment means default */
static int stdout_stream_process(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct ucred))) control;
size_t limit, consumed, allocated;
- StdoutStream *s = userdata;
+ StdoutStream *s = ASSERT_PTR(userdata);
struct ucred *ucred;
struct iovec iovec;
ssize_t l;
.msg_controllen = sizeof(control),
};
- assert(s);
-
if ((revents|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
log_error("Got invalid event from epoll for stdout stream: %"PRIx32, revents);
goto terminate;
static int stdout_stream_new(sd_event_source *es, int listen_fd, uint32_t revents, void *userdata) {
_cleanup_close_ int fd = -1;
- Server *s = userdata;
+ Server *s = ASSERT_PTR(userdata);
int r;
- assert(s);
-
if (revents != EPOLLIN)
return log_error_errno(SYNTHETIC_ERRNO(EIO),
"Got invalid event from epoll for stdout server fd: %" PRIx32,
uint64_t usec,
void *userdata) {
- sd_dhcp_client *client = userdata;
+ sd_dhcp_client *client = ASSERT_PTR(userdata);
DHCP_CLIENT_DONT_DESTROY(client);
usec_t next_timeout;
uint64_t time_now;
int r;
assert(s);
- assert(client);
assert(client->event);
r = sd_event_now(client->event, CLOCK_BOOTTIME, &time_now);
}
static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) {
- sd_dhcp_client *client = userdata;
+ sd_dhcp_client *client = ASSERT_PTR(userdata);
DHCP_CLIENT_DONT_DESTROY(client);
int r;
- assert(client);
-
client->receive_message = sd_event_source_disable_unref(client->receive_message);
client->fd = safe_close(client->fd);
uint32_t revents,
void *userdata) {
- sd_dhcp_client *client = userdata;
+ sd_dhcp_client *client = ASSERT_PTR(userdata);
_cleanup_free_ DHCPMessage *message = NULL;
const uint8_t *expected_chaddr = NULL;
uint8_t expected_hlen = 0;
ssize_t len, buflen;
assert(s);
- assert(client);
buflen = next_datagram_size_fd(fd);
if (buflen < 0) {
uint32_t revents,
void *userdata) {
- sd_dhcp_client *client = userdata;
+ sd_dhcp_client *client = ASSERT_PTR(userdata);
_cleanup_free_ DHCPPacket *packet = NULL;
CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct tpacket_auxdata))) control;
struct iovec iov = {};
int r;
assert(s);
- assert(client);
buflen = next_datagram_size_fd(fd);
if (buflen < 0) {
}
int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void *userdata) {
- sd_dhcp_lease *lease = userdata;
+ sd_dhcp_lease *lease = ASSERT_PTR(userdata);
int r;
- assert(lease);
-
switch (code) {
case SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME:
}
static int parse_request(uint8_t code, uint8_t len, const void *option, void *userdata) {
- DHCPRequest *req = userdata;
-
- assert(req);
+ DHCPRequest *req = ASSERT_PTR(userdata);
switch (code) {
case SD_DHCP_OPTION_IP_ADDRESS_LEASE_TIME:
uint32_t revents, void *userdata) {
_cleanup_free_ DHCPMessage *message = NULL;
CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct in_pktinfo))) control;
- sd_dhcp_server *server = userdata;
+ sd_dhcp_server *server = ASSERT_PTR(userdata);
struct iovec iov = {};
struct msghdr msg = {
.msg_iov = &iov,
ssize_t datagram_size, len;
int r;
- assert(server);
-
datagram_size = next_datagram_size_fd(fd);
if (datagram_size < 0) {
if (ERRNO_IS_TRANSIENT(datagram_size) || ERRNO_IS_DISCONNECT(datagram_size))
}
static int ipv4acd_on_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
- sd_ipv4acd *acd = userdata;
+ sd_ipv4acd *acd = ASSERT_PTR(userdata);
int r = 0;
- assert(acd);
-
switch (acd->state) {
case IPV4ACD_STATE_STARTED:
uint32_t revents,
void *userdata) {
- sd_ipv4acd *acd = userdata;
+ sd_ipv4acd *acd = ASSERT_PTR(userdata);
struct ether_arp packet;
ssize_t n;
int r;
assert(s);
- assert(acd);
assert(fd >= 0);
n = recv(fd, &packet, sizeof(struct ether_arp), 0);
}
void ipv4ll_on_acd(sd_ipv4acd *acd, int event, void *userdata) {
- sd_ipv4ll *ll = userdata;
+ sd_ipv4ll *ll = ASSERT_PTR(userdata);
IPV4LL_DONT_DESTROY(ll);
int r;
assert(acd);
- assert(ll);
switch (event) {
}
static int ipv4ll_check_mac(sd_ipv4acd *acd, const struct ether_addr *mac, void *userdata) {
- sd_ipv4ll *ll = userdata;
-
- assert(ll);
+ sd_ipv4ll *ll = ASSERT_PTR(userdata);
if (ll->check_mac_callback)
return ll->check_mac_callback(ll, mac, ll->check_mac_userdata);
static int lldp_rx_receive_datagram(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
ssize_t space, length;
- sd_lldp_rx *lldp_rx = userdata;
+ sd_lldp_rx *lldp_rx = ASSERT_PTR(userdata);
struct timespec ts;
assert(fd >= 0);
- assert(lldp_rx);
space = next_datagram_size_fd(fd);
if (space < 0) {
}
static int on_timer_event(sd_event_source *s, uint64_t usec, void *userdata) {
- sd_lldp_tx *lldp_tx = userdata;
+ sd_lldp_tx *lldp_tx = ASSERT_PTR(userdata);
int r;
- assert(lldp_tx);
-
r = lldp_tx_send(lldp_tx);
if (r < 0)
log_lldp_tx_errno(lldp_tx, r, "Failed to send packet, ignoring: %m");
static int ndisc_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_(sd_ndisc_router_unrefp) sd_ndisc_router *rt = NULL;
- sd_ndisc *nd = userdata;
+ sd_ndisc *nd = ASSERT_PTR(userdata);
ssize_t buflen;
int r;
assert(s);
- assert(nd);
assert(nd->event);
buflen = next_datagram_size_fd(fd);
}
static int ndisc_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
- sd_ndisc *nd = userdata;
+ sd_ndisc *nd = ASSERT_PTR(userdata);
usec_t time_now;
int r;
assert(s);
- assert(nd);
assert(nd->event);
assert_se(sd_event_now(nd->event, CLOCK_BOOTTIME, &time_now) >= 0);
}
static int ndisc_timeout_no_ra(sd_event_source *s, uint64_t usec, void *userdata) {
- sd_ndisc *nd = userdata;
+ sd_ndisc *nd = ASSERT_PTR(userdata);
assert(s);
- assert(nd);
log_ndisc(nd, "No RA received before link confirmation timeout");
}
static int radv_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- sd_radv *ra = userdata;
+ sd_radv *ra = ASSERT_PTR(userdata);
struct in6_addr src;
triple_timestamp timestamp;
int r;
assert(s);
- assert(ra);
assert(ra->event);
ssize_t buflen = next_datagram_size_fd(fd);
static int radv_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
usec_t min_timeout, max_timeout, time_now, timeout;
- sd_radv *ra = userdata;
+ sd_radv *ra = ASSERT_PTR(userdata);
int r;
assert(s);
- assert(ra);
assert(ra->event);
assert(router_lifetime_is_valid(ra->lifetime_usec));
const char *interface_name,
const sd_bus_vtable *v) {
- const sd_bus_vtable *vtable = v;
+ const sd_bus_vtable *vtable = ASSERT_PTR(v);
const char *names = "";
int r;
assert(i);
assert(interface_name);
- assert(v);
r = set_interface_name(i, interface_name);
if (r < 0)
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;
+ sd_bus_track *track = ASSERT_PTR(userdata);
const char *name;
int r;
assert(message);
- assert(track);
r = sd_bus_message_read(message, "sss", &name, NULL, NULL);
if (r < 0)
void *userdata,
sd_bus_error *ret_error) {
- sd_bus_slot *match_slot = userdata;
+ sd_bus_slot *match_slot = ASSERT_PTR(userdata);
bool failed = false;
int r;
assert(m);
- assert(match_slot);
sd_bus_slot_ref(match_slot);
}
static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
/* Note that this is called both on input_fd, output_fd as well as inotify_fd events */
r = sd_bus_process(bus, NULL);
}
static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
r = sd_bus_process(bus, NULL);
if (r < 0) {
log_debug_errno(r, "Processing of bus failed, closing down: %m");
}
static int prepare_callback(sd_event_source *s, void *userdata) {
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r, e;
usec_t until;
assert(s);
- assert(bus);
e = sd_bus_get_events(bus);
if (e < 0) {
static int device_monitor_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_(sd_device_unrefp) sd_device *device = NULL;
- sd_device_monitor *m = userdata;
-
- assert(m);
+ sd_device_monitor *m = ASSERT_PTR(userdata);
if (device_monitor_receive_device(m, &device) <= 0)
return 0;
}
static int match_is_valid(const void *data, size_t size) {
- assert(data);
+ const char *b = ASSERT_PTR(data);
if (size < 2)
return false;
if (((char*) data)[0] == '_' && ((char*) data)[1] == '_')
return false;
- const char *b = data;
for (const char *p = b; p < b + size; p++) {
if (*p == '=')
}
static char *lookup_field(const char *field, void *userdata) {
- sd_journal *j = userdata;
+ sd_journal *j = ASSERT_PTR(userdata);
const void *data;
size_t size, d;
int r;
assert(field);
- assert(j);
r = sd_journal_get_data(j, field, &data, &size);
if (r < 0 ||
}
static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- sd_netlink *nl = userdata;
+ sd_netlink *nl = ASSERT_PTR(userdata);
int r;
- assert(nl);
-
r = sd_netlink_process(nl, NULL);
if (r < 0)
return r;
}
static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
- sd_netlink *nl = userdata;
+ sd_netlink *nl = ASSERT_PTR(userdata);
int r;
- assert(nl);
-
r = sd_netlink_process(nl, NULL);
if (r < 0)
return r;
}
static int prepare_callback(sd_event_source *s, void *userdata) {
- sd_netlink *nl = userdata;
+ sd_netlink *nl = ASSERT_PTR(userdata);
int r, enabled;
usec_t until;
assert(s);
- assert(nl);
r = sd_netlink_get_events(nl);
if (r < 0)
}
static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- sd_resolve *resolve = userdata;
+ sd_resolve *resolve = ASSERT_PTR(userdata);
int r;
- assert(resolve);
-
r = sd_resolve_process(resolve);
if (r < 0)
return r;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
r = bus_map_all_properties(bus,
"org.freedesktop.locale1",
"/org/freedesktop/locale1",
static int set_locale(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
r = bus_message_new_method_call(bus, &m, bus_locale, "SetLocale");
static int set_vconsole_keymap(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
const char *map, *toggle_map;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
map = argv[1];
static int method_set_locale(sd_bus_message *m, void *userdata, sd_bus_error *error) {
_cleanup_(locale_variables_freep) char *new_locale[_VARIABLE_LC_MAX] = {};
_cleanup_strv_free_ char **l = NULL, **l_set = NULL, **l_unset = NULL;
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
int interactive, r;
bool use_localegen;
assert(m);
- assert(c);
r = sd_bus_message_read_strv(m, &l);
if (r < 0)
}
static int method_set_vc_keyboard(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
const char *keymap, *keymap_toggle;
int convert, interactive, r;
assert(m);
- assert(c);
r = sd_bus_message_read(m, "ssbb", &keymap, &keymap_toggle, &convert, &interactive);
if (r < 0)
#endif
static int method_set_x11_keyboard(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
const char *layout, *model, *variant, *options;
int convert, interactive, r;
assert(m);
- assert(c);
r = sd_bus_message_read(m, "ssssbb", &layout, &model, &variant, &options, &convert, &interactive);
if (r < 0)
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
pager_open(arg_pager_flags);
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
pager_open(arg_pager_flags);
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
pager_open(arg_pager_flags);
static int show_session(int argc, char *argv[], void *userdata) {
bool properties, new_line = false;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *path = NULL;
- assert(bus);
assert(argv);
properties = !strstr(argv[0], "status");
static int show_user(int argc, char *argv[], void *userdata) {
bool properties, new_line = false;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
properties = !strstr(argv[0], "status");
static int show_seat(int argc, char *argv[], void *userdata) {
bool properties, new_line = false;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
properties = !strstr(argv[0], "status");
static int activate(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
static int kill_session(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
static int enable_linger(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
char* short_argv[3];
bool b;
int r;
- assert(bus);
assert(argv);
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
static int terminate_user(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
static int kill_user(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
static int attach(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
static int flush_devices(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
static int lock_sessions(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
static int terminate_seat(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
assert(argv);
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
static int brightness_writer_fork(BrightnessWriter *w);
static int on_brightness_writer_exit(sd_event_source *s, const siginfo_t *si, void *userdata) {
- BrightnessWriter *w = userdata;
+ BrightnessWriter *w = ASSERT_PTR(userdata);
int r;
assert(s);
assert(si);
- assert(w);
assert(si->si_pid == w->child);
w->child = 0;
}
static int button_recheck(sd_event_source *e, void *userdata) {
- Button *b = userdata;
+ Button *b = ASSERT_PTR(userdata);
- assert(b);
assert(b->lid_closed);
button_lid_switch_handle_action(b->manager, false);
}
static int long_press_of_power_key_handler(sd_event_source *e, uint64_t usec, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(e);
- assert(m);
m->power_key_long_press_event_source = sd_event_source_unref(m->power_key_long_press_event_source);
}
static int long_press_of_reboot_key_handler(sd_event_source *e, uint64_t usec, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(e);
- assert(m);
m->reboot_key_long_press_event_source = sd_event_source_unref(m->reboot_key_long_press_event_source);
}
static int long_press_of_suspend_key_handler(sd_event_source *e, uint64_t usec, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(e);
- assert(m);
m->suspend_key_long_press_event_source = sd_event_source_unref(m->suspend_key_long_press_event_source);
}
static int long_press_of_hibernate_key_handler(sd_event_source *e, uint64_t usec, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(e);
- assert(m);
m->hibernate_key_long_press_event_source = sd_event_source_unref(m->hibernate_key_long_press_event_source);
}
static int button_dispatch(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Button *b = userdata;
+ Button *b = ASSERT_PTR(userdata);
struct input_event ev;
ssize_t l;
assert(s);
assert(fd == b->fd);
- assert(b);
l = read(b->fd, &ev, sizeof(ev));
if (l < 0)
void *data,
void *userdata) {
- unsigned *n = data;
+ unsigned *n = ASSERT_PTR(data);
unsigned o;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = safe_atou(rvalue, &o);
if (r < 0) {
#if ENABLE_UTMP
static int manager_dispatch_utmp(sd_event_source *s, const struct inotify_event *event, void *userdata) {
- Manager *m = userdata;
-
- assert(m);
+ Manager *m = ASSERT_PTR(userdata);
/* If there's indication the file itself might have been removed or became otherwise unavailable, then let's
* reestablish the watch on whatever there's now. */
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(m);
return sd_bus_message_append(reply, "b", manager_get_idle_hint(m, NULL) > 0);
}
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
dual_timestamp t = DUAL_TIMESTAMP_NULL;
assert(bus);
assert(reply);
- assert(m);
manager_get_idle_hint(m, &t);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
InhibitWhat w;
assert(bus);
assert(reply);
- assert(m);
w = manager_inhibit_what(m, streq(property, "BlockInhibited") ? INHIBIT_BLOCK : INHIBIT_DELAY);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
bool b = false;
assert(bus);
assert(reply);
- assert(m);
if (m->delayed_action) {
if (streq(property, "PreparingForShutdown"))
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(m);
r = sd_bus_message_open_container(reply, 'r', "st");
if (r < 0)
static int method_get_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
Session *session;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
static int method_get_session_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
Session *session = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
pid_t pid;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(pid_t) == sizeof(uint32_t));
static int method_get_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint32_t uid;
User *user;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "u", &uid);
if (r < 0)
static int method_get_user_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
User *user = NULL;
pid_t pid;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(pid_t) == sizeof(uint32_t));
static int method_get_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
Seat *seat;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
static int method_list_sessions(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Session *session;
int r;
assert(message);
- assert(m);
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
static int method_list_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
User *user;
int r;
assert(message);
- assert(m);
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
static int method_list_seats(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Seat *seat;
int r;
assert(message);
- assert(m);
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
static int method_list_inhibitors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Inhibitor *inhibitor;
int r;
assert(message);
- assert(m);
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
_cleanup_free_ char *id = NULL;
Session *session = NULL;
uint32_t audit_id = 0;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
User *user = NULL;
Seat *seat = NULL;
pid_t leader;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(pid_t) == sizeof(uint32_t));
assert_cc(sizeof(uid_t) == sizeof(uint32_t));
}
static int method_release_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Session *session;
const char *name;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
}
static int method_activate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Session *session;
const char *name;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
static int method_activate_session_on_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *session_name, *seat_name;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Session *session;
Seat *seat;
int r;
assert(message);
- assert(m);
/* Same as ActivateSession() but refuses to work if the seat doesn't match */
}
static int method_lock_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Session *session;
const char *name;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
}
static int method_lock_sessions(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = bus_verify_polkit_async(
message,
static int method_kill_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *name;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Session *session;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
}
static int method_kill_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint32_t uid;
User *user;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "u", &uid);
if (r < 0)
}
static int method_terminate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
Session *session;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
}
static int method_terminate_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint32_t uid;
User *user;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "u", &uid);
if (r < 0)
}
static int method_terminate_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
Seat *seat;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
static int method_set_user_linger(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
_cleanup_free_ char *cc = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r, b, interactive;
struct passwd *pw;
const char *path;
uint32_t uid, auth_uid;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "ubb", &uid, &b, &interactive);
if (r < 0)
static int method_attach_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *sysfs, *seat;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int interactive, r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "ssb", &seat, &sysfs, &interactive);
if (r < 0)
}
static int method_flush_devices(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int interactive, r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "b", &interactive);
if (r < 0)
}
static int lid_switch_ignore_handler(sd_event_source *e, uint64_t usec, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(e);
- assert(m);
m->lid_switch_ignore_event_source = sd_event_source_unref(m->lid_switch_ignore_event_source);
return 0;
uint64_t usec,
void *userdata) {
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
- assert(manager);
assert(manager->inhibit_timeout_source == s);
return manager_dispatch_delayed(manager, true);
const HandleActionData *a = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
- assert(m);
-
a = m->scheduled_shutdown_action;
assert(a);
}
static int method_schedule_shutdown(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
HandleAction handle;
const HandleActionData *a;
uint64_t elapse;
int r;
bool dry_run = false;
- assert(m);
assert(message);
r = sd_bus_message_read(message, "st", &type, &elapse);
}
static int method_cancel_scheduled_shutdown(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const HandleActionData *a;
bool cancelled;
int r;
- assert(m);
assert(message);
cancelled = m->scheduled_shutdown_action
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *arg;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &arg);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- _unused_ Manager *m = userdata;
+ _unused_ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = detect_container();
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
bool use_efi;
int b, r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "b", &b);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- _unused_ Manager *m = userdata;
+ _unused_ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = getenv_bool("SYSTEMD_REBOOT_TO_FIRMWARE_SETUP");
if (r == -ENXIO) {
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
bool use_efi;
uint64_t x;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "t", &x);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- _unused_ Manager *m = userdata;
+ _unused_ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU");
if (r == -ENXIO) {
sd_bus_error *error) {
_cleanup_free_ char *v = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *x = NULL;
int r;
assert(bus);
assert(reply);
- assert(m);
r = getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY");
if (r == -ENXIO) {
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
bool use_efi;
const char *v;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &v);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- _unused_ Manager *m = userdata;
+ _unused_ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY");
if (r == -ENXIO) {
sd_bus_error *error) {
_cleanup_(boot_config_free) BootConfig config = BOOT_CONFIG_NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
size_t i;
int r;
assert(bus);
assert(reply);
- assert(m);
r = boot_config_load_auto(&config, NULL, NULL);
if (r < 0 && r != -ENOKEY) /* don't complain if there's no GPT found */
sd_bus_error *error) {
int r;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
char *wall_message;
int enable_wall_messages;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "sb", &wall_message, &enable_wall_messages);
if (r < 0)
const char *who, *why, *what, *mode;
_cleanup_free_ char *id = NULL;
_cleanup_close_ int fifo_fd = -1;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
InhibitMode mm;
InhibitWhat w;
pid_t pid;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "ssss", &what, &who, &why, &mode);
if (r < 0)
int match_job_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *path, *result, *unit;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Session *session;
uint32_t id;
User *user;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
if (r < 0) {
int match_unit_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *path, *unit;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Session *session;
User *user;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "so", &unit, &path);
if (r < 0) {
int match_properties_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *unit = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *path;
Session *session;
User *user;
int r;
assert(message);
- assert(m);
path = sd_bus_message_get_path(message);
if (!path)
}
int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Session *session;
int b, r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "b", &b);
if (r < 0) {
}
static int inhibitor_dispatch_fifo(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Inhibitor *i = userdata;
+ Inhibitor *i = ASSERT_PTR(userdata);
assert(s);
assert(fd == i->fifo_fd);
- assert(i);
inhibitor_stop(i);
inhibitor_free(i);
sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Seat *s = userdata;
+ Seat *s = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(s);
p = s->active ? session_bus_path(s->active) : strdup("/");
if (!p)
void *userdata,
sd_bus_error *error) {
- Seat *s = userdata;
+ Seat *s = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(s);
r = sd_bus_message_open_container(reply, 'a', "(so)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Seat *s = userdata;
+ Seat *s = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(s);
return sd_bus_message_append(reply, "b", seat_get_idle_hint(s, NULL) > 0);
}
void *userdata,
sd_bus_error *error) {
- Seat *s = userdata;
+ Seat *s = ASSERT_PTR(userdata);
dual_timestamp t;
uint64_t u;
int r;
assert(bus);
assert(reply);
- assert(s);
r = seat_get_idle_hint(s, &t);
if (r < 0)
}
int bus_seat_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Seat *s = userdata;
+ Seat *s = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(s);
r = bus_verify_polkit_async(
message,
}
static int method_activate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Seat *s = userdata;
+ Seat *s = ASSERT_PTR(userdata);
const char *name;
Session *session;
int r;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
}
static int method_switch_to(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Seat *s = userdata;
+ Seat *s = ASSERT_PTR(userdata);
unsigned to;
int r;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "u", &to);
if (r < 0)
}
static int method_switch_to_next(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Seat *s = userdata;
+ Seat *s = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(s);
r = check_polkit_chvt(message, s->manager, error);
if (r < 0)
}
static int method_switch_to_previous(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Seat *s = userdata;
+ Seat *s = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(s);
r = check_polkit_chvt(message, s->manager, error);
if (r < 0)
static int seat_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
_cleanup_free_ char *e = NULL;
sd_bus_message *message;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *p;
Seat *seat;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
p = startswith(path, "/org/freedesktop/login1/seat/");
if (!p)
sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(s);
p = user_bus_path(s->user);
if (!p)
void *userdata,
sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(s);
return sd_bus_message_append(reply, "s", s->user->user_record->user_name);
}
sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(s);
p = s->seat ? seat_bus_path(s->seat) : strdup("/");
if (!p)
void *userdata,
sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(s);
return sd_bus_message_append(reply, "b", session_get_idle_hint(s, NULL) > 0);
}
void *userdata,
sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
dual_timestamp t = DUAL_TIMESTAMP_NULL;
uint64_t u;
int r;
assert(bus);
assert(reply);
- assert(s);
r = session_get_idle_hint(s, &t);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(s);
return sd_bus_message_append(reply, "b", session_get_locked_hint(s) > 0);
}
int bus_session_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(s);
r = bus_verify_polkit_async(
message,
}
int bus_session_method_activate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(s);
r = check_polkit_chvt(message, s->manager, error);
if (r < 0)
}
int bus_session_method_lock(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(s);
r = bus_verify_polkit_async(
message,
static int method_set_idle_hint(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
uid_t uid;
int r, b;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "b", &b);
if (r < 0)
static int method_set_locked_hint(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
uid_t uid;
int r, b;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "b", &b);
if (r < 0)
}
int bus_session_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
const char *swho;
int32_t signo;
KillWho who;
int r;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "si", &swho, &signo);
if (r < 0)
static int method_take_control(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
int r, force;
uid_t uid;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "b", &force);
if (r < 0)
}
static int method_release_control(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
assert(message);
- assert(s);
if (!session_is_controller(s, sd_bus_message_get_sender(message)))
return sd_bus_error_set(error, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
}
static int method_set_type(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
const char *t;
SessionType type;
int r;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "s", &t);
if (r < 0)
}
static int method_take_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
uint32_t major, minor;
SessionDevice *sd;
dev_t dev;
int r;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "uu", &major, &minor);
if (r < 0)
}
static int method_release_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
uint32_t major, minor;
SessionDevice *sd;
dev_t dev;
int r;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "uu", &major, &minor);
if (r < 0)
}
static int method_pause_device_complete(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
uint32_t major, minor;
SessionDevice *sd;
dev_t dev;
int r;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "uu", &major, &minor);
if (r < 0)
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
_cleanup_(sd_device_unrefp) sd_device *d = NULL;
const char *subsystem, *name, *seat;
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
uint32_t brightness;
uid_t uid;
int r;
assert(message);
- assert(s);
r = sd_bus_message_read(message, "ssu", &subsystem, &name, &brightness);
if (r < 0)
static int session_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
_cleanup_free_ char *e = NULL;
sd_bus_message *message;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Session *session;
const char *p;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
p = startswith(path, "/org/freedesktop/login1/session/");
if (!p)
}
static int release_timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
assert(es);
- assert(s);
session_stop(s, /* force = */ false);
return 0;
}
static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
- assert(s);
assert(s->fifo_fd == fd);
/* EOF on the FIFO means the session died abnormally. */
}
static int on_bus_track(sd_bus_track *track, void *userdata) {
- Session *s = userdata;
+ Session *s = ASSERT_PTR(userdata);
assert(track);
- assert(s);
session_drop_controller(s);
void *userdata,
sd_bus_error *error) {
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(u);
return sd_bus_message_append(reply, "u", (uint32_t) u->user_record->uid);
}
void *userdata,
sd_bus_error *error) {
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(u);
return sd_bus_message_append(reply, "u", (uint32_t) u->user_record->gid);
}
void *userdata,
sd_bus_error *error) {
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(u);
return sd_bus_message_append(reply, "s", u->user_record->user_name);
}
sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(u);
p = u->display ? session_bus_path(u->display) : strdup("/");
if (!p)
void *userdata,
sd_bus_error *error) {
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(u);
r = sd_bus_message_open_container(reply, 'a', "(so)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(u);
return sd_bus_message_append(reply, "b", user_get_idle_hint(u, NULL) > 0);
}
void *userdata,
sd_bus_error *error) {
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
dual_timestamp t = DUAL_TIMESTAMP_NULL;
uint64_t k;
assert(bus);
assert(reply);
- assert(u);
(void) user_get_idle_hint(u, &t);
k = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
void *userdata,
sd_bus_error *error) {
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
- assert(u);
r = user_check_linger_file(u);
}
int bus_user_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(u);
r = bus_verify_polkit_async(
message,
}
int bus_user_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
int32_t signo;
int r;
assert(message);
- assert(u);
r = bus_verify_polkit_async(
message,
}
static int user_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uid_t uid;
User *user;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
if (streq(path, "/org/freedesktop/login1/user/self")) {
sd_bus_message *message;
}
static int update_slice_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
- _cleanup_(user_record_unrefp) UserRecord *ur = userdata;
+ _cleanup_(user_record_unrefp) UserRecord *ur = ASSERT_PTR(userdata);
const sd_bus_error *e;
int r;
assert(m);
- assert(ur);
e = sd_bus_message_get_error(m);
if (e) {
}
static int user_stop_timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) {
- User *u = userdata;
+ User *u = ASSERT_PTR(userdata);
- assert(u);
user_add_to_gc_queue(u);
return 0;
void *data,
void *userdata) {
- uint64_t *sz = data;
+ uint64_t *sz = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
/* First, try to parse as percentage */
r = parse_permyriad(rvalue);
}
static int manager_dispatch_seat_udev(sd_device_monitor *monitor, sd_device *device, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(device);
manager_process_seat_device(m, device);
}
static int manager_dispatch_device_udev(sd_device_monitor *monitor, sd_device *device, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(device);
manager_process_seat_device(m, device);
}
static int manager_dispatch_vcsa_udev(sd_device_monitor *monitor, sd_device *device, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
- assert(m);
assert(device);
/* Whenever a VCSA device is removed try to reallocate our
}
static int manager_dispatch_button_udev(sd_device_monitor *monitor, sd_device *device, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(device);
manager_process_button_device(m, device);
}
static int manager_dispatch_console(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(m->seat0);
assert(m->console_active_fd == fd);
}
static int manager_dispatch_idle_action(sd_event_source *s, uint64_t t, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
struct dual_timestamp since;
usec_t n, elapse;
int r;
- assert(m);
-
if (m->idle_action == HANDLE_IGNORE ||
m->idle_action_usec <= 0)
return 0;
sd_bus_error *error) {
_cleanup_close_pair_ int errno_pipe_fd[2] = { -1, -1 };
- Image *image = userdata;
+ Image *image = ASSERT_PTR(userdata);
Manager *m = image->userdata;
pid_t child;
int r;
assert(message);
- assert(image);
if (m->n_operations >= OPERATIONS_MAX)
return sd_bus_error_set(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Too many ongoing operations.");
void *userdata,
sd_bus_error *error) {
- Image *image = userdata;
+ Image *image = ASSERT_PTR(userdata);
Manager *m = image->userdata;
const char *new_name;
int r;
assert(message);
- assert(image);
r = sd_bus_message_read(message, "s", &new_name);
if (r < 0)
sd_bus_error *error) {
_cleanup_close_pair_ int errno_pipe_fd[2] = { -1, -1 };
- Image *image = userdata;
- Manager *m = image->userdata;
+ Image *image = ASSERT_PTR(userdata);
+ Manager *m = ASSERT_PTR(image->userdata);
const char *new_name;
int r, read_only;
pid_t child;
assert(message);
- assert(image);
- assert(m);
if (m->n_operations >= OPERATIONS_MAX)
return sd_bus_error_set(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Too many ongoing operations.");
}
static int image_flush_cache(sd_event_source *s, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(s);
- assert(m);
hashmap_clear(m->image_cache);
return 0;
void *userdata,
sd_bus_error *error) {
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
- assert(m);
assert_cc(sizeof(int) == sizeof(int32_t));
}
int bus_machine_method_unregister(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
const char *details[] = {
"machine", m->name,
}
int bus_machine_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
const char *details[] = {
"machine", m->name,
}
int bus_machine_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
const char *swho;
int32_t signo;
KillWho who;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "si", &swho, &signo);
if (r < 0)
int bus_machine_method_get_addresses(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
int bus_machine_method_get_os_release(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
switch (m->class) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_free_ char *pty_name = NULL;
_cleanup_close_ int master = -1;
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
const char *details[] = {
"machine", m->name,
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *allocated_bus = NULL;
_cleanup_close_ int master = -1;
sd_bus *container_bus = NULL;
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
const char *p, *getty;
int r;
assert(message);
- assert(m);
const char *details[] = {
"machine", m->name,
sd_bus *container_bus = NULL;
_cleanup_close_ int master = -1, slave = -1;
_cleanup_strv_free_ char **env = NULL, **args_wire = NULL, **args = NULL;
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
const char *p, *unit, *user, *path, *description, *utmp_id;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "ss", &user, &path);
if (r < 0)
int bus_machine_method_bind_mount(sd_bus_message *message, void *userdata, sd_bus_error *error) {
int read_only, make_file_or_directory;
const char *dest, *src, *propagate_directory;
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
uid_t uid;
int r;
assert(message);
- assert(m);
if (m->class != MACHINE_CONTAINER)
return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Bind mounting is only supported on container machines.");
_cleanup_close_pair_ int errno_pipe_fd[2] = { -1, -1 };
CopyFlags copy_flags = COPY_REFLINK|COPY_MERGE|COPY_HARDLINKS;
_cleanup_close_ int hostfd = -1;
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
bool copy_from;
pid_t child;
uid_t uid_shift;
int r;
assert(message);
- assert(m);
if (m->manager->n_operations >= OPERATIONS_MAX)
return sd_bus_error_set(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Too many ongoing copies.");
int bus_machine_method_open_root_directory(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_close_ int fd = -1;
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
const char *details[] = {
"machine", m->name,
}
int bus_machine_method_get_uid_shift(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Machine *m = userdata;
+ Machine *m = ASSERT_PTR(userdata);
uid_t shift = 0;
int r;
assert(message);
- assert(m);
/* You wonder why this is a method and not a property? Well, properties are not supposed to return errors, but
* we kinda have to for this. */
}
static int machine_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Machine *machine;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
if (streq(path, "/org/freedesktop/machine1/machine/self")) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
pager_open(arg_pager_flags);
r = bus_call_method(bus, bus_machine_mgr, "ListMachines", &error, &reply, NULL);
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
pager_open(arg_pager_flags);
r = bus_call_method(bus, bus_machine_mgr, "ListImages", &error, &reply, NULL);
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
bool properties, new_line = false;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r = 0;
- assert(bus);
-
properties = !strstr(argv[0], "status");
pager_open(arg_pager_flags);
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
bool properties, new_line = false;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r = 0;
- assert(bus);
-
properties = !strstr(argv[0], "status");
pager_open(arg_pager_flags);
static int kill_machine(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
if (!arg_kill_whom)
static int terminate_machine(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
for (int i = 1; i < argc; i++) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_free_ char *abs_host_path = NULL;
char *dest, *host_path, *container_path;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
bool copy_from;
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
copy_from = streq(argv[0], "copy-from");
static int bind_mount(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
r = bus_call_method(
_cleanup_(sd_bus_slot_unrefp) sd_bus_slot *slot = NULL;
_cleanup_(sd_event_unrefp) sd_event *event = NULL;
int master = -1, r;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
const char *match, *machine;
- assert(bus);
-
if (!strv_isempty(arg_setenv) || arg_uid)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"--setenv= and --uid= are not supported for 'login'. Use 'shell' instead.");
_cleanup_(sd_bus_slot_unrefp) sd_bus_slot *slot = NULL;
_cleanup_(sd_event_unrefp) sd_event *event = NULL;
int master = -1, r;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
const char *match, *machine, *path;
_cleanup_free_ char *uid = NULL;
- assert(bus);
-
if (!IN_SET(arg_transport, BUS_TRANSPORT_LOCAL, BUS_TRANSPORT_MACHINE))
return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
"Shell only supported on local machines.");
}
static int remove_image(int argc, char *argv[], void *userdata) {
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
for (int i = 1; i < argc; i++) {
static int rename_image(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
r = bus_call_method(
static int clone_image(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
r = bus_message_new_method_call(bus, &m, bus_machine_mgr, "CloneImage");
static int read_only_image(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int b = true, r;
- assert(bus);
-
if (argc > 2) {
b = parse_boolean(argv[2]);
if (b < 0)
static int start_machine(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(bus_wait_for_jobs_freep) BusWaitForJobs *w = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
ask_password_agent_open_if_enabled(arg_transport, arg_ask_password);
UnitFileChange *changes = NULL;
size_t n_changes = 0;
const char *method = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
method = streq(argv[0], "enable") ? "EnableUnitFiles" : "DisableUnitFiles";
_cleanup_free_ char *ll = NULL, *fn = NULL;
const char *local = NULL, *path = NULL;
_cleanup_close_ int fd = -1;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
if (argc >= 2)
path = empty_or_dash_to_null(argv[1]);
_cleanup_free_ char *ll = NULL, *fn = NULL;
const char *local = NULL, *path = NULL;
_cleanup_close_ int fd = -1;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
if (argc >= 2)
path = empty_or_dash_to_null(argv[1]);
const char *local = NULL, *path = NULL;
_cleanup_free_ char *fn = NULL;
_cleanup_close_ int fd = -1;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
if (argc >= 2)
path = empty_or_dash_to_null(argv[1]);
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_close_ int fd = -1;
const char *local = NULL, *path = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
local = argv[1];
if (!hostname_is_valid(local, 0))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_close_ int fd = -1;
const char *local = NULL, *path = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
local = argv[1];
if (!hostname_is_valid(local, 0))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_free_ char *l = NULL, *ll = NULL;
const char *local, *remote;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
remote = argv[1];
if (!http_url_is_valid(remote) && !file_url_is_valid(remote))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_free_ char *l = NULL, *ll = NULL;
const char *local, *remote;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
remote = argv[1];
if (!http_url_is_valid(remote) && !file_url_is_valid(remote))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
static int cancel_transfer(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
for (int i = 1; i < argc; i++) {
static int method_get_machine(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Machine *machine;
const char *name;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
static int method_get_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- _unused_ Manager *m = userdata;
+ _unused_ Manager *m = ASSERT_PTR(userdata);
const char *name;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
static int method_get_machine_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Machine *machine = NULL;
pid_t pid;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(pid_t) == sizeof(uint32_t));
static int method_list_machines(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Machine *machine;
int r;
assert(message);
- assert(m);
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
}
static int method_create_machine_internal(sd_bus_message *message, bool read_network, void *userdata, sd_bus_error *error) {
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
Machine *m = NULL;
int r;
assert(message);
- assert(manager);
r = method_create_or_register_machine(manager, message, read_network, &m, error);
if (r < 0)
}
static int method_register_machine_internal(sd_bus_message *message, bool read_network, void *userdata, sd_bus_error *error) {
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
_cleanup_free_ char *p = NULL;
Machine *m = NULL;
int r;
assert(message);
- assert(manager);
r = method_create_or_register_machine(manager, message, read_network, &m, error);
if (r < 0)
static int method_list_images(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_hashmap_free_ Hashmap *images = NULL;
- _unused_ Manager *m = userdata;
+ _unused_ Manager *m = ASSERT_PTR(userdata);
Image *image;
int r;
assert(message);
- assert(m);
images = hashmap_new(&image_hash_ops);
if (!images)
int match_job_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *path, *result, *unit;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Machine *machine;
uint32_t id;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
if (r < 0) {
int match_properties_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *unit = NULL;
const char *path;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Machine *machine;
int r;
assert(message);
- assert(m);
path = sd_bus_message_get_path(message);
if (!path)
int match_unit_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *path, *unit;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Machine *machine;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "so", &unit, &path);
if (r < 0) {
}
int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Machine *machine;
int b, r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "b", &b);
if (r < 0) {
};
_cleanup_free_ char *found_name = NULL, *found_real_name = NULL;
uid_t found_uid = UID_INVALID, uid;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *un;
int r;
assert(parameters);
- assert(m);
r = json_dispatch(parameters, dispatch_table, NULL, 0, &p);
if (r < 0)
};
_cleanup_free_ char *found_name = NULL, *found_description = NULL;
uid_t found_gid = GID_INVALID, gid;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *gn;
int r;
assert(parameters);
- assert(m);
r = json_dispatch(parameters, dispatch_table, NULL, 0, &p);
if (r < 0)
static int operation_done(sd_event_source *s, const siginfo_t *si, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- Operation *o = userdata;
+ Operation *o = ASSERT_PTR(userdata);
int r;
- assert(o);
assert(si);
log_debug("Operating " PID_FMT " is now complete with code=%s status=%i",
}
int parse_cmdline_item(const char *key, const char *value, void *data) {
- Context *context = data;
+ Context *context = ASSERT_PTR(data);
assert(key);
- assert(data);
if (streq(key, "ip"))
return parse_cmdline_ip(context, key, value);
void *data,
void *userdata) {
- uint8_t *ret = data;
+ uint8_t *ret = ASSERT_PTR(data);
unsigned protocol;
/* linux/fou.h defines the netlink field as one byte, so we need to reject protocols numbers that
* don't fit in one byte. */
assert(section);
assert(lvalue);
assert(rvalue);
- assert(data);
r = parse_ip_protocol(rvalue);
if (r >= 0)
void *data,
void *userdata) {
- union in_addr_union *addr = data;
+ union in_addr_union *addr = ASSERT_PTR(data);
FouTunnel *t = userdata;
int r, *f;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (streq(lvalue, "Local"))
f = &t->local_family;
void *data,
void *userdata) {
- uint16_t u, *pkey = data;
+ uint16_t u, *pkey = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*pkey = 0; /* 0 means unset. */
_cleanup_free_ char *addr_or_type = NULL, *ifname = NULL;
L2tpLocalAddressType type;
- L2tpTunnel *t = userdata;
- const char *p = rvalue;
+ L2tpTunnel *t = ASSERT_PTR(userdata);
+ const char *p = ASSERT_PTR(rvalue);
union in_addr_union a;
int r, f;
assert(filename);
assert(lvalue);
- assert(rvalue);
- assert(t);
if (isempty(rvalue)) {
t->local_ifname = mfree(t->local_ifname);
void *data,
void *userdata) {
- L2tpTunnel *t = userdata;
+ L2tpTunnel *t = ASSERT_PTR(userdata);
union in_addr_union a;
int r, f;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(t);
if (isempty(rvalue)) {
t->remote = IN_ADDR_NULL;
void *data,
void *userdata) {
- MacVlan *m = userdata;
+ MacVlan *m = ASSERT_PTR(userdata);
uint32_t v;
int r;
assert(lvalue);
assert(rvalue);
assert(data);
- assert(userdata);
if (isempty(rvalue)) {
m->bc_queue_length = UINT32_MAX;
void *data,
void *userdata) {
- NetDevKind k, *kind = data;
+ NetDevKind k, *kind = ASSERT_PTR(data);
assert(filename);
assert(rvalue);
- assert(data);
k = netdev_kind_from_string(rvalue);
if (k < 0) {
void *data,
void *userdata) {
- struct hw_addr_data *hw_addr = data;
+ struct hw_addr_data *hw_addr = ASSERT_PTR(data);
assert(rvalue);
- assert(data);
if (streq(rvalue, "none")) {
*hw_addr = HW_ADDR_NONE;
union in_addr_union buffer = IN_ADDR_NULL;
NetDevLocalAddressType type;
- Tunnel *t = userdata;
+ Tunnel *t = ASSERT_PTR(userdata);
int r, f;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(userdata);
if (isempty(rvalue) || streq(rvalue, "any"))
return unset_local(t);
void *userdata) {
union in_addr_union buffer;
- Tunnel *t = userdata;
+ Tunnel *t = ASSERT_PTR(userdata);
int r, f;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(userdata);
if (isempty(rvalue) || streq(rvalue, "any"))
return unset_remote(t);
void *data,
void *userdata) {
- Set **s = data;
+ Set **s = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*s = set_free(*s);
void *data,
void *userdata) {
- VxLan *v = userdata;
+ VxLan *v = ASSERT_PTR(userdata);
union in_addr_union *addr = data, buffer;
int *family, f, r;
assert(lvalue);
assert(rvalue);
assert(data);
- assert(userdata);
if (streq(lvalue, "Local"))
family = &v->local_family;
}
static int on_resolve_retry(sd_event_source *s, usec_t usec, void *userdata) {
- WireguardPeer *peer = userdata;
+ WireguardPeer *peer = ASSERT_PTR(userdata);
NetDev *netdev;
- assert(peer);
assert(peer->wireguard);
netdev = NETDEV(peer->wireguard);
const struct addrinfo *ai,
void *userdata) {
- WireguardPeer *peer = userdata;
+ WireguardPeer *peer = ASSERT_PTR(userdata);
NetDev *netdev;
int r;
- assert(peer);
assert(peer->wireguard);
netdev = NETDEV(peer->wireguard);
void *data,
void *userdata) {
- uint16_t *s = data;
+ uint16_t *s = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(data);
if (isempty(rvalue) || streq(rvalue, "auto")) {
*s = 0;
void *data,
void *userdata) {
- NetDev *netdev = userdata;
- uint32_t *table = data;
+ NetDev *netdev = ASSERT_PTR(userdata);
+ uint32_t *table = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
- assert(userdata);
if (isempty(rvalue) || parse_boolean(rvalue) == 0) {
*table = 0; /* Disabled. */
void *userdata) {
_cleanup_(wireguard_peer_free_or_set_invalidp) WireguardPeer *peer = NULL;
- NetDev *netdev = userdata;
+ NetDev *netdev = ASSERT_PTR(userdata);
Wireguard *w;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(netdev);
assert(netdev->manager);
w = WIREGUARD(netdev);
void *data,
void *userdata) {
- uint32_t *priority = data;
+ uint32_t *priority = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*priority = 0;
void *data,
void *userdata) {
- WLan *w = userdata;
+ WLan *w = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(userdata);
if (isempty(rvalue)) {
w->wiphy_name = mfree(w->wiphy_name);
void *data,
void *userdata) {
- enum nl80211_iftype t, *iftype = data;
+ enum nl80211_iftype t, *iftype = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*iftype = NL80211_IFTYPE_UNSPECIFIED;
sd_id128_t secret_key = SD_ID128_NULL;
union in_addr_union buffer = {};
AddressGenerationType type;
- Set **tokens = data;
+ Set **tokens = ASSERT_PTR(data);
const char *addr;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*tokens = set_free(*tokens);
void *data,
void *userdata) {
- uint32_t *br = data;
+ uint32_t *br = ASSERT_PTR(data);
uint64_t sz;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = parse_size(rvalue, 1000, &sz);
if (r < 0) {
void *data,
void *userdata) {
- nsec_t val, *tq = data;
+ nsec_t val, *tq = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = parse_nsec(rvalue, &val);
if (r < 0) {
void *data,
void *userdata) {
- usec_t usec, *restart_usec = data;
+ usec_t usec, *restart_usec = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = parse_sec(rvalue, &usec);
if (r < 0) {
void *data,
void *userdata) {
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
uint32_t mask = ltype;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(userdata);
assert(mask != 0);
if (isempty(rvalue)) {
}
static int get_product_uuid_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
const sd_bus_error *e;
const void *a;
size_t sz;
int r;
assert(m);
- assert(manager);
/* To avoid calling GetProductUUID() bus method so frequently, set the flag below
* even if the method fails. */
void *data,
void *userdata) {
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
uint32_t rt;
int r;
assert(lvalue);
assert(IN_SET(ltype, AF_INET, AF_INET6));
assert(rvalue);
- assert(userdata);
r = safe_atou32(rvalue, &rt);
if (r < 0) {
void *data,
void *userdata) {
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
uint32_t iaid;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(network);
assert(IN_SET(ltype, AF_INET, AF_INET6));
r = safe_atou32(rvalue, &iaid);
void *data,
void *userdata) {
- char ***l = data;
+ char ***l = ASSERT_PTR(data);
int r;
- assert(l);
assert(lvalue);
assert(rvalue);
assert(IN_SET(ltype, AF_INET, AF_INET6));
_unused_ _cleanup_(sd_dhcp6_option_unrefp) sd_dhcp6_option *old6 = NULL;
uint32_t uint32_data, enterprise_identifier = 0;
_cleanup_free_ char *word = NULL, *q = NULL;
- OrderedHashmap **options = data;
+ OrderedHashmap **options = ASSERT_PTR(data);
uint16_t u16, uint16_data;
union in_addr_union addr;
DHCPOptionDataType type;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*options = ordered_hashmap_free(*options);
void *userdata) {
_cleanup_free_ char *type_string = NULL;
- const char *p = rvalue;
+ const char *p = ASSERT_PTR(rvalue);
bool force = ltype;
- DUID *duid = data;
+ DUID *duid = ASSERT_PTR(data);
DUIDType type;
int r;
assert(filename);
assert(lvalue);
- assert(rvalue);
- assert(duid);
if (!force && duid->set)
return 0;
void *data,
void *userdata) {
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
int r;
- assert(manager);
-
/* For backward compatibility. Setting both DHCPv4 and DHCPv6 DUID if they are not specified explicitly. */
r = config_parse_duid_type(unit, filename, line, section, section_line, lvalue, false, rvalue, &manager->dhcp_duid, manager);
void *data,
void *userdata) {
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
int r;
- assert(network);
-
r = config_parse_duid_type(unit, filename, line, section, section_line, lvalue, true, rvalue, &network->dhcp_duid, network);
if (r < 0)
return r;
uint8_t raw_data[MAX_DUID_LEN];
unsigned count = 0;
bool force = ltype;
- DUID *duid = data;
+ DUID *duid = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(duid);
if (!force && duid->set)
return 0;
void *data,
void *userdata) {
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
int r;
- assert(manager);
-
/* For backward compatibility. Setting both DHCPv4 and DHCPv6 DUID if they are not specified explicitly. */
r = config_parse_duid_rawdata(unit, filename, line, section, section_line, lvalue, false, rvalue, &manager->dhcp_duid, manager);
void *data,
void *userdata) {
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
int r;
- assert(network);
-
r = config_parse_duid_rawdata(unit, filename, line, section, section_line, lvalue, true, rvalue, &network->dhcp_duid, network);
if (r < 0)
return r;
void *data,
void *userdata) {
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
bool accept_none = true;
int *index, r;
char **name;
assert(section);
assert(lvalue);
assert(rvalue);
- assert(userdata);
if (streq(section, "DHCPServer")) {
index = &network->dhcp_server_uplink_index;
void *data,
void *userdata) {
- int64_t *p = data;
+ int64_t *p = ASSERT_PTR(data);
uint64_t t;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue) || streq(rvalue, "auto")) {
*p = -1;
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
sd_dhcp_server *s;
DHCPLease *lease;
int r;
assert(reply);
- assert(l);
s = l->dhcp_server;
if (!s)
}
void dhcp_server_callback(sd_dhcp_server *s, uint64_t event, void *data) {
- Link *l = data;
-
- assert(l);
+ Link *l = ASSERT_PTR(data);
if (event & SD_DHCP_SERVER_EVENT_LEASE_CHANGED)
(void) dhcp_server_emit_changed(l, "Leases", NULL);
void *userdata) {
_cleanup_(dhcp_static_lease_free_or_set_invalidp) DHCPStaticLease *lease = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
union in_addr_union addr;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(network);
r = lease_new_static(network, filename, section_line, &lease);
if (r < 0)
void *userdata) {
_cleanup_(dhcp_static_lease_free_or_set_invalidp) DHCPStaticLease *lease = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
struct ether_addr hwaddr;
uint8_t *c;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(network);
r = lease_new_static(network, filename, section_line, &lease);
if (r < 0)
void *data,
void *userdata) {
- NetworkDHCPServerEmitAddress *emit = data;
+ NetworkDHCPServerEmitAddress *emit = ASSERT_PTR(data);
- assert(emit);
assert(rvalue);
if (isempty(rvalue)) {
}
static int dhcp4_handler(sd_dhcp_client *client, int event, void *userdata) {
- Link *link = userdata;
+ Link *link = ASSERT_PTR(userdata);
int r;
- assert(link);
assert(link->network);
assert(link->manager);
void *data,
void *userdata) {
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint64_t a;
int r;
- assert(network);
assert(lvalue);
assert(rvalue);
void *data,
void *userdata) {
- int *tos = data;
+ int *tos = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue))
*tos = -1; /* use sd_dhcp_client's default (currently, CS6). */
void *data,
void *userdata) {
- char **label = data;
+ char **label = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*label = mfree(*label);
}
static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
- Link *link = userdata;
+ Link *link = ASSERT_PTR(userdata);
int r;
- assert(link);
assert(link->network);
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
void *data,
void *userdata) {
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
union in_addr_union u;
unsigned char prefixlen;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(userdata);
r = in_addr_prefix_from_string(rvalue, AF_INET6, &u, &prefixlen);
if (r < 0) {
}
static void on_acd(sd_ipv4acd *acd, int event, void *userdata) {
- Address *address = userdata;
+ Address *address = ASSERT_PTR(userdata);
Link *link;
int r;
assert(acd);
- assert(address);
assert(address->acd == acd);
assert(address->link);
assert(address->family == AF_INET);
}
static int ipv4acd_check_mac(sd_ipv4acd *acd, const struct ether_addr *mac, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
struct hw_addr_data hw_addr;
- assert(m);
assert(mac);
hw_addr = (struct hw_addr_data) {
}
static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata) {
- Link *link = userdata;
+ Link *link = ASSERT_PTR(userdata);
int r;
- assert(link);
assert(link->network);
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
}
static int ipv4ll_check_mac(sd_ipv4ll *ll, const struct ether_addr *mac, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
struct hw_addr_data hw_addr;
- assert(m);
assert(mac);
hw_addr = (struct hw_addr_data) {
void *data,
void *userdata) {
- AddressFamily *link_local = data;
+ AddressFamily *link_local = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
/* Note that this is mostly like
* config_parse_address_family(), except that it
void *userdata) {
_cleanup_free_ struct in6_addr *address = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
union in_addr_union buffer;
int r;
assert(filename);
assert(rvalue);
- assert(network);
if (isempty(rvalue)) {
network->ipv6_proxy_ndp_addresses = set_free_free(network->ipv6_proxy_ndp_addresses);
void *userdata,
sd_bus_error *error) {
- Link *link = userdata;
+ Link *link = ASSERT_PTR(userdata);
Manager *manager;
double interval_sec;
uint64_t tx, rx;
assert(bus);
assert(reply);
- assert(userdata);
manager = link->manager;
int bus_link_method_set_ntp_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_strv_free_ char **ntp = NULL;
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
static int bus_link_method_set_dns_servers_internal(sd_bus_message *message, void *userdata, sd_bus_error *error, bool extended) {
struct in_addr_full **dns;
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
size_t n;
int r;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
int bus_link_method_set_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_ordered_set_free_ OrderedSet *search_domains = NULL, *route_domains = NULL;
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
}
int bus_link_method_set_default_route(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r, b;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
}
int bus_link_method_set_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
ResolveSupport mode;
const char *llmnr;
int r;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
}
int bus_link_method_set_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
ResolveSupport mode;
const char *mdns;
int r;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
}
int bus_link_method_set_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
const char *dns_over_tls;
DnsOverTlsMode mode;
int r;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
}
int bus_link_method_set_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
const char *dnssec;
DnssecMode mode;
int r;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
int bus_link_method_set_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_set_free_free_ Set *ns = NULL;
_cleanup_strv_free_ char **ntas = NULL;
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
}
int bus_link_method_revert_ntp(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
}
int bus_link_method_revert_dns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(l);
r = verify_managed_link(l, error);
if (r < 0)
}
int bus_link_method_force_renew(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
- assert(l);
-
if (!l->network)
return sd_bus_error_setf(error, BUS_ERROR_UNMANAGED_INTERFACE,
"Interface %s is not managed by systemd-networkd",
}
int bus_link_method_renew(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
- assert(l);
-
if (!l->network)
return sd_bus_error_setf(error, BUS_ERROR_UNMANAGED_INTERFACE,
"Interface %s is not managed by systemd-networkd",
}
int bus_link_method_reconfigure(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(l);
r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
"org.freedesktop.network1.reconfigure",
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
_cleanup_free_ char *text = NULL;
- Link *link = userdata;
+ Link *link = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(link);
r = link_build_json(link, &v);
if (r < 0)
int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
unsigned c = 0;
Link *link;
assert(bus);
assert(path);
- assert(m);
assert(nodes);
l = new0(char*, hashmap_size(m->links_by_index) + 1);
int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
_cleanup_free_ char *identifier = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Link *link;
int ifindex, r;
assert(bus);
assert(path);
assert(interface);
- assert(m);
assert(found);
r = sd_bus_path_decode(path, "/org/freedesktop/network1/link", &identifier);
}
static int link_carrier_lost_handler(sd_event_source *s, uint64_t usec, void *userdata) {
- Link *link = userdata;
+ Link *link = ASSERT_PTR(userdata);
int r;
- assert(link);
-
r = link_carrier_lost_impl(link);
if (r < 0) {
log_link_warning_errno(link, r, "Failed to process carrier lost event: %m");
}
static void lldp_rx_handler(sd_lldp_rx *lldp_rx, sd_lldp_rx_event_t event, sd_lldp_neighbor *n, void *userdata) {
- Link *link = userdata;
+ Link *link = ASSERT_PTR(userdata);
int r;
- assert(link);
-
(void) link_lldp_save(link);
if (link->lldp_tx && event == SD_LLDP_RX_EVENT_ADDED) {
void *data,
void *userdata) {
- sd_lldp_multicast_mode_t m, *mode = data;
+ sd_lldp_multicast_mode_t m, *mode = ASSERT_PTR(data);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
- assert(mode);
if (isempty(rvalue)) {
*mode = _SD_LLDP_MULTICAST_MODE_INVALID;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
_cleanup_free_ char *text = NULL;
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(manager);
r = manager_build_json(manager, &v);
if (r < 0)
}
static int match_prepare_for_sleep(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int b, r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "b", &b);
if (r < 0) {
}
static int on_connected(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(message);
- assert(m);
/* Did we get a timezone or transient hostname from DHCP while D-Bus wasn't up yet? */
if (m->dynamic_hostname)
}
static int manager_dirty_handler(sd_event_source *s, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Link *link;
int r;
- assert(m);
-
if (m->dirty) {
r = manager_save(m);
if (r < 0)
}
static int signal_terminate_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
m->restarting = false;
log_debug("Terminate operation initiated.");
}
static int signal_restart_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
m->restarting = true;
log_debug("Restart operation initiated.");
}
static void ndisc_handler(sd_ndisc *nd, sd_ndisc_event_t event, sd_ndisc_router *rt, void *userdata) {
- Link *link = userdata;
+ Link *link = ASSERT_PTR(userdata);
int r;
- assert(link);
-
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
return;
void *userdata) {
_cleanup_(neighbor_free_or_set_invalidp) Neighbor *n = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
- assert(userdata);
r = neighbor_new_static(network, filename, section_line, &n);
if (r < 0)
void *userdata) {
_cleanup_(neighbor_free_or_set_invalidp) Neighbor *n = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
- assert(userdata);
r = neighbor_new_static(network, filename, section_line, &n);
if (r < 0)
int network_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Network *network;
int r;
assert(bus);
assert(path);
- assert(m);
assert(nodes);
ORDERED_HASHMAP_FOREACH(network, m->networks) {
}
int network_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Network *network;
_cleanup_free_ char *name = NULL;
int r;
assert(bus);
assert(path);
assert(interface);
- assert(m);
assert(found);
r = sd_bus_path_decode(path, "/org/freedesktop/network1/network", &name);
_cleanup_free_ char *name = NULL;
NetDevKind kind = ltype;
- Hashmap **h = data;
+ Hashmap **h = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
assert(IN_SET(kind,
NETDEV_KIND_IPOIB,
NETDEV_KIND_IPVLAN,
void *data,
void *userdata) {
- Network *n = userdata;
+ Network *n = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(n);
if (isempty(rvalue)) {
n->search_domains = ordered_set_free(n->search_domains);
void *data,
void *userdata) {
- char **tz = data;
+ char **tz = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*tz = mfree(*tz);
void *data,
void *userdata) {
- Network *n = userdata;
+ Network *n = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(n);
if (isempty(rvalue)) {
for (unsigned i = 0; i < n->n_dns; i++)
void *data,
void *userdata) {
- Set **nta = data;
+ Set **nta = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(nta);
if (isempty(rvalue)) {
*nta = set_free_free(*nta);
void *data,
void *userdata) {
- char ***l = data;
+ char ***l = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(l);
if (isempty(rvalue)) {
*l = strv_free(*l);
void *data,
void *userdata) {
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
LinkOperationalStateRange range;
bool required = true;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(network);
if (isempty(rvalue)) {
network->required_for_online = -1;
void *data,
void *userdata) {
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
int r;
int32_t group;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(network);
if (isempty(rvalue)) {
network->group = -1;
void *data,
void *userdata) {
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
usec_t usec;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(network);
if (isempty(rvalue)) {
network->ignore_carrier_loss_set = false;
void *userdata) {
_cleanup_(prefix_free_or_set_invalidp) Prefix *p = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
union in_addr_union a;
int r;
assert(section);
assert(lvalue);
assert(rvalue);
- assert(userdata);
r = prefix_new_static(network, filename, section_line, &p);
if (r < 0)
void *userdata) {
_cleanup_(prefix_free_or_set_invalidp) Prefix *p = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
- assert(userdata);
r = prefix_new_static(network, filename, section_line, &p);
if (r < 0)
void *userdata) {
_cleanup_(prefix_free_or_set_invalidp) Prefix *p = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
usec_t usec;
int r;
assert(section);
assert(lvalue);
assert(rvalue);
- assert(userdata);
r = prefix_new_static(network, filename, section_line, &p);
if (r < 0)
void *userdata) {
_cleanup_(prefix_free_or_set_invalidp) Prefix *p = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
- assert(userdata);
r = prefix_new_static(network, filename, section_line, &p);
if (r < 0)
void *userdata) {
_cleanup_(prefix_free_or_set_invalidp) Prefix *p = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
- assert(userdata);
r = prefix_new_static(network, filename, section_line, &p);
if (r < 0)
void *userdata) {
_cleanup_(route_prefix_free_or_set_invalidp) RoutePrefix *p = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
union in_addr_union a;
int r;
assert(section);
assert(lvalue);
assert(rvalue);
- assert(userdata);
r = route_prefix_new_static(network, filename, section_line, &p);
if (r < 0)
void *userdata) {
_cleanup_(route_prefix_free_or_set_invalidp) RoutePrefix *p = NULL;
- Network *network = userdata;
+ Network *network = ASSERT_PTR(userdata);
usec_t usec;
int r;
assert(section);
assert(lvalue);
assert(rvalue);
- assert(userdata);
r = route_prefix_new_static(network, filename, section_line, &p);
if (r < 0)
void *data,
void *userdata) {
- RADVPrefixDelegation val, *ra = data;
+ RADVPrefixDelegation val, *ra = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (streq(lvalue, "IPv6SendRA")) {
r = parse_boolean(rvalue);
void *data,
void *userdata) {
- usec_t usec, *lifetime = data;
+ usec_t usec, *lifetime = ASSERT_PTR(data);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*lifetime = RADV_DEFAULT_ROUTER_LIFETIME_USEC;
void *data,
void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(userdata);
if (isempty(rvalue)) {
m->route_table_names_by_number = hashmap_free(m->route_table_names_by_number);
}
static int route_expire_handler(sd_event_source *s, uint64_t usec, void *userdata) {
- Route *route = userdata;
+ Route *route = ASSERT_PTR(userdata);
Link *link;
int r;
- assert(route);
assert(route->manager || (route->link && route->link->manager));
link = route->link; /* This may be NULL. */
static int speed_meter_handler(sd_event_source *s, uint64_t usec, void *userdata) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
usec_t usec_now;
Link *link;
int r;
assert(s);
- assert(userdata);
r = sd_event_now(sd_event_source_get_event(s), CLOCK_MONOTONIC, &usec_now);
if (r < 0)
void *data,
void *userdata) {
- IPv6PrivacyExtensions s, *ipv6_privacy_extensions = data;
+ IPv6PrivacyExtensions s, *ipv6_privacy_extensions = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(ipv6_privacy_extensions);
s = ipv6_privacy_extensions_from_string(rvalue);
if (s < 0) {
void *userdata) {
_cleanup_free_ char *unescaped = NULL;
- char **url = data;
+ char **url = ASSERT_PTR(data);
ssize_t l;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(url);
if (isempty(rvalue)) {
*url = mfree(*url);
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint64_t k;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int32_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint32_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int *dest, r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
CakeCompensationMode mode;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
CakeFlowIsolationMode mode;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
CakePriorityQueueingPreset preset;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
CommonApplicationsKeptEnhanced *c;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint32_t fwmark;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
ControlledDelay *cd;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
ControlledDelay *cd;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
usec_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
ControlledDelay *cd;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
DeficitRoundRobinSchedulerClass *drr;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint64_t u;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = tclass_new_static(TCLASS_KIND_DRR, network, filename, section_line, &tclass);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
EnhancedTransmissionSelection *ets;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint8_t v, *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_ETS, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
EnhancedTransmissionSelection *ets;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_ETS, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
EnhancedTransmissionSelection *ets;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_ETS, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
FirstInFirstOut *fifo;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
FirstInFirstOut *fifo;
uint64_t u;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_BFIFO, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueingControlledDelay *fqcd;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint32_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_FQ_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueingControlledDelay *fqcd;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
usec_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_FQ_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueingControlledDelay *fqcd;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_FQ_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueingControlledDelay *fqcd;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint64_t sz;
uint32_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_FQ_CODEL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FlowQueuePIE *fq_pie;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint32_t val;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_FQ_PIE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueing *fq;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint32_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_FQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueing *fq;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint64_t sz;
uint32_t *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_FQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueing *fq;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_FQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueing *fq;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
usec_t sec;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_FQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
FairQueueing *fq;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint64_t sz;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_FQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
GenericRandomEarlyDetection *gred;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint32_t *p;
uint32_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_GRED, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
GenericRandomEarlyDetection *gred;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_GRED, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
HeavyHitterFilter *hhf;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_HHF, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
HierarchyTokenBucket *htb;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_HTB, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
HierarchyTokenBucket *htb;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_HTB, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
HierarchyTokenBucketClass *htb;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint32_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
if (r == -ENOMEM)
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
HierarchyTokenBucketClass *htb;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint64_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
if (r == -ENOMEM)
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
HierarchyTokenBucketClass *htb;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint64_t *v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
NetworkEmulator *ne;
usec_t u;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_NETEM, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
NetworkEmulator *ne;
uint32_t rate;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_NETEM, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
NetworkEmulator *ne;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_NETEM, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
ProportionalIntegralControllerEnhanced *pie;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_PIE, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint16_t n;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(ltype, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
QuickFairQueueingClass *qfq;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint32_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = tclass_new_static(TCLASS_KIND_QFQ, network, filename, section_line, &tclass);
if (r == -ENOMEM)
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
QuickFairQueueingClass *qfq;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
uint64_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = tclass_new_static(TCLASS_KIND_QFQ, network, filename, section_line, &tclass);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
StochasticFairBlue *sfb;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_SFB, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
StochasticFairnessQueueing *sfq;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_SFQ, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
TokenBucketFilter *tbf;
uint64_t k;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
TokenBucketFilter *tbf;
uint64_t k, *p;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
TokenBucketFilter *tbf;
usec_t u;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = tclass_new_static(ltype, network, filename, section_line, &tclass);
if (r == -ENOMEM)
void *userdata) {
_cleanup_(tclass_free_or_set_invalidp) TClass *tclass = NULL;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = tclass_new_static(ltype, network, filename, section_line, &tclass);
if (r == -ENOMEM)
_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
TrivialLinkEqualizer *teql;
- Network *network = data;
+ Network *network = ASSERT_PTR(data);
unsigned id;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = qdisc_new_static(QDISC_KIND_TEQL, network, filename, section_line, &qdisc);
if (r == -ENOMEM)
}
static int manager_process_link(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint16_t type;
Link *l;
const char *ifname;
int ifindex, r;
assert(rtnl);
- assert(m);
assert(mm);
r = sd_netlink_message_get_type(mm, &type);
}
static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Link *l;
int r;
- assert(m);
-
sd_network_monitor_flush(m->network_monitor);
HASHMAP_FOREACH(l, m->links_by_index) {
int tmpfs_mount_parse(CustomMount **l, size_t *n, const char *s) {
_cleanup_free_ char *path = NULL, *opts = NULL;
- const char *p = s;
+ const char *p = ASSERT_PTR(s);
CustomMount *m;
int r;
assert(l);
assert(n);
- assert(s);
r = extract_first_word(&p, &path, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
if (r < 0)
}
static int oci_console_dimension(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- unsigned *u = userdata;
+ unsigned *u = ASSERT_PTR(userdata);
uint64_t k;
- assert(u);
-
k = json_variant_unsigned(variant);
if (k == 0)
return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE),
}
static int oci_absolute_path(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- char **p = userdata;
+ char **p = ASSERT_PTR(userdata);
const char *n;
- assert(p);
-
n = json_variant_string(v);
if (!path_is_absolute(n))
}
static int oci_env(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- char ***l = userdata;
+ char ***l = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(l);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
const char *n;
static int oci_args(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
_cleanup_strv_free_ char **l = NULL;
- char ***value = userdata;
+ char ***value = ASSERT_PTR(userdata);
int r;
- assert(value);
-
r = json_variant_strv(v, &l);
if (r < 0)
return json_log(v, flags, r, "Cannot parse arguments as list of strings: %m");
}
static int oci_rlimit_value(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- rlim_t z, *value = userdata;
-
- assert(value);
+ rlim_t z, *value = ASSERT_PTR(userdata);
if (json_variant_is_negative(v))
z = RLIM_INFINITY;
static int oci_rlimits(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(s);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
struct rlimit_data {
{}
};
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
int r;
- assert(s);
-
r = json_dispatch(v, table, oci_unexpected, flags, &s->full_capabilities);
if (r < 0)
return r;
}
static int oci_oom_score_adj(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
int64_t k;
- assert(s);
-
k = json_variant_integer(v);
if (k < OOM_SCORE_ADJ_MIN || k > OOM_SCORE_ADJ_MAX)
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL),
}
static int oci_supplementary_gids(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(s);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
gid_t gid, *a;
}
static int oci_hostname(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
const char *n;
- assert(s);
-
assert_se(n = json_variant_string(v));
if (!hostname_is_valid(n, 0))
}
static int oci_mounts(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(s);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
static const JsonDispatch table[] = {
{ "destination", JSON_VARIANT_STRING, oci_absolute_path, offsetof(oci_mount_data, destination), JSON_MANDATORY },
}
static int oci_namespace_type(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- unsigned long *nsflags = userdata;
+ unsigned long *nsflags = ASSERT_PTR(userdata);
const char *n;
- assert(nsflags);
assert_se(n = json_variant_string(v));
/* We don't use namespace_flags_from_string() here, as the OCI spec uses slightly different names than the
{}
};
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(s);
-
if (json_variant_elements(v) == 0)
return 0;
}
static int oci_device_type(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- mode_t *mode = userdata;
+ mode_t *mode = ASSERT_PTR(userdata);
const char *t;
- assert(mode);
assert_se(t = json_variant_string(v));
if (STR_IN_SET(t, "c", "u"))
}
static int oci_devices(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(s);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
static const JsonDispatch table[] = {
static int oci_cgroups_path(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
_cleanup_free_ char *slice = NULL, *backwards = NULL;
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
const char *p;
int r;
- assert(s);
-
assert_se(p = json_variant_string(v));
r = cg_path_get_slice(p, &slice);
static int oci_cgroup_devices(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
_cleanup_free_ struct device_data *list = NULL;
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
size_t n_list = 0, i;
bool noop = false;
JsonVariant *e;
int r;
- assert(s);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
struct device_data data = {
}
static int oci_cgroup_memory_limit(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- uint64_t *m = userdata;
+ uint64_t *m = ASSERT_PTR(userdata);
uint64_t k;
- assert(m);
-
if (json_variant_is_negative(v)) {
*m = UINT64_MAX;
return 0;
};
static int oci_cgroup_cpu_shares(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- uint64_t *u = userdata;
+ uint64_t *u = ASSERT_PTR(userdata);
uint64_t k;
- assert(u);
-
k = json_variant_unsigned(v);
if (k < CGROUP_CPU_SHARES_MIN || k > CGROUP_CPU_SHARES_MAX)
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
}
static int oci_cgroup_cpu_quota(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- uint64_t *u = userdata;
+ uint64_t *u = ASSERT_PTR(userdata);
uint64_t k;
- assert(u);
-
k = json_variant_unsigned(v);
if (k <= 0 || k >= UINT64_MAX)
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
}
static int oci_cgroup_cpu_cpus(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- struct cpu_data *data = userdata;
+ struct cpu_data *data = ASSERT_PTR(userdata);
CPUSet set;
const char *n;
int r;
- assert(data);
-
assert_se(n = json_variant_string(v));
r = parse_cpu_set(n, &set);
}
static int oci_cgroup_block_io_weight(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
uint64_t k;
int r;
- assert(s);
-
k = json_variant_unsigned(v);
if (k < CGROUP_BLKIO_WEIGHT_MIN || k > CGROUP_BLKIO_WEIGHT_MAX)
return json_log(v, flags, SYNTHETIC_ERRNO(ERANGE),
}
static int oci_cgroup_block_io_weight_device(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(s);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
struct device_data {
unsigned major;
}
static int oci_cgroup_block_io_throttle(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
const char *pname;
JsonVariant *e;
int r;
- assert(s);
-
pname = streq(name, "throttleReadBpsDevice") ? "IOReadBandwidthMax" :
streq(name, "throttleWriteBpsDevice") ? "IOWriteBandwidthMax" :
streq(name, "throttleReadIOPSDevice") ? "IOReadIOPSMax" :
};
_cleanup_(json_variant_unrefp) JsonVariant *k = NULL;
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
uint64_t m;
int r;
- assert(s);
-
r = json_dispatch(v, table, oci_unexpected, flags, &k);
if (r < 0)
return r;
}
static int oci_sysctl(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *w;
const char *k;
int r;
- assert(s);
-
JSON_VARIANT_OBJECT_FOREACH(k, w, v) {
const char *m;
}
static int oci_seccomp_archs(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- scmp_filter_ctx *sc = userdata;
+ scmp_filter_ctx *sc = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(sc);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
uint32_t a;
};
static int oci_seccomp_action(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- uint32_t *action = userdata;
+ uint32_t *action = ASSERT_PTR(userdata);
int r;
- assert(action);
-
r = oci_seccomp_action_from_string(json_variant_string(v), action);
if (r < 0)
return json_log(v, flags, r, "Unknown system call action '%s': %m", json_variant_string(v));
}
static int oci_seccomp_op(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- enum scmp_compare *op = userdata;
+ enum scmp_compare *op = ASSERT_PTR(userdata);
int r;
- assert(op);
-
r = oci_seccomp_compare_from_string(json_variant_string(v), op);
if (r < 0)
return json_log(v, flags, r, "Unknown seccomp operator '%s': %m", json_variant_string(v));
}
static int oci_seccomp_args(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- struct syscall_rule *rule = userdata;
+ struct syscall_rule *rule = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(rule);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
static const struct JsonDispatch table[] = {
{ "index", JSON_VARIANT_UNSIGNED, json_dispatch_uint32, offsetof(struct scmp_arg_cmp, arg), JSON_MANDATORY },
}
static int oci_seccomp_syscalls(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- scmp_filter_ctx *sc = userdata;
+ scmp_filter_ctx *sc = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(sc);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
static const JsonDispatch table[] = {
{ "names", JSON_VARIANT_ARRAY, json_dispatch_strv, offsetof(struct syscall_rule, names), JSON_MANDATORY },
};
_cleanup_(seccomp_releasep) scmp_filter_ctx sc = NULL;
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *def;
uint32_t d;
int r;
- assert(s);
-
def = json_variant_by_key(v, "defaultAction");
if (!def)
return json_log(v, flags, SYNTHETIC_ERRNO(EINVAL), "defaultAction element missing.");
}
static int oci_masked_paths(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *e;
- assert(s);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
_cleanup_free_ char *destination = NULL;
CustomMount *m;
}
static int oci_readonly_paths(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *e;
- assert(s);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
_cleanup_free_ char *source = NULL, *destination = NULL;
CustomMount *m;
}
static int oci_hooks_array(const char *name, JsonVariant *v, JsonDispatchFlags flags, void *userdata) {
- Settings *s = userdata;
+ Settings *s = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
- assert(s);
-
JSON_VARIANT_ARRAY_FOREACH(e, v) {
static const JsonDispatch table[] = {
void *data,
void *userdata) {
- Settings *settings = data;
+ Settings *settings = ASSERT_PTR(data);
int oa, r;
assert(rvalue);
- assert(settings);
if (isempty(rvalue)) {
settings->oom_score_adjust_set = false;
void *data,
void *userdata) {
- Settings *settings = data;
+ Settings *settings = ASSERT_PTR(data);
assert(rvalue);
- assert(settings);
return parse_cpu_set_extend(rvalue, &settings->cpu_set, true, unit, filename, line, lvalue);
}
void *data,
void *userdata) {
- Settings *settings = data;
+ Settings *settings = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(settings);
r = parse_link_journal(rvalue, &settings->link_journal, &settings->link_journal_try);
if (r < 0)
void *data,
void *userdata) {
- UserNamespaceOwnership *ownership = data;
+ UserNamespaceOwnership *ownership = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(ownership);
/* Compatibility support for UserNamespaceChown=, whose job has been taken over by UserNamespaceOwnership= */
void *data,
void *userdata) {
- char ***bind_user = data;
+ char ***bind_user = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(bind_user);
if (isempty(rvalue)) {
*bind_user = strv_free(*bind_user);
};
static int on_address_change(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
- struct ExposeArgs *args = userdata;
+ struct ExposeArgs *args = ASSERT_PTR(userdata);
assert(rtnl);
assert(m);
- assert(args);
(void) expose_port_execute(rtnl, &args->fw_ctx, arg_expose_ports, AF_INET, &args->address4);
(void) expose_port_execute(rtnl, &args->fw_ctx, arg_expose_ports, AF_INET6, &args->address6);
}
static int json_dispatch_ifindex(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- int *ifi = userdata;
+ int *ifi = ASSERT_PTR(userdata);
int64_t t;
assert(variant);
- assert(ifi);
if (!json_variant_is_integer(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
}
static int json_dispatch_family(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- int *family = userdata;
+ int *family = ASSERT_PTR(userdata);
int64_t t;
assert(variant);
- assert(family);
if (!json_variant_is_integer(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
} AddressParameters;
static int json_dispatch_address(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- AddressParameters *p = userdata;
+ AddressParameters *p = ASSERT_PTR(userdata);
union in_addr_union buf = {};
JsonVariant *i;
size_t n, k = 0;
assert(variant);
- assert(p);
if (!json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
static int bus_method_dump_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *dump = NULL;
_cleanup_close_ int fd = -1;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(m);
r = manager_get_dump_string(m, &dump);
if (r < 0)
JsonVariant *parameters,
VarlinkMethodFlags flags,
void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uid_t uid;
int r;
- assert(m);
-
r = varlink_get_peer_uid(link, &uid);
if (r < 0)
return log_error_errno(r, "Failed to get varlink peer uid: %m");
const char *error_id,
VarlinkReplyFlags flags,
void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uid_t uid;
int r;
- assert(m);
-
if (error_id) {
r = -EIO;
log_debug("Error getting ManagedOOM cgroups: %s", error_id);
}
static int monitor_swap_contexts_handler(sd_event_source *s, uint64_t usec, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
usec_t usec_now;
int r;
assert(s);
- assert(userdata);
/* Reset timer */
r = sd_event_now(sd_event_source_get_event(s), CLOCK_MONOTONIC, &usec_now);
_unused_ _cleanup_(clear_candidate_hashmapp) Manager *clear_candidates = userdata;
_cleanup_set_free_ Set *targets = NULL;
bool in_post_action_delay = false;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
usec_t usec_now;
int r;
assert(s);
- assert(userdata);
/* Reset timer */
r = sd_event_now(sd_event_source_get_event(s), CLOCK_MONOTONIC, &usec_now);
void *data,
void *userdata) {
- sd_id128_t *type_uuid = data;
+ sd_id128_t *type_uuid = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(type_uuid);
r = gpt_partition_type_uuid_from_string(rvalue, type_uuid);
if (r < 0)
void *userdata) {
_cleanup_free_ char *resolved = NULL;
- char **label = data;
+ char **label = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(label);
/* Nota bene: the empty label is a totally valid one. Let's hence not follow our usual rule of
* assigning the empty string to reset to default here, but really accept it as label to set. */
void *data,
void *userdata) {
- char **fstype = data;
+ char **fstype = ASSERT_PTR(data);
assert(rvalue);
- assert(data);
if (!filename_is_valid(rvalue))
return log_syntax(unit, LOG_ERR, filename, line, 0,
_cleanup_free_ char *source = NULL, *buffer = NULL, *resolved_source = NULL, *resolved_target = NULL;
const char *p = rvalue, *target;
- Partition *partition = data;
+ Partition *partition = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(partition);
r = extract_first_word(&p, &source, ":", EXTRACT_CUNESCAPE|EXTRACT_DONT_COALESCE_SEPARATORS);
if (r < 0)
void *userdata) {
_cleanup_free_ char *d = NULL;
- Partition *partition = data;
+ Partition *partition = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(partition);
if (isempty(rvalue)) {
partition->copy_blocks_path = mfree(partition->copy_blocks_path);
void *data,
void *userdata) {
- Partition *partition = data;
- const char *p = rvalue;
+ Partition *partition = ASSERT_PTR(data);
+ const char *p = ASSERT_PTR(rvalue);
int r;
- assert(rvalue);
- assert(partition);
-
for (;;) {
_cleanup_free_ char *word = NULL, *d = NULL;
void *data,
void *userdata) {
- uint64_t *gpt_flags = data;
+ uint64_t *gpt_flags = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(gpt_flags);
r = safe_atou64(rvalue, gpt_flags);
if (r < 0) {
static int method_get_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *name;
Image *image;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
static int method_list_images(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_hashmap_free_ Hashmap *images = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Image *image;
int r;
assert(message);
- assert(m);
images = hashmap_new(&image_hash_ops);
if (!images)
_cleanup_strv_free_ char **extension_images = NULL;
PortableChange *changes = NULL;
PortableFlags flags = 0;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
size_t n_changes = 0;
const char *name_or_path;
int r;
assert(message);
- assert(m);
/* Note that we do not redirect detaching to the image object here, because we want to allow that users can
* detach already deleted images too, in case the user already deleted an image before properly detaching
sd_bus_error *error) {
_cleanup_strv_free_ char **extension_images = NULL;
- Image *image = userdata;
+ Image *image = ASSERT_PTR(userdata);
PortableState state;
int r;
assert(message);
- assert(image);
if (sd_bus_message_is_method_call(message, NULL, "GetStateWithExtensions")) {
uint64_t input_flags = 0;
_cleanup_strv_free_ char **extension_images = NULL;
PortableChange *changes = NULL;
- Image *image = userdata;
- Manager *m = image->userdata;
+ Image *image = ASSERT_PTR(userdata);
+ Manager *m = ASSERT_PTR(image->userdata);
PortableFlags flags = 0;
size_t n_changes = 0;
int r;
assert(message);
- assert(image);
- assert(m);
if (sd_bus_message_is_method_call(message, NULL, "DetachWithExtensions")) {
r = sd_bus_message_read_strv(message, &extension_images);
}
static int image_cache_flush(sd_event_source *s, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(s);
- assert(m);
hashmap_clear(m->image_cache);
return 0;
static int operation_done(sd_event_source *s, const siginfo_t *si, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- Operation *o = userdata;
+ Operation *o = ASSERT_PTR(userdata);
int r;
- assert(o);
assert(si);
log_debug("Operating " PID_FMT " is now complete with code=%s status=%i",
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
uint64_t n_current_transactions, n_total_transactions,
cache_size, n_cache_hit, n_cache_miss,
n_dnssec_secure, n_dnssec_insecure, n_dnssec_bogus, n_dnssec_indeterminate;
int r, dnssec_supported;
- assert(bus);
-
r = bus_get_property_trivial(bus, bus_resolve_mgr, "DNSSECSupported", &error, 'b', &dnssec_supported);
if (r < 0)
return log_error_errno(r, "Failed to get DNSSEC supported state: %s", bus_error_message(&error, r));
}
static int map_link_dns_servers_internal(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata, bool extended) {
- char ***l = userdata;
+ char ***l = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(member);
assert(m);
- assert(l);
r = sd_bus_message_enter_container(m, 'a', extended ? "(iayqs)" : "(iay)");
if (r < 0)
}
static int map_link_domains(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
- char ***l = userdata;
+ char ***l = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(member);
assert(m);
- assert(l);
r = sd_bus_message_enter_container(m, 'a', "(sb)");
if (r < 0)
}
static int map_global_dns_servers_internal(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata, bool extended) {
- char ***l = userdata;
+ char ***l = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(member);
assert(m);
- assert(l);
r = sd_bus_message_enter_container(m, 'a', extended ? "(iiayqs)" : "(iiay)");
if (r < 0)
}
static int map_global_domains(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
- char ***l = userdata;
+ char ***l = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(member);
assert(m);
- assert(l);
r = sd_bus_message_enter_container(m, 'a', "(isb)");
if (r < 0)
static int verb_dns(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
static int verb_domain(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
static int verb_default_route(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r, b;
- assert(bus);
-
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
static int verb_llmnr(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
static int verb_mdns(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
static int verb_dns_over_tls(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
static int verb_dnssec(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
static int verb_nta(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
bool clear;
- assert(bus);
-
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
static int verb_revert_link(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
if (argc >= 2) {
r = ifname_mangle(argv[1]);
if (r < 0)
}
static int verb_log_level(int argc, char *argv[], void *userdata) {
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
- assert(bus);
assert(IN_SET(argc, 1, 2));
return verb_log_control_common(bus, "org.freedesktop.resolve1", argv[0], argc == 2 ? argv[1] : NULL);
BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_resolve_support, resolve_support, ResolveSupport);
static int query_on_bus_track(sd_bus_track *t, void *userdata) {
- DnsQuery *q = userdata;
+ DnsQuery *q = ASSERT_PTR(userdata);
assert(t);
- assert(q);
if (!DNS_TRANSACTION_IS_LIVE(q->state))
return 0;
static int bus_method_resolve_hostname(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(dns_question_unrefp) DnsQuestion *question_idna = NULL, *question_utf8 = NULL;
_cleanup_(dns_query_freep) DnsQuery *q = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *hostname;
int family, ifindex;
uint64_t flags;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(int) == sizeof(int32_t));
static int bus_method_resolve_address(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
_cleanup_(dns_query_freep) DnsQuery *q = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
union in_addr_union a;
int family, ifindex;
uint64_t flags;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(int) == sizeof(int32_t));
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
_cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
_cleanup_(dns_query_freep) DnsQuery *q = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint16_t class, type;
const char *name;
int r, ifindex;
uint64_t flags;
assert(message);
- assert(m);
assert_cc(sizeof(int) == sizeof(int32_t));
_cleanup_(dns_question_unrefp) DnsQuestion *question_idna = NULL, *question_utf8 = NULL;
_cleanup_(dns_query_freep) DnsQuery *q = NULL;
const char *name, *type, *domain;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int family, ifindex;
uint64_t flags;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(int) == sizeof(int32_t));
sd_bus_error *error,
bool extended) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Link *l;
int r;
assert(reply);
- assert(m);
r = sd_bus_message_open_container(reply, 'a', extended ? "(iiayqs)" : "(iiay)");
if (r < 0)
sd_bus_error *error,
bool extended) {
- DnsServer **f = userdata;
+ DnsServer **f = ASSERT_PTR(userdata);
int r;
assert(reply);
- assert(f);
r = sd_bus_message_open_container(reply, 'a', extended ? "(iiayqs)" : "(iiay)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Link *l;
int r;
assert(reply);
- assert(m);
r = sd_bus_message_open_container(reply, 'a', "(isb)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(reply);
- assert(m);
return sd_bus_message_append(reply, "(tt)",
(uint64_t) hashmap_size(m->dns_transactions),
sd_bus_error *error) {
uint64_t size = 0, hit = 0, miss = 0;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(reply);
- assert(m);
LIST_FOREACH(scopes, s, m->dns_scopes) {
size += dns_cache_size(&s->cache);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(reply);
- assert(m);
return sd_bus_message_append(reply, "(tttt)",
(uint64_t) m->n_dnssec_verdict[DNSSEC_SECURE],
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
const char *domain;
int r;
assert(reply);
- assert(m);
r = sd_bus_message_open_container(reply, 'a', "s");
if (r < 0)
}
static int bus_method_reset_statistics(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(message);
- assert(m);
bus_client_log(message, "statistics reset");
static int bus_method_get_link(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r, ifindex;
Link *l;
assert(message);
- assert(m);
r = bus_message_read_ifindex(message, error, &ifindex);
if (r < 0)
}
static int bus_method_flush_caches(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(message);
- assert(m);
bus_client_log(message, "cache flush");
}
static int bus_method_reset_server_features(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(message);
- assert(m);
bus_client_log(message, "server feature reset");
}
static int dnssd_service_on_bus_track(sd_bus_track *t, void *userdata) {
- DnssdService *s = userdata;
+ DnssdService *s = ASSERT_PTR(userdata);
assert(t);
- assert(s);
log_debug("Client of active request vanished, destroying DNS-SD service.");
dnssd_service_free(s);
const char *name, *name_template, *type;
_cleanup_free_ char *path = NULL;
DnssdService *s = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uid_t euid;
int r;
assert(message);
- assert(m);
if (m->mdns_support != RESOLVE_SUPPORT_YES)
return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for MulticastDNS is disabled");
}
static int bus_method_unregister_service(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(message);
- assert(m);
return call_dnssd_method(m, message, bus_dnssd_method_unregister, error);
}
};
static int match_prepare_for_sleep(sd_bus_message *message, void *userdata, sd_bus_error *ret_error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int b, r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "b", &b);
if (r < 0) {
void *data,
void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(m);
if (isempty(rvalue))
/* Empty assignment means clear the list */
void *data,
void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(m);
if (isempty(rvalue))
/* Empty assignment means clear the list */
{ 'W', specifier_os_variant_id, NULL },
{}
};
- DnssdService *s = userdata;
+ DnssdService *s = ASSERT_PTR(userdata);
_cleanup_free_ char *name = NULL;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(s);
if (isempty(rvalue)) {
s->name_template = mfree(s->name_template);
void *data,
void *userdata) {
- DnssdService *s = userdata;
+ DnssdService *s = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(s);
if (isempty(rvalue)) {
s->type = mfree(s->type);
void *userdata) {
_cleanup_(dnssd_txtdata_freep) DnssdTxtData *txt_data = NULL;
- DnssdService *s = userdata;
+ DnssdService *s = ASSERT_PTR(userdata);
DnsTxtItem *last = NULL;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(s);
if (isempty(rvalue)) {
/* Flush out collected items */
}
static int on_query_timeout(sd_event_source *s, usec_t usec, void *userdata) {
- DnsQuery *q = userdata;
+ DnsQuery *q = ASSERT_PTR(userdata);
assert(s);
- assert(q);
dns_query_complete(q, DNS_TRANSACTION_TIMEOUT);
return 0;
}
static int on_conflict_dispatch(sd_event_source *es, usec_t usec, void *userdata) {
- DnsScope *scope = userdata;
+ DnsScope *scope = ASSERT_PTR(userdata);
int r;
assert(es);
- assert(scope);
scope->conflict_event_source = sd_event_source_disable_unref(scope->conflict_event_source);
}
static int on_stream_timeout(sd_event_source *es, usec_t usec, void *userdata) {
- DnsStream *s = userdata;
-
- assert(s);
+ DnsStream *s = ASSERT_PTR(userdata);
return dns_stream_complete(s, ETIMEDOUT);
}
}
static int on_dns_stub_packet_extra(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- DnsStubListenerExtra *l = userdata;
-
- assert(l);
+ DnsStubListenerExtra *l = ASSERT_PTR(userdata);
return on_dns_stub_packet_internal(s, fd, revents, l->manager, l);
}
}
static int on_dns_stub_stream_extra(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- DnsStubListenerExtra *l = userdata;
+ DnsStubListenerExtra *l = ASSERT_PTR(userdata);
- assert(l);
return on_dns_stub_stream_internal(s, fd, revents, l->manager, l);
}
static int on_dns_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
- DnsTransaction *t = userdata;
+ DnsTransaction *t = ASSERT_PTR(userdata);
int r;
- assert(t);
assert(t->scope);
r = manager_recv(t->scope->manager, fd, DNS_PROTOCOL_DNS, &p);
}
static int on_transaction_timeout(sd_event_source *s, usec_t usec, void *userdata) {
- DnsTransaction *t = userdata;
+ DnsTransaction *t = ASSERT_PTR(userdata);
assert(s);
- assert(t);
if (t->initial_jitter_scheduled && !t->initial_jitter_elapsed) {
log_debug("Initial jitter phase for transaction %" PRIu16 " elapsed.", t->id);
#include "user-util.h"
int bus_dnssd_method_unregister(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- DnssdService *s = userdata;
+ DnssdService *s = ASSERT_PTR(userdata);
Manager *m;
Link *l;
int r;
assert(message);
- assert(s);
m = s->manager;
static int dnssd_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
_cleanup_free_ char *name = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
DnssdService *service;
int r;
assert(path);
assert(interface);
assert(found);
- assert(m);
r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/dnssd", &name);
if (r <= 0)
static int dnssd_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
DnssdService *service;
unsigned c = 0;
int r;
assert(bus);
assert(path);
- assert(m);
assert(nodes);
l = new0(char*, hashmap_size(m->dnssd_services) + 1);
void *userdata,
sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
assert(reply);
- assert(l);
return sd_bus_message_append(reply, "s", dns_over_tls_mode_to_string(link_get_dns_over_tls_mode(l)));
}
sd_bus_error *error,
bool extended) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
assert(reply);
- assert(l);
r = sd_bus_message_open_container(reply, 'a', extended ? "(iayqs)" : "(iay)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
assert(reply);
- assert(l);
r = sd_bus_message_open_container(reply, 'a', "(sb)");
if (r < 0)
void *userdata,
sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
assert(reply);
- assert(l);
/* Return what is configured, if there's something configured */
if (l->default_route >= 0)
void *userdata,
sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
uint64_t mask;
assert(reply);
- assert(l);
mask = (l->unicast_scope ? SD_RESOLVED_DNS : 0) |
(l->llmnr_ipv4_scope ? SD_RESOLVED_LLMNR_IPV4 : 0) |
void *userdata,
sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
const char *name;
int r;
assert(reply);
- assert(l);
r = sd_bus_message_open_container(reply, 'a', "s");
if (r < 0)
_cleanup_free_ char *j = NULL;
struct in_addr_full **dns;
bool changed = false;
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
size_t n;
int r;
assert(message);
- assert(l);
r = verify_unmanaged_link(l, error);
if (r < 0)
int bus_link_method_set_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *j = NULL;
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
bool changed = false;
int r;
assert(message);
- assert(l);
r = verify_unmanaged_link(l, error);
if (r < 0)
}
int bus_link_method_set_default_route(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r, b;
assert(message);
- assert(l);
r = verify_unmanaged_link(l, error);
if (r < 0)
}
int bus_link_method_set_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
ResolveSupport mode;
const char *llmnr;
int r;
assert(message);
- assert(l);
r = verify_unmanaged_link(l, error);
if (r < 0)
}
int bus_link_method_set_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
ResolveSupport mode;
const char *mdns;
int r;
assert(message);
- assert(l);
r = verify_unmanaged_link(l, error);
if (r < 0)
}
int bus_link_method_set_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
const char *dns_over_tls;
DnsOverTlsMode mode;
int r;
assert(message);
- assert(l);
r = verify_unmanaged_link(l, error);
if (r < 0)
}
int bus_link_method_set_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
const char *dnssec;
DnssecMode mode;
int r;
assert(message);
- assert(l);
r = verify_unmanaged_link(l, error);
if (r < 0)
_cleanup_set_free_free_ Set *ns = NULL;
_cleanup_strv_free_ char **ntas = NULL;
_cleanup_free_ char *j = NULL;
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(l);
r = verify_unmanaged_link(l, error);
if (r < 0)
}
int bus_link_method_revert(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Link *l = userdata;
+ Link *l = ASSERT_PTR(userdata);
int r;
assert(message);
- assert(l);
r = verify_unmanaged_link(l, error);
if (r < 0)
static int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
_cleanup_free_ char *e = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Link *link;
int ifindex, r;
assert(path);
assert(interface);
assert(found);
- assert(m);
r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/link", &e);
if (r <= 0)
static int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Link *link;
unsigned c = 0;
assert(bus);
assert(path);
- assert(m);
assert(nodes);
l = new0(char*, hashmap_size(m->links) + 1);
static int on_llmnr_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
DnsTransaction *t = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
DnsScope *scope;
int r;
assert(s);
assert(fd >= 0);
- assert(m);
r = manager_recv(m, fd, DNS_PROTOCOL_LLMNR, &p);
if (r <= 0)
#define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
static int manager_process_link(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
uint16_t type;
Link *l;
int ifindex, r;
assert(rtnl);
- assert(m);
assert(mm);
r = sd_netlink_message_get_type(mm, &type);
}
static int manager_process_address(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
union in_addr_union address;
uint16_t type;
int r, ifindex, family;
assert(rtnl);
assert(mm);
- assert(m);
r = sd_netlink_message_get_type(mm, &type);
if (r < 0)
}
static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
Link *l;
int r;
- assert(m);
-
sd_network_monitor_flush(m->network_monitor);
HASHMAP_FOREACH(l, m->links) {
static int manager_clock_change_listen(Manager *m);
static int on_clock_change(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
-
- assert(m);
+ Manager *m = ASSERT_PTR(userdata);
/* The clock has changed, let's flush all caches. Why that? That's because DNSSEC validation takes
* the system clock into consideration, and if the clock changes the old validations might have been
static int on_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
_cleanup_free_ char *full_hostname = NULL, *llmnr_hostname = NULL, *mdns_hostname = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
bool llmnr_hostname_changed;
int r;
- assert(m);
-
r = determine_hostnames(&full_hostname, &llmnr_hostname, &mdns_hostname);
if (r < 0) {
log_warning_errno(r, "Failed to determine the local hostname and LLMNR/mDNS names, ignoring: %m");
static int manager_sigusr1(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
_cleanup_free_ char *buffer = NULL;
_cleanup_fclose_ FILE *f = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
size_t size = 0;
Link *l;
assert(s);
assert(si);
- assert(m);
f = open_memstream_unlocked(&buffer, &size);
if (!f)
}
static int manager_sigusr2(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(s);
assert(si);
- assert(m);
manager_flush_caches(m, LOG_INFO);
}
static int manager_sigrtmin1(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(s);
assert(si);
- assert(m);
manager_reset_server_features(m);
return 0;
}
static int on_io_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- SocketGraveyard *g = userdata;
-
- assert(g);
+ SocketGraveyard *g = ASSERT_PTR(userdata);
/* An IO event happened on the graveyard fd. We don't actually care which event that is, and we don't
* read any incoming packet off the socket. We just close the fd, that's enough to not trigger the
}
static int json_dispatch_address(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- LookupParameters *p = userdata;
+ LookupParameters *p = ASSERT_PTR(userdata);
union in_addr_union buf = {};
JsonVariant *i;
size_t n, k = 0;
assert(variant);
- assert(p);
if (!json_variant_is_array(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
}
static int on_properties_changed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- RunContext *c = userdata;
+ RunContext *c = ASSERT_PTR(userdata);
assert(m);
- assert(c);
return run_context_update(c, sd_bus_message_get_path(m));
}
void *userdata, \
sd_bus_error *error) { \
\
- data_type *data = userdata; \
+ data_type *data = ASSERT_PTR(userdata); \
\
assert(bus); \
assert(reply); \
- assert(data); \
\
return sd_bus_message_append(reply, bus_type, \
get2(get1(data))); \
}
static int async_polkit_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
- AsyncPolkitQuery *q = userdata;
+ AsyncPolkitQuery *q = ASSERT_PTR(userdata);
int r;
assert(reply);
- assert(q);
assert(q->slot);
q->slot = sd_bus_slot_unref(q->slot);
#include "stdio-util.h"
static int name_owner_change_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
- sd_event *e = userdata;
+ sd_event *e = ASSERT_PTR(userdata);
assert(m);
- assert(e);
sd_bus_close(sd_bus_message_get_bus(m));
sd_event_exit(e, 0);
static int match_job_removed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
const char *path, *unit, *result;
- BusWaitForJobs *d = userdata;
+ BusWaitForJobs *d = ASSERT_PTR(userdata);
uint32_t id;
char *found;
int r;
assert(m);
- assert(d);
r = sd_bus_message_read(m, "uoss", &id, &path, &unit, &result);
if (r < 0) {
}
static int match_disconnected(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- BusWaitForUnits *d = userdata;
+ BusWaitForUnits *d = ASSERT_PTR(userdata);
assert(m);
- assert(d);
log_error("Warning! D-Bus connection terminated.");
sd_bus_error *error,
void *userdata) {
- WaitForItem *item = userdata;
+ WaitForItem *item = ASSERT_PTR(userdata);
const char *path;
uint32_t id;
int r;
- assert(item);
-
r = sd_bus_message_read(m, "(uo)", &id, &path);
if (r < 0)
return r;
}
static int on_properties_changed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- WaitForItem *item = userdata;
+ WaitForItem *item = ASSERT_PTR(userdata);
const char *interface;
int r;
- assert(item);
-
r = sd_bus_message_read(m, "s", &interface);
if (r < 0) {
log_debug_errno(r, "Failed to parse PropertiesChanged signal: %m");
}
static int on_get_all_properties(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
- WaitForItem *item = userdata;
+ WaitForItem *item = ASSERT_PTR(userdata);
const sd_bus_error *e;
int r;
- assert(item);
-
e = sd_bus_message_get_error(m);
if (e) {
BusWaitForUnits *d = item->parent;
void *data,
void *userdata) {
- size_t *sz = data;
+ size_t *sz = ASSERT_PTR(data);
uint64_t v;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = parse_size(rvalue, 1024, &v);
if (r >= 0 && (uint64_t) (size_t) v != v)
void *data,
void *userdata) {
- uint64_t *sz = data;
+ uint64_t *sz = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = parse_size(rvalue, 1000, sz);
if (r < 0)
void *data,
void *userdata) {
- uint64_t *bytes = data;
+ uint64_t *bytes = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = parse_size(rvalue, 1024, bytes);
if (r < 0)
void *data,
void *userdata) {
- uint64_t *bytes = data;
+ uint64_t *bytes = ASSERT_PTR(data);
assert(rvalue);
- assert(data);
if (streq(rvalue, "infinity")) {
*bytes = UINT64_MAX;
void *userdata) {
int k;
- bool *b = data;
+ bool *b = ASSERT_PTR(data);
bool fatal = ltype;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
k = parse_boolean(rvalue);
if (k < 0) {
void *data,
void *userdata) {
- int k, *t = data;
+ int k, *t = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
/* A tristate is pretty much a boolean, except that it can also take an empty string,
* indicating "uninitialized", much like NULL is for a pointer type. */
_cleanup_free_ char *n = NULL;
bool fatal = ltype;
- char **s = data;
+ char **s = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue))
goto finalize;
void *data,
void *userdata) {
- char ***sv = data;
+ char ***sv = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*sv = strv_free(*sv);
void *data,
void *userdata) {
- char **s = data;
+ char **s = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*s = mfree(*s);
void *userdata) {
_cleanup_strv_free_ char **names = NULL;
- char ***s = data;
+ char ***s = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*s = strv_free(*s);
void *data,
void *userdata) {
- uint16_t *s = data;
+ uint16_t *s = ASSERT_PTR(data);
uint16_t port;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*s = 0;
void *data,
void *userdata) {
- uint32_t *mtu = data;
+ uint32_t *mtu = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(mtu);
r = parse_mtu(ltype, rvalue, mtu);
if (r == -ERANGE) {
void *data,
void *userdata) {
- unsigned *permille = data;
+ unsigned *permille = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(permille);
r = parse_permille(rvalue);
if (r < 0) {
void *data,
void *userdata) {
- struct hw_addr_data a, *hwaddr = data;
+ struct hw_addr_data a, *hwaddr = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*hwaddr = HW_ADDR_NULL;
void *data,
void *userdata) {
- Set **hwaddrs = data;
+ Set **hwaddrs = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *userdata) {
_cleanup_free_ struct ether_addr *n = NULL;
- struct ether_addr **hwaddr = data;
+ struct ether_addr **hwaddr = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*hwaddr = mfree(*hwaddr);
void *data,
void *userdata) {
- Set **hwaddrs = data;
+ Set **hwaddrs = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty assignment resets the list */
void *userdata) {
/* data must be a pointer to struct in_addr or in6_addr, and the type is determined by ltype. */
- struct in_addr *ipv4 = data;
- struct in6_addr *ipv6 = data;
+ struct in_addr *ipv4 = ASSERT_PTR(data);
+ struct in6_addr *ipv6 = ASSERT_PTR(data);
union in_addr_union a;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
assert(IN_SET(ltype, AF_INET, AF_INET6));
if (isempty(rvalue)) {
#define DEFINE_CONFIG_PARSE_PTR(function, parser, type, msg) \
CONFIG_PARSER_PROTOTYPE(function) { \
- type *i = data; \
+ type *i = ASSERT_PTR(data); \
int r; \
\
assert(filename); \
assert(lvalue); \
assert(rvalue); \
- assert(data); \
\
r = parser(rvalue, i); \
if (r < 0) \
#define DEFINE_CONFIG_PARSE_ENUMV(function, name, type, invalid, msg) \
CONFIG_PARSER_PROTOTYPE(function) { \
- type **enums = data; \
+ type **enums = ASSERT_PTR(data); \
_cleanup_free_ type *xs = NULL; \
size_t i = 0; \
int r; \
assert(filename); \
assert(lvalue); \
assert(rvalue); \
- assert(data); \
\
xs = new0(type, 1); \
if (!xs) \
const char *lvalue) {
_cleanup_(cpu_set_reset) CPUSet c = {};
- const char *p = rvalue;
-
- assert(p);
+ const char *p = ASSERT_PTR(rvalue);
for (;;) {
_cleanup_free_ char *word = NULL;
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(Elf *, sym_elf_end, NULL);
static int frame_callback(Dwfl_Frame *frame, void *userdata) {
- StackContext *c = userdata;
+ StackContext *c = ASSERT_PTR(userdata);
Dwarf_Addr pc, pc_adjusted;
const char *fname = NULL, *symbol = NULL;
Dwfl_Module *module;
uint64_t module_offset = 0;
assert(frame);
- assert(c);
if (c->n_frame >= FRAMES_MAX)
return DWARF_CB_ABORT;
}
static int thread_callback(Dwfl_Thread *thread, void *userdata) {
- StackContext *c = userdata;
+ StackContext *c = ASSERT_PTR(userdata);
pid_t tid;
assert(thread);
- assert(c);
if (c->n_thread >= THREADS_MAX)
return DWARF_CB_ABORT;
static int module_callback(Dwfl_Module *mod, void **userdata, const char *name, Dwarf_Addr start, void *arg) {
_cleanup_(json_variant_unrefp) JsonVariant *id_json = NULL;
- StackContext *c = arg;
+ StackContext *c = ASSERT_PTR(arg);
size_t n_program_headers;
GElf_Addr bias;
int r;
Elf *elf;
assert(mod);
- assert(c);
if (!name)
name = "(unnamed)"; /* For logging purposes */
void *data,
void *userdata) {
- uint32_t *advertise = data;
+ uint32_t *advertise = ASSERT_PTR(data);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
/* Empty string resets the value. */
void *data,
void *userdata) {
- u32_opt *dst = data;
+ u32_opt *dst = ASSERT_PTR(data);
uint32_t k;
int r;
assert(section);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
dst->value = 0;
}
static int gather_environment_generate(int fd, void *arg) {
- char ***env = arg;
+ char ***env = ASSERT_PTR(arg);
_cleanup_fclose_ FILE *f = NULL;
_cleanup_strv_free_ char **new = NULL;
int r;
* fd is always consumed, even on error.
*/
- assert(env);
-
f = fdopen(fd, "r");
if (!f) {
safe_close(fd);
static int gather_environment_collect(int fd, void *arg) {
_cleanup_fclose_ FILE *f = NULL;
- char ***env = arg;
+ char ***env = ASSERT_PTR(arg);
int r;
/* Write out a series of env=cescape(VAR=value) assignments to fd. */
- assert(env);
-
f = fdopen(fd, "w");
if (!f) {
safe_close(fd);
static int gather_environment_consume(int fd, void *arg) {
_cleanup_fclose_ FILE *f = NULL;
- char ***env = arg;
+ char ***env = ASSERT_PTR(arg);
int r = 0;
/* Read a series of env=cescape(VAR=value) assignments from fd into env. */
- assert(env);
-
f = fdopen(fd, "r");
if (!f) {
safe_close(fd);
void *data,
void *userdata) {
- Set **prefixes = data;
+ Set **prefixes = ASSERT_PTR(data);
int r;
- assert(prefixes);
assert(IN_SET(ltype, AF_UNSPEC, AF_INET, AF_INET6));
if (isempty(rvalue)) {
}
int json_dispatch_boolean(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- bool *b = userdata;
+ bool *b = ASSERT_PTR(userdata);
assert(variant);
- assert(b);
if (!json_variant_is_boolean(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a boolean.", strna(name));
}
int json_dispatch_tristate(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- int *b = userdata;
+ int *b = ASSERT_PTR(userdata);
assert(variant);
- assert(b);
if (json_variant_is_null(variant)) {
*b = -1;
}
int json_dispatch_int64(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- int64_t *i = userdata;
+ int64_t *i = ASSERT_PTR(userdata);
assert(variant);
- assert(i);
if (!json_variant_is_integer(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
}
int json_dispatch_uint64(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- uint64_t *u = userdata;
+ uint64_t *u = ASSERT_PTR(userdata);
assert(variant);
- assert(u);
if (!json_variant_is_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an unsigned integer.", strna(name));
}
int json_dispatch_uint32(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- uint32_t *u = userdata;
+ uint32_t *u = ASSERT_PTR(userdata);
assert(variant);
- assert(u);
if (!json_variant_is_unsigned(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an unsigned integer.", strna(name));
}
int json_dispatch_int32(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- int32_t *i = userdata;
+ int32_t *i = ASSERT_PTR(userdata);
assert(variant);
- assert(i);
if (!json_variant_is_integer(variant))
return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
}
int json_dispatch_string(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- char **s = userdata;
+ char **s = ASSERT_PTR(userdata);
int r;
assert(variant);
- assert(s);
if (json_variant_is_null(variant)) {
*s = mfree(*s);
}
int json_dispatch_const_string(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- const char **s = userdata;
+ const char **s = ASSERT_PTR(userdata);
assert(variant);
- assert(s);
if (json_variant_is_null(variant)) {
*s = NULL;
int json_dispatch_strv(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
_cleanup_strv_free_ char **l = NULL;
- char ***s = userdata;
+ char ***s = ASSERT_PTR(userdata);
JsonVariant *e;
int r;
assert(variant);
- assert(s);
if (json_variant_is_null(variant)) {
*s = strv_free(*s);
};
static int generic_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
- struct state *s = userdata;
+ struct state *s = ASSERT_PTR(userdata);
int r;
- assert(s);
assert(s->n_messages > 0);
s->n_messages--;
void *data,
void *userdata) {
- const char *p = rvalue;
- char ***sv = data;
+ const char *p = ASSERT_PTR(rvalue);
+ char ***sv = ASSERT_PTR(data);
bool invert;
int r;
assert(filename);
assert(lvalue);
- assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*sv = strv_free(*sv);
void *data,
void *userdata) {
- const char *p = rvalue;
- char ***sv = data;
+ const char *p = ASSERT_PTR(rvalue);
+ char ***sv = ASSERT_PTR(data);
bool invert;
int r;
assert(filename);
assert(lvalue);
- assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*sv = strv_free(*sv);
void *data,
void *userdata) {
- const char *p = rvalue;
- char ***sv = data;
+ const char *p = ASSERT_PTR(rvalue);
+ char ***sv = ASSERT_PTR(data);
bool invert;
int r;
assert(filename);
assert(lvalue);
- assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*sv = strv_free(*sv);
void *userdata) {
_cleanup_(sr_iov_free_or_set_invalidp) SRIOV *sr_iov = NULL;
- OrderedHashmap **sr_iov_by_section = data;
+ OrderedHashmap **sr_iov_by_section = ASSERT_PTR(data);
uint32_t k;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = sr_iov_new_static(sr_iov_by_section, filename, section_line, &sr_iov);
if (r < 0)
void *userdata) {
_cleanup_(sr_iov_free_or_set_invalidp) SRIOV *sr_iov = NULL;
- OrderedHashmap **sr_iov_by_section = data;
+ OrderedHashmap **sr_iov_by_section = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = sr_iov_new_static(sr_iov_by_section, filename, section_line, &sr_iov);
if (r < 0)
void *userdata) {
_cleanup_(sr_iov_free_or_set_invalidp) SRIOV *sr_iov = NULL;
- OrderedHashmap **sr_iov_by_section = data;
+ OrderedHashmap **sr_iov_by_section = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = sr_iov_new_static(sr_iov_by_section, filename, section_line, &sr_iov);
if (r < 0)
void *userdata) {
_cleanup_(sr_iov_free_or_set_invalidp) SRIOV *sr_iov = NULL;
- OrderedHashmap **sr_iov_by_section = data;
+ OrderedHashmap **sr_iov_by_section = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = sr_iov_new_static(sr_iov_by_section, filename, section_line, &sr_iov);
if (r < 0)
void *userdata) {
_cleanup_(sr_iov_free_or_set_invalidp) SRIOV *sr_iov = NULL;
- OrderedHashmap **sr_iov_by_section = data;
+ OrderedHashmap **sr_iov_by_section = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = sr_iov_new_static(sr_iov_by_section, filename, section_line, &sr_iov);
if (r < 0)
void *data,
void *userdata) {
- uint32_t n, *num_vfs = data;
+ uint32_t n, *num_vfs = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*num_vfs = UINT32_MAX;
parse_token_f const *parser_ptr = parsers;
int af = AF_UNSPEC, proto = 0, r;
uint16_t nr = 0, mn = 0;
- const char *p = str;
+ const char *p = ASSERT_PTR(str);
- assert(str);
assert(address_family);
assert(ip_protocol);
assert(nr_ports);
void *userdata) {
_cleanup_(erase_and_freep) char *pin_used = NULL;
- struct pkcs11_acquire_certificate_callback_data *data = userdata;
+ struct pkcs11_acquire_certificate_callback_data *data = ASSERT_PTR(userdata);
CK_OBJECT_HANDLE object;
int r;
assert(slot_info);
assert(token_info);
assert(uri);
- assert(data);
/* Called for every token matching our URI */
P11KitUri *uri,
void *userdata) {
- pkcs11_crypt_device_callback_data *data = userdata;
+ pkcs11_crypt_device_callback_data *data = ASSERT_PTR(userdata);
CK_OBJECT_HANDLE object;
int r;
assert(slot_info);
assert(token_info);
assert(uri);
- assert(data);
/* Called for every token matching our URI */
}
static int on_master_event(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
- PTYForward *f = userdata;
+ PTYForward *f = ASSERT_PTR(userdata);
- assert(f);
assert(e);
assert(e == f->master_event_source);
assert(fd >= 0);
}
static int on_stdin_event(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
- PTYForward *f = userdata;
+ PTYForward *f = ASSERT_PTR(userdata);
- assert(f);
assert(e);
assert(e == f->stdin_event_source);
assert(fd >= 0);
}
static int on_stdout_event(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
- PTYForward *f = userdata;
+ PTYForward *f = ASSERT_PTR(userdata);
- assert(f);
assert(e);
assert(e == f->stdout_event_source);
assert(fd >= 0);
}
static int on_sigwinch_event(sd_event_source *e, const struct signalfd_siginfo *si, void *userdata) {
- PTYForward *f = userdata;
+ PTYForward *f = ASSERT_PTR(userdata);
struct winsize ws;
- assert(f);
assert(e);
assert(e == f->sigwinch_event_source);
}
int tpm2_parse_pcrs(const char *s, uint32_t *ret) {
- const char *p = s;
+ const char *p = ASSERT_PTR(s);
uint32_t mask = 0;
int r;
- assert(s);
-
if (isempty(s)) {
*ret = 0;
return 0;
}
static int device_monitor_handler(sd_device_monitor *monitor, sd_device *device, void *userdata) {
- struct DeviceMonitorData *data = userdata;
+ struct DeviceMonitorData *data = ASSERT_PTR(userdata);
const char *sysname;
assert(device);
- assert(data);
assert(data->sysname || data->devlink);
assert(!data->device);
}
static int json_dispatch_filename_or_path(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
- char **s = userdata;
+ char **s = ASSERT_PTR(userdata);
const char *n;
int r;
- assert(s);
-
if (json_variant_is_null(variant)) {
*s = mfree(*s);
return 0;
VarlinkReplyFlags flags,
void *userdata) {
- UserDBIterator *iterator = userdata;
+ UserDBIterator *iterator = ASSERT_PTR(userdata);
int r;
- assert(iterator);
-
if (error_id) {
log_debug("Got lookup error: %s", error_id);
}
static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Varlink *v = userdata;
+ Varlink *v = ASSERT_PTR(userdata);
assert(s);
- assert(v);
handle_revents(v, revents);
(void) varlink_process(v);
}
static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
- Varlink *v = userdata;
+ Varlink *v = ASSERT_PTR(userdata);
assert(s);
- assert(v);
(void) varlink_process(v);
return 1;
}
static int defer_callback(sd_event_source *s, void *userdata) {
- Varlink *v = userdata;
+ Varlink *v = ASSERT_PTR(userdata);
assert(s);
- assert(v);
(void) varlink_process(v);
return 1;
}
static int prepare_callback(sd_event_source *s, void *userdata) {
- Varlink *v = userdata;
+ Varlink *v = ASSERT_PTR(userdata);
int r, e;
usec_t until;
bool have_timeout;
assert(s);
- assert(v);
e = varlink_get_events(v);
if (e < 0)
}
static int quit_callback(sd_event_source *event, void *userdata) {
- Varlink *v = userdata;
+ Varlink *v = ASSERT_PTR(userdata);
assert(event);
- assert(v);
varlink_flush(v);
varlink_close(v);
}
static int connect_callback(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
- VarlinkServerSocket *ss = userdata;
+ VarlinkServerSocket *ss = ASSERT_PTR(userdata);
_cleanup_close_ int cfd = -1;
Varlink *v = NULL;
int r;
assert(source);
- assert(ss);
varlink_server_log(ss->server, "New incoming connection.");
const char *rvalue,
void *data,
void *userdata) {
- uint16_t *id = data;
+ uint16_t *id = ASSERT_PTR(data);
assert(lvalue);
assert(rvalue);
- assert(data);
if (streq(rvalue, "none")) {
*id = 0;
void *data,
void *userdata) {
- uint16_t *id = data;
+ uint16_t *id = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
r = parse_vlanid(rvalue, id);
if (r == -ERANGE) {
static int connection_enable_event_sources(Connection *c);
static int traffic_cb(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Connection *c = userdata;
+ Connection *c = ASSERT_PTR(userdata);
int r;
assert(s);
assert(fd >= 0);
- assert(c);
r = connection_shovel(c,
&c->server_fd, c->server_to_client_buffer, &c->client_fd,
}
static int connect_cb(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Connection *c = userdata;
+ Connection *c = ASSERT_PTR(userdata);
socklen_t solen;
int error, r;
assert(s);
assert(fd >= 0);
- assert(c);
solen = sizeof(error);
r = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &solen);
static int accept_cb(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_free_ char *peer = NULL;
- Context *context = userdata;
+ Context *context = ASSERT_PTR(userdata);
int nfd = -1, r;
assert(s);
assert(fd >= 0);
assert(revents & EPOLLIN);
- assert(context);
nfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
if (nfd < 0) {
#include "bus-error.h"
static int match_startup_finished(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- char **state = userdata;
+ char **state = ASSERT_PTR(userdata);
int r;
- assert(state);
-
r = bus_get_property_string(sd_bus_message_get_bus(m), bus_systemd_mgr, "SystemState", NULL, state);
sd_event_exit(sd_bus_get_event(sd_bus_message_get_bus(m)), r);
void *userdata) {
_cleanup_free_ char *resolved = NULL;
- char ***protected_versions = data;
+ char ***protected_versions = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(data);
r = specifier_printf(rvalue, NAME_MAX, specifier_table, arg_root, NULL, &resolved);
if (r < 0) {
void *userdata) {
_cleanup_free_ char *resolved = NULL;
- char **version = data;
+ char **version = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(data);
r = specifier_printf(rvalue, NAME_MAX, specifier_table, arg_root, NULL, &resolved);
if (r < 0) {
void *userdata) {
_cleanup_free_ char *resolved = NULL;
- char **current_symlink = data;
+ char **current_symlink = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(data);
r = specifier_printf(rvalue, NAME_MAX, specifier_table, arg_root, NULL, &resolved);
if (r < 0) {
void *data,
void *userdata) {
- char ***patterns = data;
+ char ***patterns = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*patterns = strv_free(*patterns);
void *userdata) {
_cleanup_free_ char *resolved = NULL;
- Resource *rr = data;
+ Resource *rr = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(data);
if (streq(rvalue, "auto")) {
rr->path_auto = true;
void *data,
void *userdata) {
- Resource *rr = data;
+ Resource *rr = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(data);
r = gpt_partition_type_uuid_from_string(rvalue, &rr->partition_type);
if (r < 0) {
void *data,
void *userdata) {
- Transfer *t = data;
+ Transfer *t = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(data);
r = sd_id128_from_string(rvalue, &t->partition_uuid);
if (r < 0) {
void *data,
void *userdata) {
- Transfer *t = data;
+ Transfer *t = ASSERT_PTR(data);
int r;
assert(rvalue);
- assert(data);
r = safe_atou64(rvalue, &t->partition_flags);
if (r < 0) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
r = bus_map_all_properties(bus,
"org.freedesktop.timedate1",
"/org/freedesktop/timedate1",
}
static int show_properties(int argc, char **argv, void *userdata) {
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
r = bus_print_all_properties(bus,
"org.freedesktop.timedate1",
"/org/freedesktop/timedate1",
}
static int map_ntp_message(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
- NTPStatusInfo *p = userdata;
+ NTPStatusInfo *p = ASSERT_PTR(userdata);
const void *d;
size_t sz;
int32_t b;
int r;
- assert(p);
-
r = sd_bus_message_enter_container(m, 'r', "uuuuittayttttbtt");
if (r < 0)
return r;
static int show_timesync_status(int argc, char **argv, void *userdata) {
_cleanup_(sd_event_unrefp) sd_event *event = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
r = show_timesync_status_once(bus);
if (r < 0)
return r;
}
static int show_timesync(int argc, char **argv, void *userdata) {
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int r;
- assert(bus);
-
r = bus_print_all_properties(bus,
"org.freedesktop.timesync1",
"/org/freedesktop/timesync1",
static int verb_ntp_servers(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *req = NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int ifindex, r;
- assert(bus);
-
ifindex = parse_ifindex_bus(bus, argv[1]);
if (ifindex < 0)
return ifindex;
static int verb_revert(int argc, char **argv, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus *bus = userdata;
+ sd_bus *bus = ASSERT_PTR(userdata);
int ifindex, r;
- assert(bus);
-
ifindex = parse_ifindex_bus(bus, argv[1]);
if (ifindex < 0)
return ifindex;
}
static int match_job_removed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
const char *path;
unsigned n = 0;
int r;
- assert(c);
assert(m);
r = sd_bus_message_read(m, "uoss", NULL, &path, NULL, NULL);
void *userdata,
sd_bus_error *error) {
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
int r;
- assert(c);
assert(bus);
assert(property);
assert(reply);
void *userdata,
sd_bus_error *error) {
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
int r;
- assert(c);
assert(bus);
assert(property);
assert(reply);
}
static int method_set_timezone(sd_bus_message *m, void *userdata, sd_bus_error *error) {
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
int interactive, r;
const char *z;
assert(m);
- assert(c);
r = sd_bus_message_read(m, "sb", &z, &interactive);
if (r < 0)
static int method_set_local_rtc(sd_bus_message *m, void *userdata, sd_bus_error *error) {
int lrtc, fix_system, interactive;
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
struct timespec ts;
int r;
assert(m);
- assert(c);
r = sd_bus_message_read(m, "bbb", &lrtc, &fix_system, &interactive);
if (r < 0)
sd_bus *bus = sd_bus_message_get_bus(m);
char buf[FORMAT_TIMESTAMP_MAX];
int relative, interactive, r;
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
int64_t utc;
struct timespec ts;
usec_t start;
struct tm tm;
assert(m);
- assert(c);
if (c->slot_job_removed)
return sd_bus_error_set(error, BUS_ERROR_AUTOMATIC_TIME_SYNC_ENABLED, "Previous request is not finished, refusing.");
static int method_set_ntp(sd_bus_message *m, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_slot_unrefp) sd_bus_slot *slot = NULL;
sd_bus *bus = sd_bus_message_get_bus(m);
- Context *c = userdata;
+ Context *c = ASSERT_PTR(userdata);
const UnitStatusInfo *selected = NULL;
int enable, interactive, q, r;
assert(m);
assert(bus);
- assert(c);
r = sd_bus_message_read(m, "bb", &enable, &interactive);
if (r < 0)
void *userdata,
sd_bus_error *error) {
- ServerName **s = userdata;
+ ServerName **s = ASSERT_PTR(userdata);
int r;
- assert(s);
assert(bus);
assert(reply);
static int method_set_runtime_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_strv_free_ char **msg_names = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
- assert(m);
assert(message);
r = sd_bus_message_read_strv(message, &msg_names);
void *userdata,
sd_bus_error *error) {
- ServerName **s = userdata;
+ ServerName **s = ASSERT_PTR(userdata);
- assert(s);
assert(bus);
assert(reply);
void *userdata,
sd_bus_error *error) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
int r;
- assert(m);
assert(reply);
r = sd_bus_message_open_container(reply, 'r', "uuuuittayttttbtt");
static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
_cleanup_free_ char *pretty = NULL;
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
- assert(m);
assert(m->current_server_name);
assert(m->current_server_address);
}
static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
- Manager *m = userdata;
-
- assert(m);
+ Manager *m = ASSERT_PTR(userdata);
return manager_send_request(m);
}
}
static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
-
- assert(m);
+ Manager *m = ASSERT_PTR(userdata);
/* rearm timer */
manager_clock_watch_setup(m);
}
static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
struct ntp_msg ntpmsg;
struct iovec iov = {
int leap_sec, r;
assert(source);
- assert(m);
if (revents & (EPOLLHUP|EPOLLERR)) {
log_warning("Server connection returned error.");
}
static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
- Manager *m = userdata;
-
- assert(m);
+ Manager *m = ASSERT_PTR(userdata);
return manager_connect(m);
}
}
static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
bool changed, connected, online;
int r;
- assert(m);
-
sd_network_monitor_flush(m->network_monitor);
/* When manager_network_read_link_servers() failed, we assume that the servers are changed. */
}
static int manager_save_time_handler(sd_event_source *s, uint64_t usec, void *userdata) {
- Manager *m = userdata;
-
- assert(m);
+ Manager *m = ASSERT_PTR(userdata);
(void) manager_save_time_and_rearm(m, USEC_INFINITY);
return 0;
void *data,
void *userdata) {
- char **s = data;
+ char **s = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (isempty(rvalue)) {
*s = mfree(*s);
void *data,
void *userdata) {
- LinkConfig *config = userdata;
+ LinkConfig *config = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(userdata);
if (isempty(rvalue)) {
config->wol_password = erase_and_free(config->wol_password);
}
static int udev_ctrl_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- UdevCtrl *uctrl = userdata;
+ UdevCtrl *uctrl = ASSERT_PTR(userdata);
_cleanup_close_ int sock = -1;
struct ucred ucred;
int r;
- assert(uctrl);
-
sock = accept4(fd, NULL, NULL, SOCK_CLOEXEC|SOCK_NONBLOCK);
if (sock < 0) {
if (ERRNO_IS_ACCEPT_AGAIN(errno))
bool *ret_truncated) {
bool truncated = false;
- const char *s = src;
+ const char *s = ASSERT_PTR(src);
int r;
assert(event);
assert(event->dev);
- assert(src);
assert(dest);
assert(size > 0);
}
static int on_spawn_io(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Spawn *spawn = userdata;
+ Spawn *spawn = ASSERT_PTR(userdata);
char buf[4096], *p;
size_t size;
ssize_t l;
int r;
- assert(spawn);
assert(fd == spawn->fd_stdout || fd == spawn->fd_stderr);
assert(!spawn->result || spawn->result_len < spawn->result_size);
}
static int on_spawn_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
- Spawn *spawn = userdata;
-
- assert(spawn);
+ Spawn *spawn = ASSERT_PTR(userdata);
DEVICE_TRACE_POINT(spawn_timeout, spawn->device, spawn->cmd);
}
static int on_spawn_timeout_warning(sd_event_source *s, uint64_t usec, void *userdata) {
- Spawn *spawn = userdata;
-
- assert(spawn);
+ Spawn *spawn = ASSERT_PTR(userdata);
log_device_warning(spawn->device, "Spawned process '%s' ["PID_FMT"] is taking longer than %s to complete",
spawn->cmd, spawn->pid,
}
static int on_spawn_sigchld(sd_event_source *s, const siginfo_t *si, void *userdata) {
- Spawn *spawn = userdata;
+ Spawn *spawn = ASSERT_PTR(userdata);
int ret = -EIO;
- assert(spawn);
-
switch (si->si_code) {
case CLD_EXITED:
if (si->si_status == 0)
}
static int device_monitor_handler(sd_device_monitor *m, sd_device *dev, void *userdata) {
- Hashmap *settle_hashmap = userdata;
+ Hashmap *settle_hashmap = ASSERT_PTR(userdata);
sd_id128_t *settle_id;
const char *syspath;
char *k;
int r;
assert(dev);
- assert(settle_hashmap);
r = sd_device_get_syspath(dev, &syspath);
if (r < 0) {
}
static int on_kill_workers_event(sd_event_source *s, uint64_t usec, void *userdata) {
- Manager *manager = userdata;
-
- assert(manager);
+ Manager *manager = ASSERT_PTR(userdata);
log_debug("Cleanup idle workers");
manager_kill_workers(manager, false);
}
static int worker_device_monitor_handler(sd_device_monitor *monitor, sd_device *dev, void *userdata) {
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
int r;
assert(dev);
- assert(manager);
r = worker_process_device(manager, dev);
if (r == EVENT_RESULT_TRY_AGAIN)
}
static int on_event_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
- Event *event = userdata;
+ Event *event = ASSERT_PTR(userdata);
- assert(event);
assert(event->worker);
kill_and_sigcont(event->worker->pid, arg_timeout_signal);
}
static int on_event_timeout_warning(sd_event_source *s, uint64_t usec, void *userdata) {
- Event *event = userdata;
+ Event *event = ASSERT_PTR(userdata);
- assert(event);
assert(event->worker);
log_device_warning(event->dev, "Worker ["PID_FMT"] processing SEQNUM=%"PRIu64" is taking a long time", event->worker->pid, event->seqnum);
}
static int on_uevent(sd_device_monitor *monitor, sd_device *dev, void *userdata) {
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
int r;
- assert(manager);
-
DEVICE_TRACE_POINT(kernel_uevent_received, dev);
device_ensure_usec_initialized(dev, NULL);
}
static int on_worker(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
- Manager *manager = userdata;
-
- assert(manager);
+ Manager *manager = ASSERT_PTR(userdata);
for (;;) {
EventResult result;
/* receive the udevd message from userspace */
static int on_ctrl_msg(UdevCtrl *uctrl, UdevCtrlMessageType type, const UdevCtrlMessageValue *value, void *userdata) {
- Manager *manager = userdata;
+ Manager *manager = ASSERT_PTR(userdata);
int r;
assert(value);
- assert(manager);
switch (type) {
case UDEV_CTRL_SET_LOG_LEVEL:
}
static int on_sigterm(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
- Manager *manager = userdata;
-
- assert(manager);
+ Manager *manager = ASSERT_PTR(userdata);
manager_exit(manager);
}
static int on_sighup(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
- Manager *manager = userdata;
-
- assert(manager);
+ Manager *manager = ASSERT_PTR(userdata);
manager_reload(manager, /* force = */ true);
}
static int on_post(sd_event_source *s, void *userdata) {
- Manager *manager = userdata;
-
- assert(manager);
+ Manager *manager = ASSERT_PTR(userdata);
if (manager->events) {
/* Try to process pending events if idle workers exist. Why is this necessary?
static int start_workers(Manager *m, bool explicit_request);
static int on_sigchld(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(s);
- assert(m);
for (;;) {
siginfo_t siginfo = {};
}
static int on_sigusr2(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
- Manager *m = userdata;
+ Manager *m = ASSERT_PTR(userdata);
assert(s);
- assert(m);
(void) start_workers(m, true); /* Workers told us there's more work, let's add one more worker as long as we are below the high watermark */
return 0;
void *data,
void *userdata) {
- bool *b = data;
+ bool *b = ASSERT_PTR(data);
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
if (streq(rvalue, "true"))
*b = true;
void *userdata) {
_cleanup_free_ char *res = NULL;
- char **out = data;
+ char **out = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
/* XDG does not allow duplicate definitions. */
if (*out) {
void *data,
void *userdata) {
- char ***ret_sv = data;
+ char ***ret_sv = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
- assert(data);
/* XDG does not allow duplicate definitions. */
if (*ret_sv) {
projects / thirdparty / systemd.git / commitdiff
