_cleanup_hashmap_free_ Hashmap *unit_ids = NULL;
_cleanup_hashmap_free_ Hashmap *unit_names = NULL;
char **patterns = strv_skip(argv, 1);
- Iterator i;
const char *k, *dst;
char **v;
int r;
if (r < 0)
return log_error_errno(r, "unit_file_build_name_map() failed: %m");
- HASHMAP_FOREACH_KEY(dst, k, unit_ids, i) {
+ HASHMAP_FOREACH_KEY(dst, k, unit_ids) {
if (!strv_fnmatch_or_empty(patterns, k, FNM_NOESCAPE) &&
!strv_fnmatch_or_empty(patterns, dst, FNM_NOESCAPE))
continue;
printf("ids: %s → %s\n", k, dst);
}
- HASHMAP_FOREACH_KEY(v, k, unit_names, i) {
+ HASHMAP_FOREACH_KEY(v, k, unit_names) {
if (!strv_fnmatch_or_empty(patterns, k, FNM_NOESCAPE) &&
!strv_fnmatch_strv_or_empty(patterns, v, FNM_NOESCAPE))
continue;
* the entries were inserted.
* It is safe to remove the current entry.
*/
-#define HASHMAP_FOREACH(e, h, i) \
- for ((i) = ITERATOR_FIRST; hashmap_iterate((h), &(i), (void**)&(e), NULL); )
-
-#define ORDERED_HASHMAP_FOREACH(e, h, i) \
- for ((i) = ITERATOR_FIRST; ordered_hashmap_iterate((h), &(i), (void**)&(e), NULL); )
-
-#define HASHMAP_FOREACH_KEY(e, k, h, i) \
- for ((i) = ITERATOR_FIRST; hashmap_iterate((h), &(i), (void**)&(e), (const void**) &(k)); )
-
-#define ORDERED_HASHMAP_FOREACH_KEY(e, k, h, i) \
- for ((i) = ITERATOR_FIRST; ordered_hashmap_iterate((h), &(i), (void**)&(e), (const void**) &(k)); )
+#define _HASHMAP_FOREACH(e, h, i) \
+ for (Iterator i = ITERATOR_FIRST; hashmap_iterate((h), &i, (void**)&(e), NULL); )
+#define HASHMAP_FOREACH(e, h) \
+ _HASHMAP_FOREACH(e, h, UNIQ_T(i, UNIQ))
+
+#define _ORDERED_HASHMAP_FOREACH(e, h, i) \
+ for (Iterator i = ITERATOR_FIRST; ordered_hashmap_iterate((h), &i, (void**)&(e), NULL); )
+#define ORDERED_HASHMAP_FOREACH(e, h) \
+ _ORDERED_HASHMAP_FOREACH(e, h, UNIQ_T(i, UNIQ))
+
+#define _HASHMAP_FOREACH_KEY(e, k, h, i) \
+ for (Iterator i = ITERATOR_FIRST; hashmap_iterate((h), &i, (void**)&(e), (const void**) &(k)); )
+#define HASHMAP_FOREACH_KEY(e, k, h) \
+ _HASHMAP_FOREACH_KEY(e, k, h, UNIQ_T(i, UNIQ))
+
+#define _ORDERED_HASHMAP_FOREACH_KEY(e, k, h, i) \
+ for (Iterator i = ITERATOR_FIRST; ordered_hashmap_iterate((h), &i, (void**)&(e), (const void**) &(k)); )
+#define ORDERED_HASHMAP_FOREACH_KEY(e, k, h) \
+ _ORDERED_HASHMAP_FOREACH_KEY(e, k, h, UNIQ_T(i, UNIQ))
DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, hashmap_free);
DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, hashmap_free_free);
int ordered_set_put_string_set(OrderedSet *s, OrderedSet *l) {
int n = 0, r;
- Iterator i;
char *p;
/* Like ordered_set_put_strv, but for an OrderedSet of strings */
- ORDERED_SET_FOREACH(p, l, i) {
+ ORDERED_SET_FOREACH(p, l) {
r = ordered_set_put_strdup(s, p);
if (r < 0)
return r;
void ordered_set_print(FILE *f, const char *field, OrderedSet *s) {
bool space = false;
- Iterator i;
char *p;
if (ordered_set_isempty(s))
fputs(field, f);
- ORDERED_SET_FOREACH(p, s, i)
+ ORDERED_SET_FOREACH(p, s)
fputs_with_space(f, p, NULL, &space);
fputc('\n', f);
int ordered_set_put_string_set(OrderedSet *s, OrderedSet *l);
void ordered_set_print(FILE *f, const char *field, OrderedSet *s);
-#define ORDERED_SET_FOREACH(e, s, i) \
- for ((i) = ITERATOR_FIRST; ordered_set_iterate((s), &(i), (void**)&(e)); )
+#define _ORDERED_SET_FOREACH(e, s, i) \
+ for (Iterator i = ITERATOR_FIRST; ordered_set_iterate((s), &i, (void**)&(e)); )
+#define ORDERED_SET_FOREACH(e, s) \
+ _ORDERED_SET_FOREACH(e, s, UNIQ_T(i, UNIQ))
DEFINE_TRIVIAL_CLEANUP_FUNC(OrderedSet*, ordered_set_free);
DEFINE_TRIVIAL_CLEANUP_FUNC(OrderedSet*, ordered_set_free_free);
int set_put_strsplit(Set *s, const char *v, const char *separators, ExtractFlags flags);
-#define SET_FOREACH(e, s, i) \
- for ((i) = ITERATOR_FIRST; set_iterate((s), &(i), (void**)&(e)); )
+#define _SET_FOREACH(e, s, i) \
+ for (Iterator i = ITERATOR_FIRST; set_iterate((s), &i, (void**)&(e)); )
+#define SET_FOREACH(e, s) \
+ _SET_FOREACH(e, s, UNIQ_T(i, UNIQ))
#define SET_FOREACH_MOVE(e, d, s) \
for (; ({ e = set_first(s); assert_se(!e || set_move_one(d, s, e) >= 0); e; }); )
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_hashmap_free_ Hashmap *names = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
- Iterator iterator;
char **i, *k;
void *v;
int r;
table_set_header(table, arg_legend);
- HASHMAP_FOREACH_KEY(v, k, names, iterator) {
+ HASHMAP_FOREACH_KEY(v, k, names) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
if (v == NAME_IS_ACTIVATABLE) {
_cleanup_(member_set_freep) Set *members = NULL;
unsigned name_width, type_width, signature_width, result_width, j, k = 0;
Member *m, **sorted = NULL;
- Iterator i;
const char *xml;
int r;
return r;
/* Second, find the current values for them */
- SET_FOREACH(m, members, i) {
+ SET_FOREACH(m, members) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
if (!streq(m->type, "property"))
sorted = newa(Member*, set_size(members));
- SET_FOREACH(m, members, i) {
+ SET_FOREACH(m, members) {
if (argv[3] && !streq(argv[3], m->interface))
continue;
}
static void display(Hashmap *a) {
- Iterator i;
Group *g;
Group **array;
signed path_columns;
array = newa(Group*, hashmap_size(a));
- HASHMAP_FOREACH(g, a, i)
+ HASHMAP_FOREACH(g, a)
if (g->n_tasks_valid || g->cpu_valid || g->memory_valid || g->io_valid)
array[n++] = g;
static int automount_serialize(Unit *u, FILE *f, FDSet *fds) {
Automount *a = AUTOMOUNT(u);
- Iterator i;
void *p;
int r;
(void) serialize_item(f, "result", automount_result_to_string(a->result));
(void) serialize_item_format(f, "dev-id", "%lu", (unsigned long) a->dev_id);
- SET_FOREACH(p, a->tokens, i)
+ SET_FOREACH(p, a->tokens)
(void) serialize_item_format(f, "token", "%u", PTR_TO_UINT(p));
- SET_FOREACH(p, a->expire_tokens, i)
+ SET_FOREACH(p, a->expire_tokens)
(void) serialize_item_format(f, "expire-token", "%u", PTR_TO_UINT(p));
r = serialize_fd(f, fds, "pipe-fd", a->pipe_fd);
static int attach_custom_bpf_progs(Unit *u, const char *path, int attach_type, Set **set, Set **set_installed) {
BPFProgram *prog;
- Iterator i;
int r;
assert(u);
set_clear(*set_installed);
- SET_FOREACH(prog, *set, i) {
+ SET_FOREACH(prog, *set) {
r = bpf_program_cgroup_attach(prog, attach_type, path, BPF_F_ALLOW_MULTI);
if (r < 0)
return log_unit_error_errno(u, r, "Attaching custom egress BPF program to cgroup %s failed: %m", path);
if (u->type == UNIT_SLICE) {
void *v;
Unit *member;
- Iterator i;
- HASHMAP_FOREACH_KEY(v, member, u->dependencies[UNIT_BEFORE], i)
+ HASHMAP_FOREACH_KEY(v, member, u->dependencies[UNIT_BEFORE])
if (UNIT_DEREF(member->slice) == u)
u->cgroup_members_mask |= unit_get_subtree_mask(member); /* note that this calls ourselves again, for the children */
}
int unit_attach_pids_to_cgroup(Unit *u, Set *pids, const char *suffix_path) {
CGroupMask delegated_mask;
const char *p;
- Iterator i;
void *pidp;
int r, q;
delegated_mask = unit_get_delegate_mask(u);
r = 0;
- SET_FOREACH(pidp, pids, i) {
+ SET_FOREACH(pidp, pids) {
pid_t pid = PTR_TO_PID(pidp);
CGroupController c;
/* Controllers can only be disabled depth-first, from the leaves of the
* hierarchy upwards to the unit in question. */
static int unit_realize_cgroup_now_disable(Unit *u, ManagerState state) {
- Iterator i;
Unit *m;
void *v;
if (u->type != UNIT_SLICE)
return 0;
- HASHMAP_FOREACH_KEY(v, m, u->dependencies[UNIT_BEFORE], i) {
+ HASHMAP_FOREACH_KEY(v, m, u->dependencies[UNIT_BEFORE]) {
CGroupMask target_mask, enable_mask, new_target_mask, new_enable_mask;
int r;
* masks. */
do {
- Iterator i;
Unit *m;
void *v;
/* Children of u likely changed when we're called */
u->cgroup_members_mask_valid = false;
- HASHMAP_FOREACH_KEY(v, m, u->dependencies[UNIT_BEFORE], i) {
+ HASHMAP_FOREACH_KEY(v, m, u->dependencies[UNIT_BEFORE]) {
/* Skip units that have a dependency on the slice but aren't actually in it. */
if (UNIT_DEREF(m->slice) != u)
continue;
* list of our children includes our own. */
if (u->type == UNIT_SLICE) {
Unit *member;
- Iterator i;
void *v;
- HASHMAP_FOREACH_KEY(v, member, u->dependencies[UNIT_BEFORE], i)
+ HASHMAP_FOREACH_KEY(v, member, u->dependencies[UNIT_BEFORE])
if (UNIT_DEREF(member->slice) == u)
unit_invalidate_cgroup_bpf(member);
}
}
void manager_invalidate_startup_units(Manager *m) {
- Iterator i;
Unit *u;
assert(m);
- SET_FOREACH(u, m->startup_units, i)
+ SET_FOREACH(u, m->startup_units)
unit_invalidate_cgroup(u, CGROUP_MASK_CPU|CGROUP_MASK_IO|CGROUP_MASK_BLKIO);
}
else if (p.user_name)
r = dynamic_user_lookup_name(m, p.user_name, &found_uid);
else {
- Iterator i;
DynamicUser *d;
- HASHMAP_FOREACH(d, m->dynamic_users, i) {
+ HASHMAP_FOREACH(d, m->dynamic_users) {
r = dynamic_user_current(d, &uid);
if (r == -EAGAIN) /* not realized yet? */
continue;
r = dynamic_user_lookup_name(m, p.group_name, (uid_t*) &found_gid);
else {
DynamicUser *d;
- Iterator i;
- HASHMAP_FOREACH(d, m->dynamic_users, i) {
+ HASHMAP_FOREACH(d, m->dynamic_users) {
uid_t uid;
r = dynamic_user_current(d, &uid);
int r;
#if HAVE_SECCOMP
- Iterator i;
void *id, *val;
#endif
return r;
#if HAVE_SECCOMP
- HASHMAP_FOREACH_KEY(val, id, c->syscall_filter, i) {
+ HASHMAP_FOREACH_KEY(val, id, c->syscall_filter) {
_cleanup_free_ char *name = NULL;
const char *e = NULL;
char *s;
int r;
#if HAVE_SECCOMP
- Iterator i;
void *id;
#endif
assert(c);
#if HAVE_SECCOMP
- SET_FOREACH(id, c->syscall_archs, i) {
+ SET_FOREACH(id, c->syscall_archs) {
const char *name;
name = seccomp_arch_to_string(PTR_TO_UINT32(id) - 1);
ExecContext *c = userdata;
_cleanup_strv_free_ char **l = NULL;
- Iterator i;
void *af;
int r;
if (r < 0)
return r;
- SET_FOREACH(af, c->address_families, i) {
+ SET_FOREACH(af, c->address_families) {
const char *name;
name = af_to_name(PTR_TO_INT(af));
ExecContext *c = userdata;
ExecSetCredential *sc;
- Iterator iterator;
int r;
assert(bus);
if (r < 0)
return r;
- HASHMAP_FOREACH(sc, c->set_credentials, iterator) {
+ HASHMAP_FOREACH(sc, c->set_credentials) {
r = sd_bus_message_open_container(reply, 'r', "say");
if (r < 0)
_cleanup_strv_free_ char **l = NULL;
Manager *m = userdata;
unsigned k = 0;
- Iterator i;
Job *j;
l = new0(char*, hashmap_size(m->jobs)+1);
if (!l)
return -ENOMEM;
- HASHMAP_FOREACH(j, m->jobs, i) {
+ HASHMAP_FOREACH(j, m->jobs) {
l[k] = job_dbus_path(j);
if (!l[k])
return -ENOMEM;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = userdata;
const char *k;
- Iterator i;
Unit *u;
int r;
if (r < 0)
return r;
- HASHMAP_FOREACH_KEY(u, k, m->units, i) {
+ HASHMAP_FOREACH_KEY(u, k, m->units) {
if (k != u->id)
continue;
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;
- Iterator i;
Job *j;
int r;
if (r < 0)
return r;
- HASHMAP_FOREACH(j, m->jobs, i) {
+ HASHMAP_FOREACH(j, m->jobs) {
_cleanup_free_ char *unit_path = NULL, *job_path = NULL;
job_path = job_dbus_path(j);
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = userdata;
DynamicUser *d;
- Iterator i;
int r;
assert(message);
if (r < 0)
return r;
- HASHMAP_FOREACH(d, m->dynamic_users, i) {
+ HASHMAP_FOREACH(d, m->dynamic_users) {
uid_t uid;
r = dynamic_user_current(d, &uid);
Manager *m = userdata;
UnitFileList *item;
Hashmap *h;
- Iterator i;
int r;
assert(message);
if (r < 0)
goto fail;
- HASHMAP_FOREACH(item, h, i) {
+ HASHMAP_FOREACH(item, h) {
r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
if (r < 0)
const ExitStatusSet *status_set = userdata;
unsigned n;
- Iterator i;
int r;
assert(bus);
if (r < 0)
return r;
- BITMAP_FOREACH(n, &status_set->status, i) {
+ BITMAP_FOREACH(n, &status_set->status) {
assert(n < 256);
r = sd_bus_message_append_basic(reply, 'i', &n);
if (r < 0)
return r;
- BITMAP_FOREACH(n, &status_set->signal, i) {
+ BITMAP_FOREACH(n, &status_set->signal) {
const char *str;
str = signal_to_string(n);
sd_bus_error *error) {
Unit *u = userdata;
- Iterator i;
const char *t;
int r;
if (r < 0)
return r;
- SET_FOREACH(t, u->aliases, i) {
+ SET_FOREACH(t, u->aliases) {
r = sd_bus_message_append(reply, "s", t);
if (r < 0)
return r;
sd_bus_error *error) {
Hashmap **h = userdata;
- Iterator j;
Unit *u;
void *v;
int r;
if (r < 0)
return r;
- HASHMAP_FOREACH_KEY(v, u, *h, j) {
+ HASHMAP_FOREACH_KEY(v, u, *h) {
r = sd_bus_message_append(reply, "s", u->id);
if (r < 0)
return r;
Hashmap **h = userdata;
const char *p;
- Iterator j;
void *v;
int r;
if (r < 0)
return r;
- HASHMAP_FOREACH_KEY(v, p, *h, j) {
+ HASHMAP_FOREACH_KEY(v, p, *h) {
r = sd_bus_message_append(reply, "s", p);
if (r < 0)
return r;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_free_ char *job_path = NULL, *unit_path = NULL;
_cleanup_set_free_ Set *affected = NULL;
- Iterator i;
Job *j, *a;
int r;
if (r < 0)
return r;
- SET_FOREACH(a, affected, i) {
+ SET_FOREACH(a, affected) {
if (a->id == j->id)
continue;
_cleanup_strv_free_ char **l = NULL;
Manager *m = userdata;
unsigned k = 0;
- Iterator i;
Unit *u;
l = new0(char*, hashmap_size(m->units)+1);
if (!l)
return -ENOMEM;
- HASHMAP_FOREACH(u, m->units, i) {
+ HASHMAP_FOREACH(u, m->units) {
l[k] = unit_dbus_path(u);
if (!l[k])
return -ENOMEM;
}
static int bus_setup_api(Manager *m, sd_bus *bus) {
- Iterator i;
char *name;
Unit *u;
int r;
if (r < 0)
return r;
- HASHMAP_FOREACH_KEY(u, name, m->watch_bus, i) {
+ HASHMAP_FOREACH_KEY(u, name, m->watch_bus) {
r = unit_install_bus_match(u, bus, name);
if (r < 0)
log_error_errno(r, "Failed to subscribe to NameOwnerChanged signal for '%s': %m", name);
}
static void destroy_bus(Manager *m, sd_bus **bus) {
- Iterator i;
Unit *u;
Job *j;
return;
/* Make sure all bus slots watching names are released. */
- HASHMAP_FOREACH(u, m->watch_bus, i) {
+ HASHMAP_FOREACH(u, m->watch_bus) {
if (u->match_bus_slot && sd_bus_slot_get_bus(u->match_bus_slot) == *bus)
u->match_bus_slot = sd_bus_slot_unref(u->match_bus_slot);
if (u->get_name_owner_slot && sd_bus_slot_get_bus(u->get_name_owner_slot) == *bus)
if (m->subscribed && sd_bus_track_get_bus(m->subscribed) == *bus)
m->subscribed = sd_bus_track_unref(m->subscribed);
- HASHMAP_FOREACH(j, m->jobs, i)
+ HASHMAP_FOREACH(j, m->jobs)
if (j->bus_track && sd_bus_track_get_bus(j->bus_track) == *bus)
j->bus_track = sd_bus_track_unref(j->bus_track);
- HASHMAP_FOREACH(u, m->units, i) {
+ HASHMAP_FOREACH(u, m->units) {
if (u->bus_track && sd_bus_track_get_bus(u->bus_track) == *bus)
u->bus_track = sd_bus_track_unref(u->bus_track);
}
int bus_fdset_add_all(Manager *m, FDSet *fds) {
- Iterator i;
sd_bus *b;
int fd;
}
}
- SET_FOREACH(b, m->private_buses, i) {
+ SET_FOREACH(b, m->private_buses) {
fd = sd_bus_get_fd(b);
if (fd >= 0) {
fd = fdset_put_dup(fds, fd);
int (*send_message)(sd_bus *bus, void *userdata),
void *userdata) {
- Iterator i;
sd_bus *b;
int r, ret = 0;
/* Send to all direct buses, unconditionally */
- SET_FOREACH(b, m->private_buses, i) {
+ SET_FOREACH(b, m->private_buses) {
/* Don't bother with enqueuing these messages to clients that haven't started yet */
if (sd_bus_is_ready(b) <= 0)
uint64_t manager_bus_n_queued_write(Manager *m) {
uint64_t c = 0;
- Iterator i;
sd_bus *b;
int r;
/* Returns the total number of messages queued for writing on all our direct and API buses. */
- SET_FOREACH(b, m->private_buses, i) {
+ SET_FOREACH(b, m->private_buses) {
uint64_t k;
r = sd_bus_get_n_queued_write(b, &k);
static void device_upgrade_mount_deps(Unit *u) {
Unit *other;
- Iterator i;
void *v;
int r;
/* Let's upgrade Requires= to BindsTo= on us. (Used when SYSTEMD_MOUNT_DEVICE_BOUND is set) */
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REQUIRED_BY], i) {
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REQUIRED_BY]) {
if (other->type != UNIT_MOUNT)
continue;
int dynamic_user_serialize(Manager *m, FILE *f, FDSet *fds) {
DynamicUser *d;
- Iterator i;
assert(m);
assert(f);
/* Dump the dynamic user database into the manager serialization, to deal with daemon reloads. */
- HASHMAP_FOREACH(d, m->dynamic_users, i) {
+ HASHMAP_FOREACH(d, m->dynamic_users) {
int copy0, copy1;
copy0 = fdset_put_dup(fds, d->storage_socket[0]);
void dynamic_user_vacuum(Manager *m, bool close_user) {
DynamicUser *d;
- Iterator i;
assert(m);
* to which no reference exist. This is called after a daemon reload finished, in order to destroy users which
* might not be referenced anymore. */
- HASHMAP_FOREACH(d, m->dynamic_users, i) {
+ HASHMAP_FOREACH(d, m->dynamic_users) {
if (d->n_ref > 0)
continue;
_cleanup_close_ int dfd = -1;
ExecSetCredential *sc;
char **id, **fn;
- Iterator iterator;
int r;
assert(context);
/* First we use the literally specified credentials. Note that they might be overriden again below,
* and thus act as a "default" if the same credential is specified multiple times */
- HASHMAP_FOREACH(sc, context->set_credentials, iterator) {
+ HASHMAP_FOREACH(sc, context->set_credentials) {
size_t add;
add = strlen(sc->id) + sc->size;
if (c->syscall_filter) {
#if HAVE_SECCOMP
- Iterator j;
void *id, *val;
bool first = true;
#endif
fputc('~', f);
#if HAVE_SECCOMP
- HASHMAP_FOREACH_KEY(val, id, c->syscall_filter, j) {
+ HASHMAP_FOREACH_KEY(val, id, c->syscall_filter) {
_cleanup_free_ char *name = NULL;
const char *errno_name = NULL;
int num = PTR_TO_INT(val);
if (c->syscall_archs) {
#if HAVE_SECCOMP
- Iterator j;
void *id;
#endif
prefix);
#if HAVE_SECCOMP
- SET_FOREACH(id, c->syscall_archs, j)
+ SET_FOREACH(id, c->syscall_archs)
fprintf(f, " %s", strna(seccomp_arch_to_string(PTR_TO_UINT32(id) - 1)));
#endif
fputc('\n', f);
int exec_runtime_serialize(const Manager *m, FILE *f, FDSet *fds) {
ExecRuntime *rt;
- Iterator i;
assert(m);
assert(f);
assert(fds);
- HASHMAP_FOREACH(rt, m->exec_runtime_by_id, i) {
+ HASHMAP_FOREACH(rt, m->exec_runtime_by_id) {
fprintf(f, "exec-runtime=%s", rt->id);
if (rt->tmp_dir)
void exec_runtime_vacuum(Manager *m) {
ExecRuntime *rt;
- Iterator i;
assert(m);
/* Free unreferenced ExecRuntime objects. This is used after manager deserialization process. */
- HASHMAP_FOREACH(rt, m->exec_runtime_by_id, i) {
+ HASHMAP_FOREACH(rt, m->exec_runtime_by_id) {
if (rt->n_ref > 0)
continue;
}
static bool job_is_runnable(Job *j) {
- Iterator i;
Unit *other;
void *v;
if (j->type == JOB_NOP)
return true;
- HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER], i)
+ HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER])
if (other->job && job_compare(j, other->job, UNIT_AFTER) > 0) {
log_unit_debug(j->unit,
"starting held back, waiting for: %s",
return false;
}
- HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE], i)
+ HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE])
if (other->job && job_compare(j, other->job, UNIT_BEFORE) > 0) {
log_unit_debug(j->unit,
"stopping held back, waiting for: %s",
static void job_fail_dependencies(Unit *u, UnitDependency d) {
Unit *other;
- Iterator i;
void *v;
assert(u);
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[d], i) {
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[d]) {
Job *j = other->job;
if (!j)
Unit *u;
Unit *other;
JobType t;
- Iterator i;
void *v;
assert(j);
finish:
/* Try to start the next jobs that can be started */
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_AFTER], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_AFTER])
if (other->job) {
job_add_to_run_queue(other->job);
job_add_to_gc_queue(other->job);
}
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BEFORE], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BEFORE])
if (other->job) {
job_add_to_run_queue(other->job);
job_add_to_gc_queue(other->job);
bool job_may_gc(Job *j) {
Unit *other;
- Iterator i;
void *v;
assert(j);
return false;
/* The logic is inverse to job_is_runnable, we cannot GC as long as we block any job. */
- HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE], i)
+ HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE])
if (other->job && job_compare(j, other->job, UNIT_BEFORE) < 0)
return false;
- HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER], i)
+ HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER])
if (other->job && job_compare(j, other->job, UNIT_AFTER) < 0)
return false;
_cleanup_free_ Job** list = NULL;
size_t n = 0, n_allocated = 0;
Unit *other = NULL;
- Iterator i;
void *v;
/* Returns a list of all pending jobs that need to finish before this job may be started. */
return 0;
}
- HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER], i) {
+ HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER]) {
if (!other->job)
continue;
if (job_compare(j, other->job, UNIT_AFTER) <= 0)
list[n++] = other->job;
}
- HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE], i) {
+ HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE]) {
if (!other->job)
continue;
if (job_compare(j, other->job, UNIT_BEFORE) <= 0)
size_t n = 0, n_allocated = 0;
Unit *other = NULL;
void *v;
- Iterator i;
assert(j);
assert(ret);
/* Returns a list of all pending jobs that are waiting for this job to finish. */
- HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE], i) {
+ HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE]) {
if (!other->job)
continue;
list[n++] = other->job;
}
- HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER], i) {
+ HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER]) {
if (!other->job)
continue;
static void log_children_no_yet_killed(Set *pids) {
_cleanup_free_ char *lst_child = NULL;
- Iterator i;
void *p;
- SET_FOREACH(p, pids, i) {
+ SET_FOREACH(p, pids) {
_cleanup_free_ char *s = NULL;
if (get_process_comm(PTR_TO_PID(p), &s) < 0)
struct timespec ts;
int k;
void *p;
- Iterator i;
/* First, let the kernel inform us about killed
* children. Most processes will probably be our
/* Now explicitly check who might be remaining, who
* might not be our child. */
- SET_FOREACH(p, pids, i) {
+ SET_FOREACH(p, pids) {
/* kill(pid, 0) sends no signal, but it tells
* us whether the process still exists. */
static void manager_print_jobs_in_progress(Manager *m) {
_cleanup_free_ char *job_of_n = NULL;
- Iterator i;
Job *j;
unsigned counter = 0, print_nr;
char cylon[6 + CYLON_BUFFER_EXTRA + 1];
print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
- HASHMAP_FOREACH(j, m->jobs, i)
+ HASHMAP_FOREACH(j, m->jobs)
if (j->state == JOB_RUNNING && counter++ == print_nr)
break;
static void unit_gc_mark_good(Unit *u, unsigned gc_marker) {
Unit *other;
- Iterator i;
void *v;
u->gc_marker = gc_marker + GC_OFFSET_GOOD;
/* Recursively mark referenced units as GOOD as well */
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REFERENCES], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REFERENCES])
if (other->gc_marker == gc_marker + GC_OFFSET_UNSURE)
unit_gc_mark_good(other, gc_marker);
}
static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
Unit *other;
bool is_bad;
- Iterator i;
void *v;
assert(u);
is_bad = true;
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REFERENCED_BY], i) {
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REFERENCED_BY]) {
unit_gc_sweep(other, gc_marker);
if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
}
static void manager_coldplug(Manager *m) {
- Iterator i;
Unit *u;
char *k;
int r;
log_debug("Invoking unit coldplug() handlers…");
/* Let's place the units back into their deserialized state */
- HASHMAP_FOREACH_KEY(u, k, m->units, i) {
+ HASHMAP_FOREACH_KEY(u, k, m->units) {
/* ignore aliases */
if (u->id != k)
}
static void manager_catchup(Manager *m) {
- Iterator i;
Unit *u;
char *k;
log_debug("Invoking unit catchup() handlers…");
/* Let's catch up on any state changes that happened while we were reloading/reexecing */
- HASHMAP_FOREACH_KEY(u, k, m->units, i) {
+ HASHMAP_FOREACH_KEY(u, k, m->units) {
/* ignore aliases */
if (u->id != k)
}
static void manager_distribute_fds(Manager *m, FDSet *fds) {
- Iterator i;
Unit *u;
assert(m);
- HASHMAP_FOREACH(u, m->units, i) {
+ HASHMAP_FOREACH(u, m->units) {
if (fdset_size(fds) <= 0)
break;
for (k = 0; k < ELEMENTSOF(deps); k++) {
Unit *target;
- Iterator i;
void *v;
- HASHMAP_FOREACH_KEY(v, target, u->dependencies[deps[k]], i) {
+ HASHMAP_FOREACH_KEY(v, target, u->dependencies[deps[k]]) {
r = unit_add_default_target_dependency(u, target);
if (r < 0)
return r;
}
void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
- Iterator i;
Job *j;
assert(s);
assert(f);
- HASHMAP_FOREACH(j, s->jobs, i)
+ HASHMAP_FOREACH(j, s->jobs)
job_dump(j, f, prefix);
}
void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
- Iterator i;
Unit *u;
const char *t;
assert(s);
assert(f);
- HASHMAP_FOREACH_KEY(u, t, s->units, i)
+ HASHMAP_FOREACH_KEY(u, t, s->units)
if (u->id == t)
unit_dump(u, f, prefix);
}
static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
Manager *m = userdata;
- Iterator i;
Unit *u;
assert(m);
/* Restart the watch */
(void) manager_setup_time_change(m);
- HASHMAP_FOREACH(u, m->units, i)
+ HASHMAP_FOREACH(u, m->units)
if (UNIT_VTABLE(u)->time_change)
UNIT_VTABLE(u)->time_change(u);
Manager *m = userdata;
int changed;
- Iterator i;
Unit *u;
assert(m);
log_debug("Timezone has been changed (now: %s).", tzname[daylight]);
- HASHMAP_FOREACH(u, m->units, i)
+ HASHMAP_FOREACH(u, m->units)
if (UNIT_VTABLE(u)->timezone_change)
UNIT_VTABLE(u)->timezone_change(u);
Hashmap **uid_refs,
const char *field_name) {
- Iterator i;
void *p, *k;
assert(m);
/* Serialize the UID reference table. Or actually, just the IPC destruction flag of it, as
* the actual counter of it is better rebuild after a reload/reexec. */
- HASHMAP_FOREACH_KEY(p, k, *uid_refs, i) {
+ HASHMAP_FOREACH_KEY(p, k, *uid_refs) {
uint32_t c;
uid_t uid;
ManagerTimestamp q;
const char *t;
- Iterator i;
Unit *u;
int r;
(void) fputc('\n', f);
- HASHMAP_FOREACH_KEY(u, t, m->units, i) {
+ HASHMAP_FOREACH_KEY(u, t, m->units) {
if (u->id != t)
continue;
void manager_reset_failed(Manager *m) {
Unit *u;
- Iterator i;
assert(m);
- HASHMAP_FOREACH(u, m->units, i)
+ HASHMAP_FOREACH(u, m->units)
unit_reset_failed(u);
}
Hashmap **uid_refs,
int (*_clean_ipc)(uid_t uid)) {
- Iterator i;
void *p, *k;
assert(m);
assert(uid_refs);
assert(_clean_ipc);
- HASHMAP_FOREACH_KEY(p, k, *uid_refs, i) {
+ HASHMAP_FOREACH_KEY(p, k, *uid_refs) {
uint32_t c, n;
uid_t uid;
static int mount_add_mount_dependencies(Mount *m) {
MountParameters *pm;
Unit *other;
- Iterator i;
Set *s;
int r;
/* Adds in dependencies to other units that use this path or paths further down in the hierarchy */
s = manager_get_units_requiring_mounts_for(UNIT(m)->manager, m->where);
- SET_FOREACH(other, s, i) {
+ SET_FOREACH(other, s) {
if (other->load_state != UNIT_LOADED)
continue;
static int mount_process_proc_self_mountinfo(Manager *m) {
_cleanup_set_free_free_ Set *around = NULL, *gone = NULL;
const char *what;
- Iterator i;
Unit *u;
int r;
mount->proc_flags = 0;
}
- SET_FOREACH(what, gone, i) {
+ SET_FOREACH(what, gone) {
if (set_contains(around, what))
continue;
rn_socket_fds = 1;
} else {
- Iterator i;
void *v;
Unit *u;
/* Pass all our configured sockets for singleton services */
- HASHMAP_FOREACH_KEY(v, u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY], i) {
+ HASHMAP_FOREACH_KEY(v, u, UNIT(s)->dependencies[UNIT_TRIGGERED_BY]) {
_cleanup_free_ int *cfds = NULL;
Socket *sock;
int cn_fds;
static bool slice_freezer_action_supported_by_children(Unit *s) {
Unit *member;
void *v;
- Iterator i;
assert(s);
- HASHMAP_FOREACH_KEY(v, member, s->dependencies[UNIT_BEFORE], i) {
+ HASHMAP_FOREACH_KEY(v, member, s->dependencies[UNIT_BEFORE]) {
int r;
if (UNIT_DEREF(member->slice) != s)
static int slice_freezer_action(Unit *s, FreezerAction action) {
Unit *member;
void *v;
- Iterator i;
int r;
assert(s);
if (!slice_freezer_action_supported_by_children(s))
return log_unit_warning(s, "Requested freezer operation is not supported by all children of the slice");
- HASHMAP_FOREACH_KEY(v, member, s->dependencies[UNIT_BEFORE], i) {
+ HASHMAP_FOREACH_KEY(v, member, s->dependencies[UNIT_BEFORE]) {
if (UNIT_DEREF(member->slice) != s)
continue;
if (cfd < 0) {
bool pending = false;
Unit *other;
- Iterator i;
void *v;
/* If there's already a start pending don't bother to
* do anything */
- HASHMAP_FOREACH_KEY(v, other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
+ HASHMAP_FOREACH_KEY(v, other, UNIT(s)->dependencies[UNIT_TRIGGERS])
if (unit_active_or_pending(other)) {
pending = true;
break;
assert(u);
LIST_FOREACH(port, p, s->ports) {
- Iterator i;
int fd;
if (p->type != SOCKET_SOCKET)
if (p->fd >= 0)
continue;
- FDSET_FOREACH(fd, fds, i) {
+ FDSET_FOREACH(fd, fds) {
if (socket_address_matches_fd(&p->address, fd)) {
p->fd = fdset_remove(fds, fd);
s->deserialized_state = SOCKET_LISTENING;
for (k = 0; k < ELEMENTSOF(deps); k++) {
Unit *other;
- Iterator i;
void *v;
- HASHMAP_FOREACH_KEY(v, other, UNIT(t)->dependencies[deps[k]], i) {
+ HASHMAP_FOREACH_KEY(v, other, UNIT(t)->dependencies[deps[k]]) {
r = unit_add_default_target_dependency(other, UNIT(t));
if (r < 0)
return r;
static int transaction_merge_jobs(Transaction *tr, sd_bus_error *e) {
Job *j;
- Iterator i;
int r;
assert(tr);
/* First step, check whether any of the jobs for one specific
* task conflict. If so, try to drop one of them. */
- HASHMAP_FOREACH(j, tr->jobs, i) {
+ HASHMAP_FOREACH(j, tr->jobs) {
JobType t;
Job *k;
}
/* Second step, merge the jobs. */
- HASHMAP_FOREACH(j, tr->jobs, i) {
+ HASHMAP_FOREACH(j, tr->jobs) {
JobType t = j->type;
Job *k;
assert(tr);
do {
- Iterator i;
Job *j;
again = false;
- HASHMAP_FOREACH(j, tr->jobs, i) {
+ HASHMAP_FOREACH(j, tr->jobs) {
bool keep = false;
Job *k;
}
static int transaction_verify_order_one(Transaction *tr, Job *j, Job *from, unsigned generation, sd_bus_error *e) {
- Iterator i;
Unit *u;
void *v;
int r;
* ordering dependencies and we test with job_compare() whether it is the 'before' edge in the job
* execution ordering. */
for (d = 0; d < ELEMENTSOF(directions); d++) {
- HASHMAP_FOREACH_KEY(v, u, j->unit->dependencies[directions[d]], i) {
+ HASHMAP_FOREACH_KEY(v, u, j->unit->dependencies[directions[d]]) {
Job *o;
/* Is there a job for this unit? */
static int transaction_verify_order(Transaction *tr, unsigned *generation, sd_bus_error *e) {
Job *j;
int r;
- Iterator i;
unsigned g;
assert(tr);
g = (*generation)++;
- HASHMAP_FOREACH(j, tr->jobs, i) {
+ HASHMAP_FOREACH(j, tr->jobs) {
r = transaction_verify_order_one(tr, j, NULL, g, e);
if (r < 0)
return r;
/* Drop jobs that are not required by any other job */
do {
- Iterator i;
Job *j;
again = false;
- HASHMAP_FOREACH(j, tr->jobs, i) {
+ HASHMAP_FOREACH(j, tr->jobs) {
if (tr->anchor_job == j)
continue;
}
static int transaction_is_destructive(Transaction *tr, JobMode mode, sd_bus_error *e) {
- Iterator i;
Job *j;
assert(tr);
/* Checks whether applying this transaction means that
* existing jobs would be replaced */
- HASHMAP_FOREACH(j, tr->jobs, i) {
+ HASHMAP_FOREACH(j, tr->jobs) {
/* Assume merged */
assert(!j->transaction_prev);
static void transaction_minimize_impact(Transaction *tr) {
Job *j;
- Iterator i;
assert(tr);
* or that stop a running service. */
rescan:
- HASHMAP_FOREACH(j, tr->jobs, i) {
+ HASHMAP_FOREACH(j, tr->jobs) {
LIST_FOREACH(transaction, j, j) {
bool stops_running_service, changes_existing_job;
JobMode mode,
Set *affected_jobs) {
- Iterator i;
Job *j;
int r;
/* When isolating first kill all installed jobs which
* aren't part of the new transaction */
- HASHMAP_FOREACH(j, m->jobs, i) {
+ HASHMAP_FOREACH(j, m->jobs) {
assert(j->installed);
if (j->unit->ignore_on_isolate)
}
}
- HASHMAP_FOREACH(j, tr->jobs, i) {
+ HASHMAP_FOREACH(j, tr->jobs) {
/* Assume merged */
assert(!j->transaction_prev);
assert(!j->transaction_next);
rollback:
- HASHMAP_FOREACH(j, tr->jobs, i)
+ HASHMAP_FOREACH(j, tr->jobs)
hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
return r;
Set *affected_jobs,
sd_bus_error *e) {
- Iterator i;
Job *j;
int r;
unsigned generation = 1;
/* Reset the generation counter of all installed jobs. The detection of cycles
* looks at installed jobs. If they had a non-zero generation from some previous
* walk of the graph, the algorithm would break. */
- HASHMAP_FOREACH(j, m->jobs, i)
+ HASHMAP_FOREACH(j, m->jobs)
j->generation = 0;
/* First step: figure out which jobs matter */
}
void transaction_add_propagate_reload_jobs(Transaction *tr, Unit *unit, Job *by, bool ignore_order, sd_bus_error *e) {
- Iterator i;
JobType nt;
Unit *dep;
void *v;
assert(tr);
assert(unit);
- HASHMAP_FOREACH_KEY(v, dep, unit->dependencies[UNIT_PROPAGATES_RELOAD_TO], i) {
+ HASHMAP_FOREACH_KEY(v, dep, unit->dependencies[UNIT_PROPAGATES_RELOAD_TO]) {
nt = job_type_collapse(JOB_TRY_RELOAD, dep);
if (nt == JOB_NOP)
continue;
sd_bus_error *e) {
bool is_new;
- Iterator i;
Unit *dep;
Job *ret;
void *v;
/* If we are following some other unit, make sure we
* add all dependencies of everybody following. */
if (unit_following_set(ret->unit, &following) > 0) {
- SET_FOREACH(dep, following, i) {
+ SET_FOREACH(dep, following) {
r = transaction_add_job_and_dependencies(tr, type, dep, ret, false, false, false, ignore_order, e);
if (r < 0) {
log_unit_full(dep,
/* Finally, recursively add in all dependencies. */
if (IN_SET(type, JOB_START, JOB_RESTART)) {
- HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_REQUIRES], i) {
+ HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_REQUIRES]) {
r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, true, false, false, ignore_order, e);
if (r < 0) {
if (r != -EBADR) /* job type not applicable */
}
}
- HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_BINDS_TO], i) {
+ HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_BINDS_TO]) {
r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, true, false, false, ignore_order, e);
if (r < 0) {
if (r != -EBADR) /* job type not applicable */
}
}
- HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_WANTS], i) {
+ HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_WANTS]) {
r = transaction_add_job_and_dependencies(tr, JOB_START, dep, ret, false, false, false, ignore_order, e);
if (r < 0) {
/* unit masked, job type not applicable and unit not found are not considered as errors. */
}
}
- HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_REQUISITE], i) {
+ HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_REQUISITE]) {
r = transaction_add_job_and_dependencies(tr, JOB_VERIFY_ACTIVE, dep, ret, true, false, false, ignore_order, e);
if (r < 0) {
if (r != -EBADR) /* job type not applicable */
}
}
- HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_CONFLICTS], i) {
+ HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_CONFLICTS]) {
r = transaction_add_job_and_dependencies(tr, JOB_STOP, dep, ret, true, true, false, ignore_order, e);
if (r < 0) {
if (r != -EBADR) /* job type not applicable */
}
}
- HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_CONFLICTED_BY], i) {
+ HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[UNIT_CONFLICTED_BY]) {
r = transaction_add_job_and_dependencies(tr, JOB_STOP, dep, ret, false, false, false, ignore_order, e);
if (r < 0) {
log_unit_warning(dep,
ptype = type == JOB_RESTART ? JOB_TRY_RESTART : type;
for (j = 0; j < ELEMENTSOF(propagate_deps); j++)
- HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[propagate_deps[j]], i) {
+ HASHMAP_FOREACH_KEY(v, dep, ret->unit->dependencies[propagate_deps[j]]) {
JobType nt;
nt = job_type_collapse(ptype, dep);
}
int transaction_add_isolate_jobs(Transaction *tr, Manager *m) {
- Iterator i;
Unit *u;
char *k;
int r;
assert(tr);
assert(m);
- HASHMAP_FOREACH_KEY(u, k, m->units, i) {
+ HASHMAP_FOREACH_KEY(u, k, m->units) {
/* ignore aliases */
if (u->id != k)
}
int transaction_add_triggering_jobs(Transaction *tr, Unit *u) {
- Iterator i;
void *v;
Unit *trigger;
int r;
assert(tr);
assert(u);
- HASHMAP_FOREACH_KEY(v, trigger, u->dependencies[UNIT_TRIGGERED_BY], i) {
+ HASHMAP_FOREACH_KEY(v, trigger, u->dependencies[UNIT_TRIGGERED_BY]) {
/* No need to stop inactive jobs */
if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(trigger)) && !trigger->job)
continue;
static void bidi_set_free(Unit *u, Hashmap *h) {
Unit *other;
- Iterator i;
void *v;
assert(u);
/* Frees the hashmap and makes sure we are dropped from the inverse pointers */
- HASHMAP_FOREACH_KEY(v, other, h, i) {
+ HASHMAP_FOREACH_KEY(v, other, h) {
for (UnitDependency d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
hashmap_remove(other->dependencies[d], u);
}
void unit_free(Unit *u) {
- Iterator i;
char *t;
if (!u)
unit_free_requires_mounts_for(u);
- SET_FOREACH(t, u->aliases, i)
+ SET_FOREACH(t, u->aliases)
hashmap_remove_value(u->manager->units, t, u);
if (u->id)
hashmap_remove_value(u->manager->units, u->id, u);
static int merge_names(Unit *u, Unit *other) {
char *name;
- Iterator i;
int r;
assert(u);
TAKE_PTR(other->id);
other->aliases = set_free_free(other->aliases);
- SET_FOREACH(name, u->aliases, i)
+ SET_FOREACH(name, u->aliases)
assert_se(hashmap_replace(u->manager->units, name, u) == 0);
return 0;
}
static void merge_dependencies(Unit *u, Unit *other, const char *other_id, UnitDependency d) {
- Iterator i;
Unit *back;
void *v;
int r;
assert(d < _UNIT_DEPENDENCY_MAX);
/* Fix backwards pointers. Let's iterate through all dependent units of the other unit. */
- HASHMAP_FOREACH_KEY(v, back, other->dependencies[d], i)
+ HASHMAP_FOREACH_KEY(v, back, other->dependencies[d])
/* Let's now iterate through the dependencies of that dependencies of the other units,
* looking for pointers back, and let's fix them up, to instead point to 'u'. */
void unit_dump(Unit *u, FILE *f, const char *prefix) {
char *t, **j;
- Iterator i;
const char *prefix2;
char timestamp[5][FORMAT_TIMESTAMP_MAX], timespan[FORMAT_TIMESPAN_MAX];
Unit *following;
"%s-> Unit %s:\n",
prefix, u->id);
- SET_FOREACH(t, u->aliases, i)
+ SET_FOREACH(t, u->aliases)
fprintf(f, "%s\tAlias: %s\n", prefix, t);
fprintf(f,
if (r >= 0) {
Unit *other;
- SET_FOREACH(other, following_set, i)
+ SET_FOREACH(other, following_set)
fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
}
UnitDependencyInfo di;
Unit *other;
- HASHMAP_FOREACH_KEY(di.data, other, u->dependencies[d], i) {
+ HASHMAP_FOREACH_KEY(di.data, other, u->dependencies[d]) {
bool space = false;
fprintf(f, "%s\t%s: %s (", prefix, unit_dependency_to_string(d), other->id);
UnitDependencyInfo di;
const char *path;
- HASHMAP_FOREACH_KEY(di.data, path, u->requires_mounts_for, i) {
+ HASHMAP_FOREACH_KEY(di.data, path, u->requires_mounts_for) {
bool space = false;
fprintf(f, "%s\tRequiresMountsFor: %s (", prefix, path);
static int unit_add_mount_dependencies(Unit *u) {
UnitDependencyInfo di;
const char *path;
- Iterator i;
int r;
assert(u);
- HASHMAP_FOREACH_KEY(di.data, path, u->requires_mounts_for, i) {
+ HASHMAP_FOREACH_KEY(di.data, path, u->requires_mounts_for) {
char prefix[strlen(path) + 1];
PATH_FOREACH_PREFIX_MORE(prefix, path) {
static bool unit_verify_deps(Unit *u) {
Unit *other;
- Iterator j;
void *v;
assert(u);
* processing, but do not have any effect afterwards. We don't check BindsTo= dependencies that are not used in
* conjunction with After= as for them any such check would make things entirely racy. */
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO], j) {
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO]) {
if (!hashmap_contains(u->dependencies[UNIT_AFTER], other))
continue;
for (size_t j = 0; j < ELEMENTSOF(deps); j++) {
Unit *other;
- Iterator i;
void *v;
/* If a dependent unit has a job queued, is active or transitioning, or is marked for
* restart, then don't clean this one up. */
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[deps[j]], i) {
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[deps[j]]) {
if (other->job)
return false;
for (size_t j = 0; j < ELEMENTSOF(deps); j++) {
Unit *other;
- Iterator i;
void *v;
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[deps[j]], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[deps[j]])
unit_submit_to_stop_when_unneeded_queue(other);
}
}
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
bool stop = false;
Unit *other;
- Iterator i;
void *v;
int r;
if (unit_active_state(u) != UNIT_ACTIVE)
return;
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO], i) {
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO]) {
if (other->job)
continue;
}
static void retroactively_start_dependencies(Unit *u) {
- Iterator i;
Unit *other;
void *v;
assert(u);
assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REQUIRES], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REQUIRES])
if (!hashmap_get(u->dependencies[UNIT_AFTER], other) &&
!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, NULL, NULL, NULL);
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO])
if (!hashmap_get(u->dependencies[UNIT_AFTER], other) &&
!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, NULL, NULL, NULL);
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_WANTS], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_WANTS])
if (!hashmap_get(u->dependencies[UNIT_AFTER], other) &&
!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
manager_add_job(u->manager, JOB_START, other, JOB_FAIL, NULL, NULL, NULL);
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_CONFLICTS], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_CONFLICTS])
if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, NULL, NULL, NULL);
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_CONFLICTED_BY], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_CONFLICTED_BY])
if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, NULL, NULL, NULL);
}
static void retroactively_stop_dependencies(Unit *u) {
Unit *other;
- Iterator i;
void *v;
assert(u);
assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
/* Pull down units which are bound to us recursively if enabled */
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BOUND_BY], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BOUND_BY])
if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, NULL, NULL, NULL);
}
void unit_start_on_failure(Unit *u) {
Unit *other;
- Iterator i;
void *v;
int r;
log_unit_info(u, "Triggering OnFailure= dependencies.");
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_ON_FAILURE], i) {
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_ON_FAILURE]) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, NULL, &error, NULL);
void unit_trigger_notify(Unit *u) {
Unit *other;
- Iterator i;
void *v;
assert(u);
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_TRIGGERED_BY], i)
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_TRIGGERED_BY])
if (UNIT_VTABLE(other)->trigger_notify)
UNIT_VTABLE(other)->trigger_notify(other, u);
}
static void unit_tidy_watch_pids(Unit *u) {
pid_t except1, except2;
- Iterator i;
void *e;
assert(u);
except1 = unit_main_pid(u);
except2 = unit_control_pid(u);
- SET_FOREACH(e, u->pids, i) {
+ SET_FOREACH(e, u->pids) {
pid_t pid = PTR_TO_PID(e);
if (pid == except1 || pid == except2)
ExecRuntime **rt;
size_t offset;
Unit *other;
- Iterator i;
void *v;
int r;
return 0;
/* Try to get it from somebody else */
- HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
+ HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_JOINS_NAMESPACE_OF]) {
r = exec_runtime_acquire(u->manager, NULL, other->id, false, rt);
if (r == 1)
return 1;
do {
UnitDependencyInfo di;
Unit *other;
- Iterator i;
done = true;
- HASHMAP_FOREACH_KEY(di.data, other, u->dependencies[d], i) {
+ HASHMAP_FOREACH_KEY(di.data, other, u->dependencies[d]) {
if ((di.origin_mask & ~mask) == di.origin_mask)
continue;
di.origin_mask &= ~mask;
static int add_proc_cmdline_devices(void) {
int r;
- Iterator i;
crypto_device *d;
- HASHMAP_FOREACH(d, arg_disks, i) {
+ HASHMAP_FOREACH(d, arg_disks) {
_cleanup_free_ char *device = NULL;
if (!d->create)
static int process_suffix(const char *suffix, const char *onlyprefix) {
const char *p;
- char *f;
- OrderedHashmap *top, *bottom, *drops;
- OrderedHashmap *h;
- char *key;
- int r = 0, k;
- Iterator i, j;
- int n_found = 0;
+ char *f, *key;
+ OrderedHashmap *top, *bottom, *drops, *h;
+ int r = 0, k, n_found = 0;
bool dropins;
assert(suffix);
r = k;
}
- ORDERED_HASHMAP_FOREACH_KEY(f, key, top, i) {
+ ORDERED_HASHMAP_FOREACH_KEY(f, key, top) {
char *o;
o = ordered_hashmap_get(bottom, key);
h = ordered_hashmap_get(drops, key);
if (h)
- ORDERED_HASHMAP_FOREACH(o, h, j)
+ ORDERED_HASHMAP_FOREACH(o, h)
if (!onlyprefix || startswith(o, onlyprefix))
n_found += notify_override_extended(f, o);
}
ordered_hashmap_free_free(top);
ordered_hashmap_free_free(bottom);
- ORDERED_HASHMAP_FOREACH_KEY(h, key, drops, i) {
+ ORDERED_HASHMAP_FOREACH_KEY(h, key, drops) {
ordered_hashmap_free_free(ordered_hashmap_remove(drops, key));
ordered_hashmap_remove(drops, key);
free(key);
_cleanup_strv_free_ char **l = NULL;
Manager *m = userdata;
size_t k = 0;
- Iterator i;
Home *h;
int r;
if (!l)
return -ENOMEM;
- HASHMAP_FOREACH(h, m->homes_by_uid, i) {
+ HASHMAP_FOREACH(h, m->homes_by_uid) {
r = bus_home_path(h, l + k);
if (r < 0)
return r;
sd_bus_error *error) {
Manager *m = userdata;
- Iterator i;
Home *h;
int r;
if (r < 0)
return r;
- HASHMAP_FOREACH(h, m->homes_by_name, i) {
+ HASHMAP_FOREACH(h, m->homes_by_name) {
_cleanup_(strv_freep) char **seats = NULL;
_cleanup_free_ char *home_path = NULL;
char **s;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = userdata;
- Iterator i;
Home *h;
int r;
if (r < 0)
return r;
- HASHMAP_FOREACH(h, m->homes_by_uid, i) {
+ HASHMAP_FOREACH(h, m->homes_by_uid) {
_cleanup_free_ char *path = NULL;
r = bus_home_path(h, &path);
_cleanup_(operation_unrefp) Operation *o = NULL;
bool waiting = false;
Manager *m = userdata;
- Iterator i;
Home *h;
int r;
* for every suitable home we have and only when all of them completed we send a reply indicating
* completion. */
- HASHMAP_FOREACH(h, m->homes_by_name, i) {
+ HASHMAP_FOREACH(h, m->homes_by_name) {
/* Automatically suspend all homes that have at least one client referencing it that asked
* for "please suspend", and no client that asked for "please do not suspend". */
int manager_verify_user_record(Manager *m, UserRecord *hr) {
EVP_PKEY *pkey;
- Iterator i;
int r;
assert(m);
}
}
- HASHMAP_FOREACH(pkey, m->public_keys, i) {
+ HASHMAP_FOREACH(pkey, m->public_keys) {
r = user_record_verify(hr, pkey);
switch (r) {
manager_revalidate_image(m, h);
} else {
/* Gc all */
- Iterator i;
- HASHMAP_FOREACH(h, m->homes_by_name, i)
+ HASHMAP_FOREACH(h, m->homes_by_name)
manager_revalidate_image(m, h);
}
else if (p.user_name)
h = hashmap_get(m->homes_by_name, p.user_name);
else {
- Iterator i;
/* If neither UID nor name was specified, then dump all homes. Do so with varlink_notify()
* for all entries but the last, so that clients can stream the results, and easily process
* them piecemeal. */
- HASHMAP_FOREACH(h, m->homes_by_name, i) {
+ HASHMAP_FOREACH(h, m->homes_by_name) {
if (!home_user_match_lookup_parameters(&p, h))
continue;
else if (p.group_name)
h = hashmap_get(m->homes_by_name, p.group_name);
else {
- Iterator i;
- HASHMAP_FOREACH(h, m->homes_by_name, i) {
+ HASHMAP_FOREACH(h, m->homes_by_name) {
if (!home_group_match_lookup_parameters(&p, h))
continue;
} else if (p.group_name) {
const char *last = NULL;
- Iterator i;
- HASHMAP_FOREACH(h, m->homes_by_name, i) {
+ HASHMAP_FOREACH(h, m->homes_by_name) {
if (!strv_contains(h->record->member_of, p.group_name))
continue;
JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(p.group_name))));
} else {
const char *last_user_name = NULL, *last_group_name = NULL;
- Iterator i;
- HASHMAP_FOREACH(h, m->homes_by_name, i) {
+ HASHMAP_FOREACH(h, m->homes_by_name) {
char **j;
STRV_FOREACH(j, h->record->member_of) {
Manager *m = userdata;
char *p, *e;
Transfer *t;
- Iterator i;
ssize_t n;
int r;
return 0;
}
- HASHMAP_FOREACH(t, m->transfers, i)
+ HASHMAP_FOREACH(t, m->transfers)
if (ucred->pid == t->pid)
break;
static Transfer *manager_find(Manager *m, TransferType type, const char *remote) {
Transfer *t;
- Iterator i;
assert(m);
assert(type >= 0);
assert(type < _TRANSFER_TYPE_MAX);
- HASHMAP_FOREACH(t, m->transfers, i)
+ HASHMAP_FOREACH(t, m->transfers)
if (t->type == type && streq_ptr(t->remote, remote))
return t;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = userdata;
Transfer *t;
- Iterator i;
int r;
assert(msg);
if (r < 0)
return r;
- HASHMAP_FOREACH(t, m->transfers, i) {
+ HASHMAP_FOREACH(t, m->transfers) {
r = sd_bus_message_append(
reply,
Manager *m = userdata;
Transfer *t;
unsigned k = 0;
- Iterator i;
l = new0(char*, hashmap_size(m->transfers) + 1);
if (!l)
return -ENOMEM;
- HASHMAP_FOREACH(t, m->transfers, i) {
+ HASHMAP_FOREACH(t, m->transfers) {
l[k] = strdup(t->object_path);
if (!l[k])
ssize_t offset;
char *payload;
CatalogItem *i;
- Iterator j;
unsigned n;
int r;
int64_t sz;
return log_oom();
n = 0;
- ORDERED_HASHMAP_FOREACH_KEY(payload, i, h, j) {
+ ORDERED_HASHMAP_FOREACH_KEY(payload, i, h) {
log_debug("Found " SD_ID128_FORMAT_STR ", language %s",
SD_ID128_FORMAT_VAL(i->id),
isempty(i->language) ? "C" : i->language);
if (!strv_isempty(patterns)) {
_cleanup_set_free_free_ Set *units = NULL;
- Iterator it;
char *u;
r = get_possible_units(j, SYSTEM_UNITS, patterns, &units);
if (r < 0)
return r;
- SET_FOREACH(u, units, it) {
+ SET_FOREACH(u, units) {
r = add_matches_for_unit(j, u);
if (r < 0)
return r;
if (!strv_isempty(patterns)) {
_cleanup_set_free_free_ Set *units = NULL;
- Iterator it;
char *u;
r = get_possible_units(j, USER_UNITS, patterns, &units);
if (r < 0)
return r;
- SET_FOREACH(u, units, it) {
+ SET_FOREACH(u, units) {
r = add_matches_for_user_unit(j, u, getuid());
if (r < 0)
return r;
static int add_facilities(sd_journal *j) {
void *p;
- Iterator it;
int r;
- SET_FOREACH(p, arg_facilities, it) {
+ SET_FOREACH(p, arg_facilities) {
char match[STRLEN("SYSLOG_FACILITY=") + DECIMAL_STR_MAX(int)];
xsprintf(match, "SYSLOG_FACILITY=%d", PTR_TO_INT(p));
static int verify(sd_journal *j) {
int r = 0;
- Iterator i;
JournalFile *f;
assert(j);
log_show_color(true);
- ORDERED_HASHMAP_FOREACH(f, j->files, i) {
+ ORDERED_HASHMAP_FOREACH(f, j->files) {
int k;
usec_t first = 0, validated = 0, last = 0;
case ACTION_VACUUM: {
Directory *d;
- Iterator i;
- HASHMAP_FOREACH(d, j->directories_by_path, i) {
+ HASHMAP_FOREACH(d, j->directories_by_path) {
int q;
q = journal_directory_vacuum(d->path, arg_vacuum_size, arg_vacuum_n_files, arg_vacuum_time, NULL, !arg_quiet);
static void server_process_deferred_closes(Server *s) {
JournalFile *f;
- Iterator i;
/* Perform any deferred closes which aren't still offlining. */
- SET_FOREACH(f, s->deferred_closes, i) {
+ SET_FOREACH(f, s->deferred_closes) {
if (journal_file_is_offlining(f))
continue;
void server_rotate(Server *s) {
JournalFile *f;
- Iterator i;
void *k;
int r;
(void) do_rotate(s, &s->system_journal, "system", s->seal, 0);
/* Then, rotate all user journals we have open (keeping them open) */
- ORDERED_HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
+ ORDERED_HASHMAP_FOREACH_KEY(f, k, s->user_journals) {
r = do_rotate(s, &f, "user", s->seal, PTR_TO_UID(k));
if (r >= 0)
ordered_hashmap_replace(s->user_journals, k, f);
void server_sync(Server *s) {
JournalFile *f;
- Iterator i;
int r;
if (s->system_journal) {
log_warning_errno(r, "Failed to sync system journal, ignoring: %m");
}
- ORDERED_HASHMAP_FOREACH(f, s->user_journals, i) {
+ ORDERED_HASHMAP_FOREACH(f, s->user_journals) {
r = journal_file_set_offline(f, false);
if (r < 0)
log_warning_errno(r, "Failed to sync user journal, ignoring: %m");
void server_maybe_append_tags(Server *s) {
#if HAVE_GCRYPT
JournalFile *f;
- Iterator i;
usec_t n;
n = now(CLOCK_REALTIME);
if (s->system_journal)
journal_file_maybe_append_tag(s->system_journal, n);
- ORDERED_HASHMAP_FOREACH(f, s->user_journals, i)
+ ORDERED_HASHMAP_FOREACH(f, s->user_journals)
journal_file_maybe_append_tag(f, n);
#endif
}
FOREACH_DIRENT(de, d, goto fail) {
unsigned long st_dev, st_ino;
bool found = false;
- Iterator i;
int fd;
if (sscanf(de->d_name, "%lu:%lu", &st_dev, &st_ino) != 2)
continue;
- FDSET_FOREACH(fd, fds, i) {
+ FDSET_FOREACH(fd, fds) {
struct stat st;
if (fstat(fd, &st) < 0)
static void mmap_cache_process_sigbus(MMapCache *m) {
bool found = false;
MMapFileDescriptor *f;
- Iterator i;
int r;
assert(m);
}
ours = false;
- HASHMAP_FOREACH(f, m->fds, i) {
+ HASHMAP_FOREACH(f, m->fds) {
Window *w;
LIST_FOREACH(by_fd, w, f->windows) {
if (_likely_(!found))
return;
- HASHMAP_FOREACH(f, m->fds, i) {
+ HASHMAP_FOREACH(f, m->fds) {
Window *w;
if (!f->sigbus)
}
static void detach_location(sd_journal *j) {
- Iterator i;
JournalFile *f;
assert(j);
j->current_file = NULL;
j->current_field = 0;
- ORDERED_HASHMAP_FOREACH(f, j->files, i)
+ ORDERED_HASHMAP_FOREACH(f, j->files)
journal_file_reset_location(f);
}
}
static int add_current_paths(sd_journal *j) {
- Iterator i;
JournalFile *f;
assert(j);
/* Simply adds all directories for files we have open as directories. We don't expect errors here, so we
* treat them as fatal. */
- ORDERED_HASHMAP_FOREACH(f, j->files, i) {
+ ORDERED_HASHMAP_FOREACH(f, j->files) {
_cleanup_free_ char *dir;
int r;
}
_public_ int sd_journal_open_files_fd(sd_journal **ret, int fds[], unsigned n_fds, int flags) {
- Iterator iterator;
JournalFile *f;
_cleanup_(sd_journal_closep) sd_journal *j = NULL;
unsigned i;
fail:
/* If we fail, make sure we don't take possession of the files we managed to make use of successfully, and they
* remain open */
- ORDERED_HASHMAP_FOREACH(f, j->files, iterator)
+ ORDERED_HASHMAP_FOREACH(f, j->files)
f->close_fd = false;
return r;
static void process_q_overflow(sd_journal *j) {
JournalFile *f;
Directory *m;
- Iterator i;
assert(j);
j->generation++;
(void) reiterate_all_paths(j);
- ORDERED_HASHMAP_FOREACH(f, j->files, i) {
+ ORDERED_HASHMAP_FOREACH(f, j->files) {
if (f->last_seen_generation == j->generation)
continue;
remove_file_real(j, f);
}
- HASHMAP_FOREACH(m, j->directories_by_path, i) {
+ HASHMAP_FOREACH(m, j->directories_by_path) {
if (m->last_seen_generation == j->generation)
continue;
assert_return(!journal_pid_changed(j), -ECHILD);
if (j->inotify_fd < 0) {
- Iterator i;
JournalFile *f;
/* This is the first invocation, hence create the
/* Server might have done some vacuuming while we weren't watching.
Get rid of the deleted files now so they don't stay around indefinitely. */
- ORDERED_HASHMAP_FOREACH(f, j->files, i) {
+ ORDERED_HASHMAP_FOREACH(f, j->files) {
r = journal_file_fstat(f);
if (r == -EIDRM)
remove_file_real(j, f);
}
_public_ int sd_journal_get_cutoff_realtime_usec(sd_journal *j, uint64_t *from, uint64_t *to) {
- Iterator i;
JournalFile *f;
bool first = true;
uint64_t fmin = 0, tmax = 0;
assert_return(from || to, -EINVAL);
assert_return(from != to, -EINVAL);
- ORDERED_HASHMAP_FOREACH(f, j->files, i) {
+ ORDERED_HASHMAP_FOREACH(f, j->files) {
usec_t fr, t;
r = journal_file_get_cutoff_realtime_usec(f, &fr, &t);
}
_public_ int sd_journal_get_cutoff_monotonic_usec(sd_journal *j, sd_id128_t boot_id, uint64_t *from, uint64_t *to) {
- Iterator i;
JournalFile *f;
bool found = false;
int r;
assert_return(from || to, -EINVAL);
assert_return(from != to, -EINVAL);
- ORDERED_HASHMAP_FOREACH(f, j->files, i) {
+ ORDERED_HASHMAP_FOREACH(f, j->files) {
usec_t fr, t;
r = journal_file_get_cutoff_monotonic_usec(f, boot_id, &fr, &t);
}
void journal_print_header(sd_journal *j) {
- Iterator i;
JournalFile *f;
bool newline = false;
assert(j);
- ORDERED_HASHMAP_FOREACH(f, j->files, i) {
+ ORDERED_HASHMAP_FOREACH(f, j->files) {
if (newline)
putchar('\n');
else
}
_public_ int sd_journal_get_usage(sd_journal *j, uint64_t *bytes) {
- Iterator i;
JournalFile *f;
uint64_t sum = 0;
assert_return(!journal_pid_changed(j), -ECHILD);
assert_return(bytes, -EINVAL);
- ORDERED_HASHMAP_FOREACH(f, j->files, i) {
+ ORDERED_HASHMAP_FOREACH(f, j->files) {
struct stat st;
if (fstat(f->fd, &st) < 0)
for (;;) {
JournalFile *of;
- Iterator i;
Object *o;
const void *odata;
size_t ol;
* object by checking if it exists in the earlier
* traversed files. */
found = false;
- ORDERED_HASHMAP_FOREACH(of, j->files, i) {
+ ORDERED_HASHMAP_FOREACH(of, j->files) {
if (of == j->unique_file)
break;
for (;;) {
JournalFile *f, *of;
- Iterator i;
uint64_t m;
Object *o;
size_t sz;
/* Let's see if we already returned this field name before. */
found = false;
- ORDERED_HASHMAP_FOREACH(of, j->files, i) {
+ ORDERED_HASHMAP_FOREACH(of, j->files) {
if (of == f)
break;
static void test_catalog_import_one(void) {
_cleanup_ordered_hashmap_free_free_free_ OrderedHashmap *h = NULL;
char *payload;
- Iterator j;
const char *input =
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededed\n" \
h = test_import(input, -1, 0);
assert_se(ordered_hashmap_size(h) == 1);
- ORDERED_HASHMAP_FOREACH(payload, h, j) {
+ ORDERED_HASHMAP_FOREACH(payload, h) {
printf("expect: %s\n", expect);
printf("actual: %s\n", payload);
assert_se(streq(expect, payload));
static void test_catalog_import_merge(void) {
_cleanup_ordered_hashmap_free_free_free_ OrderedHashmap *h = NULL;
char *payload;
- Iterator j;
const char *input =
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededed\n" \
h = test_import(input, -1, 0);
assert_se(ordered_hashmap_size(h) == 1);
- ORDERED_HASHMAP_FOREACH(payload, h, j)
+ ORDERED_HASHMAP_FOREACH(payload, h)
assert_se(streq(combined, payload));
}
static void test_catalog_import_merge_no_body(void) {
_cleanup_ordered_hashmap_free_free_free_ OrderedHashmap *h = NULL;
char *payload;
- Iterator j;
const char *input =
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededed\n" \
h = test_import(input, -1, 0);
assert_se(ordered_hashmap_size(h) == 1);
- ORDERED_HASHMAP_FOREACH(payload, h, j)
+ ORDERED_HASHMAP_FOREACH(payload, h)
assert_se(streq(combined, payload));
}
OrderedHashmap *s = (OrderedHashmap *) optval;
struct sd_dhcp_option *p;
size_t l = 0;
- Iterator i;
- ORDERED_HASHMAP_FOREACH(p, s, i)
+ ORDERED_HASHMAP_FOREACH(p, s)
l += p->length + 2;
if (*offset + l + 2 > size)
*offset += 2;
- ORDERED_HASHMAP_FOREACH(p, s, i) {
+ ORDERED_HASHMAP_FOREACH(p, s) {
options[*offset] = p->option;
options[*offset + 1] = p->length;
memcpy(&options[*offset + 2], p->data, p->length);
int dhcp6_option_append_vendor_option(uint8_t **buf, size_t *buflen, OrderedHashmap *vendor_options) {
sd_dhcp6_option *options;
- Iterator i;
int r;
assert(buf);
assert(buflen);
assert(vendor_options);
- ORDERED_HASHMAP_FOREACH(options, vendor_options, i) {
+ ORDERED_HASHMAP_FOREACH(options, vendor_options) {
_cleanup_free_ uint8_t *p = NULL;
size_t total;
static int client_append_common_discover_request_options(sd_dhcp_client *client, DHCPPacket *packet, size_t *optoffset, size_t optlen) {
sd_dhcp_option *j;
- Iterator i;
int r;
assert(client);
return r;
}
- ORDERED_HASHMAP_FOREACH(j, client->extra_options, i) {
+ ORDERED_HASHMAP_FOREACH(j, client->extra_options) {
r = dhcp_option_append(&packet->dhcp, optlen, optoffset, 0,
j->option, j->length, j->data);
if (r < 0)
_cleanup_free_ DHCPPacket *packet = NULL;
be32_t lease_time;
sd_dhcp_option *j;
- Iterator i;
size_t offset;
int r;
return r;
}
- ORDERED_HASHMAP_FOREACH(j, server->extra_options, i) {
+ ORDERED_HASHMAP_FOREACH(j, server->extra_options) {
r = dhcp_option_append(&packet->dhcp, req->max_optlen, &offset, 0,
j->option, j->length, j->data);
if (r < 0)
IN6ADDR_ALL_DHCP6_RELAY_AGENTS_AND_SERVERS_INIT;
struct sd_dhcp6_option *j;
size_t len, optlen = 512;
- Iterator i;
uint8_t *opt;
int r;
usec_t elapsed_usec;
if (r < 0)
return r;
- ORDERED_HASHMAP_FOREACH(j, client->extra_options, i) {
+ ORDERED_HASHMAP_FOREACH(j, client->extra_options) {
r = dhcp6_option_append(&opt, &optlen, j->option, j->length, j->data);
if (r < 0)
return r;
_public_ int sd_lldp_get_neighbors(sd_lldp *lldp, sd_lldp_neighbor ***ret) {
sd_lldp_neighbor **l = NULL, *n;
- Iterator i;
int k = 0, r;
assert_return(lldp, -EINVAL);
return r;
}
- HASHMAP_FOREACH(n, lldp->neighbor_by_id, i)
+ HASHMAP_FOREACH(n, lldp->neighbor_by_id)
l[k++] = sd_lldp_neighbor_ref(n);
assert((size_t) k == hashmap_size(lldp->neighbor_by_id));
return;
if (BUS_MATCH_CAN_HASH(node->type)) {
- Iterator i;
- HASHMAP_FOREACH(c, node->compare.children, i)
+ HASHMAP_FOREACH(c, node->compare.children)
bus_match_free(c);
assert(hashmap_isempty(node->compare.children));
putchar('\n');
if (BUS_MATCH_CAN_HASH(node->type)) {
- Iterator i;
- HASHMAP_FOREACH(c, node->compare.children, i)
+ HASHMAP_FOREACH(c, node->compare.children)
bus_match_dump(c, level + 1);
}
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_set_free_free_ Set *s = NULL;
- Iterator i;
char *path;
int r;
if (r < 0)
return r;
- SET_FOREACH(path, s, i) {
+ SET_FOREACH(path, s) {
r = object_manager_serialize_path_and_fallbacks(bus, reply, path, &error);
if (r < 0)
return bus_maybe_reply_error(m, r, &error);
int bus_start_running(sd_bus *bus) {
struct reply_callback *c;
- Iterator i;
usec_t n;
int r;
* adding a fixed value to all entries should not alter the internal order. */
n = now(CLOCK_MONOTONIC);
- ORDERED_HASHMAP_FOREACH(c, bus->reply_callbacks, i) {
+ ORDERED_HASHMAP_FOREACH(c, bus->reply_callbacks) {
if (c->timeout_usec == 0)
continue;
static bool match_sysattr(sd_device_enumerator *enumerator, sd_device *device) {
const char *sysattr;
const char *value;
- Iterator i;
assert(enumerator);
assert(device);
- HASHMAP_FOREACH_KEY(value, sysattr, enumerator->nomatch_sysattr, i)
+ HASHMAP_FOREACH_KEY(value, sysattr, enumerator->nomatch_sysattr)
if (match_sysattr_value(device, sysattr, value))
return false;
- HASHMAP_FOREACH_KEY(value, sysattr, enumerator->match_sysattr, i)
+ HASHMAP_FOREACH_KEY(value, sysattr, enumerator->match_sysattr)
if (!match_sysattr_value(device, sysattr, value))
return false;
static bool match_property(sd_device_enumerator *enumerator, sd_device *device) {
const char *property;
const char *value;
- Iterator i;
assert(enumerator);
assert(device);
if (hashmap_isempty(enumerator->match_property))
return true;
- HASHMAP_FOREACH_KEY(value, property, enumerator->match_property, i) {
+ HASHMAP_FOREACH_KEY(value, property, enumerator->match_property) {
const char *property_dev, *value_dev;
FOREACH_DEVICE_PROPERTY(device, property_dev, value_dev) {
static bool match_tag(sd_device_enumerator *enumerator, sd_device *device) {
const char *tag;
- Iterator i;
assert(enumerator);
assert(device);
- SET_FOREACH(tag, enumerator->match_tag, i)
+ SET_FOREACH(tag, enumerator->match_tag)
if (!sd_device_has_tag(device, tag))
return false;
static bool match_parent(sd_device_enumerator *enumerator, sd_device *device) {
const char *syspath_parent, *syspath;
- Iterator i;
assert(enumerator);
assert(device);
assert_se(sd_device_get_syspath(device, &syspath) >= 0);
- SET_FOREACH(syspath_parent, enumerator->match_parent, i)
+ SET_FOREACH(syspath_parent, enumerator->match_parent)
if (path_startswith(syspath, syspath_parent))
return true;
static bool match_sysname(sd_device_enumerator *enumerator, const char *sysname) {
const char *sysname_match;
- Iterator i;
assert(enumerator);
assert(sysname);
if (set_isempty(enumerator->match_sysname))
return true;
- SET_FOREACH(sysname_match, enumerator->match_sysname, i)
+ SET_FOREACH(sysname_match, enumerator->match_sysname)
if (fnmatch(sysname_match, sysname, 0) == 0)
return true;
static bool match_subsystem(sd_device_enumerator *enumerator, const char *subsystem) {
const char *subsystem_match;
- Iterator i;
assert(enumerator);
if (!subsystem)
return false;
- SET_FOREACH(subsystem_match, enumerator->nomatch_subsystem, i)
+ SET_FOREACH(subsystem_match, enumerator->nomatch_subsystem)
if (fnmatch(subsystem_match, subsystem, 0) == 0)
return false;
if (set_isempty(enumerator->match_subsystem))
return true;
- SET_FOREACH(subsystem_match, enumerator->match_subsystem, i)
+ SET_FOREACH(subsystem_match, enumerator->match_subsystem)
if (fnmatch(subsystem_match, subsystem, 0) == 0)
return true;
static int enumerator_scan_devices_tags(sd_device_enumerator *enumerator) {
const char *tag;
- Iterator i;
int r = 0;
assert(enumerator);
- SET_FOREACH(tag, enumerator->match_tag, i) {
+ SET_FOREACH(tag, enumerator->match_tag) {
int k;
k = enumerator_scan_devices_tag(enumerator, tag);
static int enumerator_scan_devices_children(sd_device_enumerator *enumerator) {
const char *path;
int r = 0, k;
- Iterator i;
- SET_FOREACH(path, enumerator->match_parent, i) {
+ SET_FOREACH(path, enumerator->match_parent) {
k = parent_add_child(enumerator, path);
if (k < 0)
r = k;
static int passes_filter(sd_device_monitor *m, sd_device *device) {
const char *tag, *subsystem, *devtype, *s, *d = NULL;
- Iterator i;
int r;
assert_return(m, -EINVAL);
if (r < 0 && r != -ENOENT)
return r;
- HASHMAP_FOREACH_KEY(devtype, subsystem, m->subsystem_filter, i) {
+ HASHMAP_FOREACH_KEY(devtype, subsystem, m->subsystem_filter) {
if (!streq(s, subsystem))
continue;
if (set_isempty(m->tag_filter))
return 1;
- SET_FOREACH(tag, m->tag_filter, i)
+ SET_FOREACH(tag, m->tag_filter)
if (sd_device_has_tag(device, tag) > 0)
return 1;
struct sock_fprog filter;
const char *subsystem, *devtype, *tag;
unsigned i = 0;
- Iterator it;
assert_return(m, -EINVAL);
int tag_matches = set_size(m->tag_filter);
/* add all tags matches */
- SET_FOREACH(tag, m->tag_filter, it) {
+ SET_FOREACH(tag, m->tag_filter) {
uint64_t tag_bloom_bits = string_bloom64(tag);
uint32_t tag_bloom_hi = tag_bloom_bits >> 32;
uint32_t tag_bloom_lo = tag_bloom_bits & 0xffffffff;
/* add all subsystem matches */
if (!hashmap_isempty(m->subsystem_filter)) {
- HASHMAP_FOREACH_KEY(devtype, subsystem, m->subsystem_filter, it) {
+ HASHMAP_FOREACH_KEY(devtype, subsystem, m->subsystem_filter) {
uint32_t hash = string_hash32(subsystem);
/* load device subsystem value in A */
int device_copy_properties(sd_device *device_dst, sd_device *device_src) {
const char *property, *value;
- Iterator i;
int r;
assert(device_dst);
if (r < 0)
return r;
- ORDERED_HASHMAP_FOREACH_KEY(value, property, device_src->properties_db, i) {
+ ORDERED_HASHMAP_FOREACH_KEY(value, property, device_src->properties_db) {
r = device_add_property_aux(device_dst, property, value, true);
if (r < 0)
return r;
}
- ORDERED_HASHMAP_FOREACH_KEY(value, property, device_src->properties, i) {
+ ORDERED_HASHMAP_FOREACH_KEY(value, property, device_src->properties) {
r = device_add_property_aux(device_dst, property, value, false);
if (r < 0)
return r;
if (has_info) {
const char *property, *value, *tag;
- Iterator i;
if (major(device->devnum) > 0) {
const char *devlink;
if (device->usec_initialized > 0)
fprintf(f, "I:"USEC_FMT"\n", device->usec_initialized);
- ORDERED_HASHMAP_FOREACH_KEY(value, property, device->properties_db, i)
+ ORDERED_HASHMAP_FOREACH_KEY(value, property, device->properties_db)
fprintf(f, "E:%s=%s\n", property, value);
FOREACH_DEVICE_TAG(device, tag)
fprintf(f, "G:%s\n", tag); /* Any tag */
- SET_FOREACH(tag, device->current_tags, i)
+ SET_FOREACH(tag, device->current_tags)
fprintf(f, "Q:%s\n", tag); /* Current tag */
}
size_t ret_allocated = 0, ret_len;
_cleanup_free_ char *ret = NULL;
const char *tag;
- Iterator i;
if (!GREEDY_REALLOC(ret, ret_allocated, 2))
return NULL;
strcpy(ret, ":");
ret_len = 1;
- SET_FOREACH(tag, s, i) {
+ SET_FOREACH(tag, s) {
char *e;
if (!GREEDY_REALLOC(ret, ret_allocated, ret_len + strlen(tag) + 2))
static int process_child(sd_event *e) {
sd_event_source *s;
- Iterator i;
int r;
assert(e);
the callback still sees the process as a zombie.
*/
- HASHMAP_FOREACH(s, e->child_sources, i) {
+ HASHMAP_FOREACH(s, e->child_sources) {
assert(s->type == SOURCE_CHILD);
if (s->pending)
if (d->buffer.ev.mask & IN_Q_OVERFLOW) {
struct inode_data *inode_data;
- Iterator i;
/* The queue overran, let's pass this event to all event sources connected to this inotify
* object */
- HASHMAP_FOREACH(inode_data, d->inodes, i) {
+ HASHMAP_FOREACH(inode_data, d->inodes) {
sd_event_source *s;
LIST_FOREACH(inotify.by_inode_data, s, inode_data->event_sources) {
if (s->type != SOURCE_POST) {
sd_event_source *z;
- Iterator i;
/* If we execute a non-post source, let's mark all
* post sources as pending */
- SET_FOREACH(z, s->event->post_sources, i) {
+ SET_FOREACH(z, s->event->post_sources) {
if (z->enabled == SD_EVENT_OFF)
continue;
else {
_cleanup_free_ struct udev_list_entry **buf = NULL;
struct udev_list_entry *entry, **p;
- Iterator i;
size_t j;
buf = new(struct udev_list_entry *, n);
return NULL;
p = buf;
- HASHMAP_FOREACH(entry, list->unique_entries, i)
+ HASHMAP_FOREACH(entry, list->unique_entries)
*p++ = entry;
typesafe_qsort(buf, n, udev_list_entry_compare_func);
_cleanup_closedir_ DIR *dir = NULL;
struct dirent *dent;
sd_device *d;
- Iterator i;
char *n;
int r;
}
r = 0;
- SET_FOREACH(n, nodes, i) {
+ SET_FOREACH(n, nodes) {
int k;
log_debug("Changing ACLs at %s for seat %s (uid "UID_FMT"→"UID_FMT"%s%s)",
Session *s;
bool idle_hint;
dual_timestamp ts = DUAL_TIMESTAMP_NULL;
- Iterator i;
assert(m);
idle_hint = !manager_is_inhibited(m, INHIBIT_IDLE, INHIBIT_BLOCK, t, false, false, 0, NULL);
- HASHMAP_FOREACH(s, m->sessions, i) {
+ HASHMAP_FOREACH(s, m->sessions) {
dual_timestamp k;
int ih;
}
bool manager_is_lid_closed(Manager *m) {
- Iterator i;
Button *b;
- HASHMAP_FOREACH(b, m->buttons, i)
+ HASHMAP_FOREACH(b, m->buttons)
if (b->lid_closed)
return true;
}
static bool manager_is_docked(Manager *m) {
- Iterator i;
Button *b;
- HASHMAP_FOREACH(b, m->buttons, i)
+ HASHMAP_FOREACH(b, m->buttons)
if (b->docked)
return true;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = userdata;
Session *session;
- Iterator i;
int r;
assert(message);
if (r < 0)
return r;
- HASHMAP_FOREACH(session, m->sessions, i) {
+ HASHMAP_FOREACH(session, m->sessions) {
_cleanup_free_ char *p = NULL;
p = session_bus_path(session);
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = userdata;
User *user;
- Iterator i;
int r;
assert(message);
if (r < 0)
return r;
- HASHMAP_FOREACH(user, m->users, i) {
+ HASHMAP_FOREACH(user, m->users) {
_cleanup_free_ char *p = NULL;
p = user_bus_path(user);
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = userdata;
Seat *seat;
- Iterator i;
int r;
assert(message);
if (r < 0)
return r;
- HASHMAP_FOREACH(seat, m->seats, i) {
+ HASHMAP_FOREACH(seat, m->seats) {
_cleanup_free_ char *p = NULL;
p = seat_bus_path(seat);
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = userdata;
Inhibitor *inhibitor;
- Iterator i;
int r;
assert(message);
if (r < 0)
return r;
- HASHMAP_FOREACH(inhibitor, m->inhibitors, i) {
+ HASHMAP_FOREACH(inhibitor, m->inhibitors) {
r = sd_bus_message_append(reply, "(ssssuu)",
strempty(inhibit_what_to_string(inhibitor->what)),
uid_t uid) {
Session *session;
- Iterator i;
assert(m);
/* Check for other users' sessions. Greeter sessions do not
* count, and non-login sessions do not count either. */
- HASHMAP_FOREACH(session, m->sessions, i)
+ HASHMAP_FOREACH(session, m->sessions)
if (session->class == SESSION_USER &&
session->user->user_record->uid != uid)
return true;
int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = userdata;
Session *session;
- Iterator i;
int b, r;
assert(message);
/* systemd finished reloading, let's recheck all our sessions */
log_debug("System manager has been reloaded, rechecking sessions...");
- HASHMAP_FOREACH(session, m->sessions, i)
+ HASHMAP_FOREACH(session, m->sessions)
session_add_to_gc_queue(session);
return 0;
InhibitWhat manager_inhibit_what(Manager *m, InhibitMode mm) {
Inhibitor *i;
- Iterator j;
InhibitWhat what = 0;
assert(m);
- HASHMAP_FOREACH(i, m->inhibitors, j)
+ HASHMAP_FOREACH(i, m->inhibitors)
if (i->mode == mm && i->started)
what |= i->what;
Inhibitor **offending) {
Inhibitor *i;
- Iterator j;
struct dual_timestamp ts = DUAL_TIMESTAMP_NULL;
bool inhibited = false;
assert(m);
assert(w > 0 && w < _INHIBIT_WHAT_MAX);
- HASHMAP_FOREACH(i, m->inhibitors, j) {
+ HASHMAP_FOREACH(i, m->inhibitors) {
if (!i->started)
continue;
sd_bus_message *message;
Manager *m = userdata;
Seat *seat;
- Iterator i;
int r;
assert(bus);
assert(path);
assert(nodes);
- HASHMAP_FOREACH(seat, m->seats, i) {
+ HASHMAP_FOREACH(seat, m->seats) {
char *p;
p = seat_bus_path(seat);
sd_bus_message *message;
Manager *m = userdata;
Session *session;
- Iterator i;
int r;
assert(bus);
assert(path);
assert(nodes);
- HASHMAP_FOREACH(session, m->sessions, i) {
+ HASHMAP_FOREACH(session, m->sessions) {
char *p;
p = session_bus_path(session);
int session_send_lock_all(Manager *m, bool lock) {
Session *session;
- Iterator i;
int r = 0;
assert(m);
- HASHMAP_FOREACH(session, m->sessions, i) {
+ HASHMAP_FOREACH(session, m->sessions) {
int k;
k = session_send_lock(session, lock);
void session_device_complete_pause(SessionDevice *sd) {
SessionDevice *iter;
- Iterator i;
if (!sd->active)
return;
session_device_stop(sd);
/* if not all devices are paused, wait for further completion events */
- HASHMAP_FOREACH(iter, sd->session->devices, i)
+ HASHMAP_FOREACH(iter, sd->session->devices)
if (iter->active)
return;
void session_device_resume_all(Session *s) {
SessionDevice *sd;
- Iterator i;
assert(s);
- HASHMAP_FOREACH(sd, s->devices, i) {
+ HASHMAP_FOREACH(sd, s->devices) {
if (sd->active)
continue;
void session_device_pause_all(Session *s) {
SessionDevice *sd;
- Iterator i;
assert(s);
- HASHMAP_FOREACH(sd, s->devices, i) {
+ HASHMAP_FOREACH(sd, s->devices) {
if (!sd->active)
continue;
unsigned session_device_try_pause_all(Session *s) {
unsigned num_pending = 0;
SessionDevice *sd;
- Iterator i;
assert(s);
- HASHMAP_FOREACH(sd, s->devices, i) {
+ HASHMAP_FOREACH(sd, s->devices) {
if (!sd->active)
continue;
static void session_save_devices(Session *s, FILE *f) {
SessionDevice *sd;
- Iterator i;
if (!hashmap_isempty(s->devices)) {
fprintf(f, "DEVICES=");
- HASHMAP_FOREACH(sd, s->devices, i)
+ HASHMAP_FOREACH(sd, s->devices)
fprintf(f, "%u:%u ", major(sd->dev), minor(sd->dev));
fprintf(f, "\n");
}
sd_bus_message *message;
Manager *m = userdata;
User *user;
- Iterator i;
int r;
assert(bus);
assert(path);
assert(nodes);
- HASHMAP_FOREACH(user, m->users, i) {
+ HASHMAP_FOREACH(user, m->users) {
char *p;
p = user_bus_path(user);
User *user;
Button *button;
Inhibitor *inhibitor;
- Iterator i;
assert(m);
manager_read_utmp(m);
/* And start everything */
- HASHMAP_FOREACH(seat, m->seats, i)
+ HASHMAP_FOREACH(seat, m->seats)
(void) seat_start(seat);
- HASHMAP_FOREACH(user, m->users, i)
+ HASHMAP_FOREACH(user, m->users)
(void) user_start(user);
- HASHMAP_FOREACH(session, m->sessions, i)
+ HASHMAP_FOREACH(session, m->sessions)
(void) session_start(session, NULL, NULL);
- HASHMAP_FOREACH(inhibitor, m->inhibitors, i) {
+ HASHMAP_FOREACH(inhibitor, m->inhibitors) {
(void) inhibitor_start(inhibitor);
/* Let's see if the inhibitor is dead now, then remove it */
}
}
- HASHMAP_FOREACH(button, m->buttons, i)
+ HASHMAP_FOREACH(button, m->buttons)
button_check_switches(button);
manager_dispatch_idle_action(NULL, 0, m);
_cleanup_hashmap_free_ Hashmap *images = NULL;
_cleanup_strv_free_ char **l = NULL;
Image *image;
- Iterator i;
int r;
assert(bus);
if (r < 0)
return r;
- HASHMAP_FOREACH(image, images, i) {
+ HASHMAP_FOREACH(image, images) {
char *p;
p = image_bus_path(image->name);
_cleanup_strv_free_ char **l = NULL;
Machine *machine = NULL;
Manager *m = userdata;
- Iterator i;
int r;
assert(bus);
assert(path);
assert(nodes);
- HASHMAP_FOREACH(machine, m->machines, i) {
+ HASHMAP_FOREACH(machine, m->machines) {
char *p;
p = machine_bus_path(machine);
int manager_find_machine_for_uid(Manager *m, uid_t uid, Machine **ret_machine, uid_t *ret_internal_uid) {
Machine *machine;
- Iterator i;
int r;
assert(m);
/* Finds the machine for the specified host UID and returns it along with the UID translated into the
* internal UID inside the machine */
- HASHMAP_FOREACH(machine, m->machines, i) {
+ HASHMAP_FOREACH(machine, m->machines) {
uid_t converted;
r = machine_owns_uid(machine, uid, &converted);
int manager_find_machine_for_gid(Manager *m, gid_t gid, Machine **ret_machine, gid_t *ret_internal_gid) {
Machine *machine;
- Iterator i;
int r;
assert(m);
assert(gid_is_valid(gid));
- HASHMAP_FOREACH(machine, m->machines, i) {
+ HASHMAP_FOREACH(machine, m->machines) {
gid_t converted;
r = machine_owns_gid(machine, gid, &converted);
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *m = userdata;
Machine *machine;
- Iterator i;
int r;
assert(message);
if (r < 0)
return sd_bus_error_set_errno(error, r);
- HASHMAP_FOREACH(machine, m->machines, i) {
+ HASHMAP_FOREACH(machine, m->machines) {
_cleanup_free_ char *p = NULL;
p = machine_bus_path(machine);
_cleanup_hashmap_free_ Hashmap *images = NULL;
_unused_ Manager *m = userdata;
Image *image;
- Iterator i;
int r;
assert(message);
if (r < 0)
return r;
- HASHMAP_FOREACH(image, images, i) {
+ HASHMAP_FOREACH(image, images) {
_cleanup_free_ char *p = NULL;
p = image_bus_path(image->name);
_cleanup_hashmap_free_ Hashmap *images = NULL;
bool success = true;
Image *image;
- Iterator i;
ssize_t l;
errno_pipe_fd[0] = safe_close(errno_pipe_fd[0]);
goto child_fail;
}
- HASHMAP_FOREACH(image, images, i) {
+ HASHMAP_FOREACH(image, images) {
/* We can't remove vendor images (i.e. those in /usr) */
if (IMAGE_IS_VENDOR(image))
int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = userdata;
Machine *machine;
- Iterator i;
int b, r;
assert(message);
/* systemd finished reloading, let's recheck all our machines */
log_debug("System manager has been reloaded, rechecking machines...");
- HASHMAP_FOREACH(machine, m->machines, i)
+ HASHMAP_FOREACH(machine, m->machines)
machine_add_to_gc_queue(machine);
return 0;
static int manager_startup(Manager *m) {
Machine *machine;
- Iterator i;
int r;
assert(m);
manager_gc(m, false);
/* And start everything */
- HASHMAP_FOREACH(machine, m->machines, i)
+ HASHMAP_FOREACH(machine, m->machines)
machine_start(machine, NULL, NULL);
return 0;
Network *network;
NetDev *netdev;
Link *link;
- Iterator i;
int k, r;
const char *p;
if (r < 0)
return log_error_errno(r, "Failed to create directory " NETWORKD_UNIT_DIRECTORY ": %m");
- HASHMAP_FOREACH(network, context->networks_by_name, i) {
+ HASHMAP_FOREACH(network, context->networks_by_name) {
k = network_save(network, p);
if (k < 0 && r >= 0)
r = k;
}
- HASHMAP_FOREACH(netdev, context->netdevs_by_name, i) {
+ HASHMAP_FOREACH(netdev, context->netdevs_by_name) {
k = netdev_save(netdev, p);
if (k < 0 && r >= 0)
r = k;
}
- HASHMAP_FOREACH(link, context->links_by_name, i) {
+ HASHMAP_FOREACH(link, context->links_by_name) {
k = link_save(link, p);
if (k < 0 && r >= 0)
r = k;
int context_merge_networks(Context *context) {
Network *all, *network;
Route *route;
- Iterator i;
int r;
assert(context);
if (hashmap_size(context->networks_by_name) <= 1)
return 0;
- HASHMAP_FOREACH(network, context->networks_by_name, i) {
+ HASHMAP_FOREACH(network, context->networks_by_name) {
if (network == all)
continue;
}
if (b->arp_interval > 0 && !ordered_set_isempty(b->arp_ip_targets)) {
- Iterator i;
void *val;
int n = 0;
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not open contaniner IFLA_BOND_ARP_IP_TARGET : %m");
- ORDERED_SET_FOREACH(val, b->arp_ip_targets, i) {
+ ORDERED_SET_FOREACH(val, b->arp_ip_targets) {
r = sd_netlink_message_append_u32(m, n++, PTR_TO_UINT32(val));
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m");
static int l2tp_acquire_local_address(L2tpTunnel *t, Link *link, union in_addr_union *ret) {
Address *a;
- Iterator i;
assert(t);
assert(link);
return 0;
}
- SET_FOREACH(a, link->addresses, i)
+ SET_FOREACH(a, link->addresses)
if (l2tp_acquire_local_address_one(t, a, ret) >= 0)
return 1;
- SET_FOREACH(a, link->addresses_foreign, i)
+ SET_FOREACH(a, link->addresses_foreign)
if (l2tp_acquire_local_address_one(t, a, ret) >= 0)
return 1;
static int l2tp_create_tunnel_handler(sd_netlink *rtnl, sd_netlink_message *m, NetDev *netdev) {
L2tpSession *session;
L2tpTunnel *t;
- Iterator i;
int r;
assert(netdev);
log_netdev_debug(netdev, "L2TP tunnel is created");
- ORDERED_HASHMAP_FOREACH(session, t->sessions_by_section, i)
+ ORDERED_HASHMAP_FOREACH(session, t->sessions_by_section)
(void) l2tp_create_session(netdev, session);
return 1;
static int netdev_l2tp_tunnel_verify(NetDev *netdev, const char *filename) {
L2tpTunnel *t;
L2tpSession *session;
- Iterator i;
assert(netdev);
assert(filename);
"%s: L2TP tunnel without tunnel IDs configured. Ignoring",
filename);
- ORDERED_HASHMAP_FOREACH(session, t->sessions_by_section, i)
+ ORDERED_HASHMAP_FOREACH(session, t->sessions_by_section)
if (l2tp_session_verify(session) < 0)
l2tp_session_free(session);
static int netdev_macsec_configure(NetDev *netdev, Link *link, sd_netlink_message *m) {
TransmitAssociation *a;
ReceiveChannel *c;
- Iterator i;
MACsec *s;
int r;
s = MACSEC(netdev);
assert(s);
- ORDERED_HASHMAP_FOREACH(a, s->transmit_associations_by_section, i) {
+ ORDERED_HASHMAP_FOREACH(a, s->transmit_associations_by_section) {
r = netdev_macsec_configure_transmit_association(netdev, a);
if (r < 0)
return r;
}
- ORDERED_HASHMAP_FOREACH(c, s->receive_channels, i) {
+ ORDERED_HASHMAP_FOREACH(c, s->receive_channels) {
r = netdev_macsec_configure_receive_channel(netdev, c);
if (r < 0)
return r;
TransmitAssociation *a;
ReceiveAssociation *n;
ReceiveChannel *c;
- Iterator i;
uint8_t an, encoding_an;
bool use_for_encoding;
int r;
assert(v);
assert(filename);
- ORDERED_HASHMAP_FOREACH(c, v->receive_channels_by_section, i) {
+ ORDERED_HASHMAP_FOREACH(c, v->receive_channels_by_section) {
r = macsec_receive_channel_verify(c);
if (r < 0)
macsec_receive_channel_free(c);
an = 0;
use_for_encoding = false;
encoding_an = 0;
- ORDERED_HASHMAP_FOREACH(a, v->transmit_associations_by_section, i) {
+ ORDERED_HASHMAP_FOREACH(a, v->transmit_associations_by_section) {
r = macsec_transmit_association_verify(a);
if (r < 0) {
macsec_transmit_association_free(a);
assert(encoding_an < MACSEC_MAX_ASSOCIATION_NUMBER);
v->encoding_an = encoding_an;
- ORDERED_HASHMAP_FOREACH(n, v->receive_associations_by_section, i) {
+ ORDERED_HASHMAP_FOREACH(n, v->receive_associations_by_section) {
r = macsec_receive_association_verify(n);
if (r < 0)
macsec_receive_association_free(n);
assert(m);
if (m->mode == NETDEV_MACVLAN_MODE_SOURCE && !set_isempty(m->match_source_mac)) {
- Iterator i;
const struct ether_addr *mac_addr;
r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_MACADDR_MODE, MACVLAN_MACADDR_SET);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not open IFLA_MACVLAN_MACADDR_DATA container: %m");
- SET_FOREACH(mac_addr, m->match_source_mac, i) {
+ SET_FOREACH(mac_addr, m->match_source_mac) {
r = sd_netlink_message_append_ether_addr(req, IFLA_MACVLAN_MACADDR, mac_addr);
if (r < 0)
return log_netdev_error_errno(netdev, r, "Could not append IFLA_MACVLAN_MACADDR attribute: %m");
};
WireguardPeer *peer;
Wireguard *w;
- Iterator i;
int r;
assert(netdev);
w = WIREGUARD(netdev);
assert(w);
- SET_FOREACH(peer, w->peers_with_unresolved_endpoint, i) {
+ SET_FOREACH(peer, w->peers_with_unresolved_endpoint) {
r = resolve_getaddrinfo(netdev->manager->resolve,
NULL,
peer->endpoint_host,
_cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
_cleanup_set_free_ Set *indexes = NULL;
int index, r, i;
- Iterator j;
void *p;
r = sd_netlink_open(&rtnl);
return log_oom();
}
- SET_FOREACH(p, indexes, j) {
+ SET_FOREACH(p, indexes) {
index = PTR_TO_INT(p);
r = link_up_down_send_message(rtnl, argv[0], index);
if (r < 0) {
_cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
_cleanup_set_free_ Set *indexes = NULL;
int index, r, i;
- Iterator j;
void *p;
r = sd_netlink_open(&rtnl);
return log_oom();
}
- SET_FOREACH(p, indexes, j) {
+ SET_FOREACH(p, indexes) {
index = PTR_TO_INT(p);
r = link_delete_send_message(rtnl, index);
if (r < 0) {
_cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
_cleanup_set_free_ Set *indexes = NULL;
int index, i, r;
- Iterator j;
void *p;
r = sd_bus_open_system(&bus);
return log_oom();
}
- SET_FOREACH(p, indexes, j) {
+ SET_FOREACH(p, indexes) {
index = PTR_TO_INT(p);
r = bus_call_method(bus, bus_network_mgr, "ReconfigureLink", &error, NULL, "i", index);
if (r < 0) {
const union in_addr_union *u,
unsigned prefixlen) {
- Iterator i;
Link *l;
Network *n;
assert(p);
assert(u);
- HASHMAP_FOREACH(l, p->manager->links, i) {
+ HASHMAP_FOREACH(l, p->manager->links) {
Address *a;
- Iterator j;
/* Don't clash with assigned addresses */
- SET_FOREACH(a, l->addresses, j) {
+ SET_FOREACH(a, l->addresses) {
if (a->family != p->family)
continue;
}
/* And don't clash with configured but un-assigned addresses either */
- ORDERED_HASHMAP_FOREACH(n, p->manager->networks, i) {
+ ORDERED_HASHMAP_FOREACH(n, p->manager->networks) {
Address *a;
LIST_FOREACH(addresses, a, n->static_addresses) {
if (address->link && !address->acd) {
NDiscAddress *n;
- Iterator i;
set_remove(address->link->addresses, address);
set_remove(address->link->addresses_foreign, address);
set_remove(address->link->dhcp6_addresses_old, address);
set_remove(address->link->dhcp6_pd_addresses, address);
set_remove(address->link->dhcp6_pd_addresses_old, address);
- SET_FOREACH(n, address->link->ndisc_addresses, i)
+ SET_FOREACH(n, address->link->ndisc_addresses)
if (n->address == address)
free(set_remove(address->link->ndisc_addresses, n));
static bool address_exists_internal(Set *addresses, int family, const union in_addr_union *in_addr) {
Address *address;
- Iterator i;
- SET_FOREACH(address, addresses, i) {
+ SET_FOREACH(address, addresses) {
if (address->family != family)
continue;
if (in_addr_equal(address->family, &address->in_addr, in_addr))
Link *l = userdata;
sd_dhcp_server *s;
DHCPLease *lease;
- Iterator i;
int r;
assert(reply);
if (r < 0)
return r;
- HASHMAP_FOREACH(lease, s->leases_by_client_id, i) {
+ HASHMAP_FOREACH(lease, s->leases_by_client_id) {
r = sd_bus_message_open_container(reply, 'r', "uayayayayt");
if (r < 0)
return r;
sd_dhcp_option *p;
Link *uplink = NULL;
Address *address;
- Iterator i;
int r;
address = link_find_dhcp_server_address(link);
return log_link_error_errno(link, r, "Failed to set timezone for DHCP server: %m");
}
- ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_options, i) {
+ ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_options) {
r = sd_dhcp_server_add_option(link->dhcp_server, p);
if (r == -EEXIST)
continue;
return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m");
}
- ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_vendor_options, i) {
+ ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_vendor_options) {
r = sd_dhcp_server_add_vendor_option(link->dhcp_server, p);
if (r == -EEXIST)
continue;
static int dhcp4_release_old_lease(Link *link) {
Route *route;
- Iterator i;
int k, r = 0;
assert(link);
link_dirty(link);
- SET_FOREACH(route, link->dhcp_routes_old, i) {
+ SET_FOREACH(route, link->dhcp_routes_old) {
k = route_remove(route, link, NULL);
if (k < 0)
r = k;
static int dhcp4_remove_all(Link *link) {
Route *route;
- Iterator i;
int k, r = 0;
assert(link);
- SET_FOREACH(route, link->dhcp_routes, i) {
+ SET_FOREACH(route, link->dhcp_routes) {
k = route_remove(route, link, dhcp4_remove_route_handler);
if (k < 0)
r = k;
int dhcp4_configure(Link *link) {
sd_dhcp_option *send_option;
void *request_options;
- Iterator i;
int r;
assert(link);
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for timezone: %m");
}
- SET_FOREACH(request_options, link->network->dhcp_request_options, i) {
+ SET_FOREACH(request_options, link->network->dhcp_request_options) {
uint32_t option = PTR_TO_UINT32(request_options);
r = sd_dhcp_client_set_request_option(link->dhcp_client, option);
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set request flag for '%u': %m", option);
}
- ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp_client_send_options, i) {
+ ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp_client_send_options) {
r = sd_dhcp_client_add_option(link->dhcp_client, send_option);
if (r == -EEXIST)
continue;
return log_link_error_errno(link, r, "DHCP4 CLIENT: Failed to set send option: %m");
}
- ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp_client_send_vendor_options, i) {
+ ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp_client_send_vendor_options) {
r = sd_dhcp_client_add_vendor_option(link->dhcp_client, send_option);
if (r == -EEXIST)
continue;
static int dhcp6_pd_address_callback(Address *address) {
Address *a;
- Iterator i;
assert(address);
assert(address->link);
/* Make this called only once */
- SET_FOREACH(a, address->link->dhcp6_pd_addresses, i)
+ SET_FOREACH(a, address->link->dhcp6_pd_addresses)
a->callback = NULL;
return dhcp6_pd_remove_old(address->link, true);
static int dhcp6_pd_remove_old(Link *link, bool force) {
Address *address;
Route *route;
- Iterator i;
int k, r = 0;
assert(link);
if (!force) {
bool set_callback = !set_isempty(link->dhcp6_pd_addresses);
- SET_FOREACH(address, link->dhcp6_pd_addresses, i)
+ SET_FOREACH(address, link->dhcp6_pd_addresses)
if (address_is_ready(address)) {
set_callback = false;
break;
}
if (set_callback) {
- SET_FOREACH(address, link->dhcp6_pd_addresses, i)
+ SET_FOREACH(address, link->dhcp6_pd_addresses)
address->callback = dhcp6_pd_address_callback;
return 0;
}
link_dirty(link);
- SET_FOREACH(route, link->dhcp6_pd_routes_old, i) {
+ SET_FOREACH(route, link->dhcp6_pd_routes_old) {
k = route_remove(route, link, NULL);
if (k < 0)
r = k;
dhcp6_pd_free(hashmap_get(link->manager->dhcp6_prefixes, &route->dst.in6));
}
- SET_FOREACH(address, link->dhcp6_pd_addresses_old, i) {
+ SET_FOREACH(address, link->dhcp6_pd_addresses_old) {
k = address_remove(address, link, NULL);
if (k < 0)
r = k;
int dhcp6_pd_remove(Link *link) {
Address *address;
Route *route;
- Iterator i;
int k, r = 0;
assert(link);
link_dirty(link);
- SET_FOREACH(route, link->dhcp6_pd_routes, i) {
+ SET_FOREACH(route, link->dhcp6_pd_routes) {
k = route_remove(route, link, NULL);
if (k < 0)
r = k;
dhcp6_pd_free(hashmap_get(link->manager->dhcp6_prefixes, &route->dst.in6));
}
- SET_FOREACH(address, link->dhcp6_pd_addresses, i) {
+ SET_FOREACH(address, link->dhcp6_pd_addresses) {
k = address_remove(address, link, NULL);
if (k < 0)
r = k;
uint32_t lifetime_valid,
bool assign_preferred_subnet_id) {
- Iterator i;
Link *link;
int r;
assert(masked_pd_prefix);
assert(pd_prefix_len <= 64);
- HASHMAP_FOREACH(link, dhcp6_link->manager->links, i) {
+ HASHMAP_FOREACH(link, dhcp6_link->manager->links) {
_cleanup_free_ char *assigned_buf = NULL;
union in_addr_union assigned_prefix;
static void dhcp6_pd_prefix_lost(Link *dhcp6_link) {
Link *link;
- Iterator i;
int r;
assert(dhcp6_link);
assert(dhcp6_link->manager);
- HASHMAP_FOREACH(link, dhcp6_link->manager->links, i) {
+ HASHMAP_FOREACH(link, dhcp6_link->manager->links) {
if (link == dhcp6_link)
continue;
static int dhcp6_address_callback(Address *address) {
Address *a;
- Iterator i;
assert(address);
assert(address->link);
/* Make this called only once */
- SET_FOREACH(a, address->link->dhcp6_addresses, i)
+ SET_FOREACH(a, address->link->dhcp6_addresses)
a->callback = NULL;
return dhcp6_remove_old(address->link, true);
static int dhcp6_remove_old(Link *link, bool force) {
Address *address;
Route *route;
- Iterator i;
int k, r = 0;
assert(link);
if (!force) {
bool set_callback = !set_isempty(link->dhcp6_addresses);
- SET_FOREACH(address, link->dhcp6_addresses, i)
+ SET_FOREACH(address, link->dhcp6_addresses)
if (address_is_ready(address)) {
set_callback = false;
break;
}
if (set_callback) {
- SET_FOREACH(address, link->dhcp6_addresses, i)
+ SET_FOREACH(address, link->dhcp6_addresses)
address->callback = dhcp6_address_callback;
return 0;
}
link_dirty(link);
- SET_FOREACH(route, link->dhcp6_routes_old, i) {
+ SET_FOREACH(route, link->dhcp6_routes_old) {
k = route_remove(route, link, NULL);
if (k < 0)
r = k;
}
- SET_FOREACH(address, link->dhcp6_addresses_old, i) {
+ SET_FOREACH(address, link->dhcp6_addresses_old) {
k = address_remove(address, link, NULL);
if (k < 0)
r = k;
static int dhcp6_remove(Link *link) {
Address *address;
Route *route;
- Iterator i;
int k, r = 0;
assert(link);
link_dirty(link);
- SET_FOREACH(route, link->dhcp6_routes, i) {
+ SET_FOREACH(route, link->dhcp6_routes) {
k = route_remove(route, link, NULL);
if (k < 0)
r = k;
}
- SET_FOREACH(address, link->dhcp6_addresses, i) {
+ SET_FOREACH(address, link->dhcp6_addresses) {
k = address_remove(address, link, NULL);
if (k < 0)
r = k;
}
static int dhcp6_pd_prefix_acquired(Link *dhcp6_link) {
- Iterator i;
Link *link;
int r;
assert(dhcp6_link);
assert(dhcp6_link->dhcp6_lease);
- HASHMAP_FOREACH(link, dhcp6_link->manager->links, i) {
+ HASHMAP_FOREACH(link, dhcp6_link->manager->links) {
if (link == dhcp6_link)
continue;
false);
}
- HASHMAP_FOREACH(link, dhcp6_link->manager->links, i) {
+ HASHMAP_FOREACH(link, dhcp6_link->manager->links) {
if (link == dhcp6_link)
continue;
int dhcp6_request_prefix_delegation(Link *link) {
Link *l;
- Iterator i;
assert(link);
assert(link->manager);
log_link_debug(link, "Requesting DHCPv6 prefixes to be delegated for new link");
- HASHMAP_FOREACH(l, link->manager->links, i) {
+ HASHMAP_FOREACH(l, link->manager->links) {
int r, enabled;
if (l == link)
static bool dhcp6_enable_prefix_delegation(Link *dhcp6_link) {
Link *link;
- Iterator i;
assert(dhcp6_link);
assert(dhcp6_link->manager);
- HASHMAP_FOREACH(link, dhcp6_link->manager->links, i) {
+ HASHMAP_FOREACH(link, dhcp6_link->manager->links) {
if (link == dhcp6_link)
continue;
sd_dhcp6_option *send_option;
void *request_options;
const DUID *duid;
- Iterator i;
int r;
assert(link);
if (r < 0)
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set DUID: %m");
- ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp6_client_send_options, i) {
+ ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp6_client_send_options) {
r = sd_dhcp6_client_add_option(client, send_option);
if (r == -EEXIST)
continue;
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set MUD URL: %m");
}
- SET_FOREACH(request_options, link->network->dhcp6_request_options, i) {
+ SET_FOREACH(request_options, link->network->dhcp6_request_options) {
uint32_t option = PTR_TO_UINT32(request_options);
r = sd_dhcp6_client_set_request_option(client, option);
return log_link_error_errno(link, r, "DHCP6 CLIENT: Failed to set vendor class: %m");
}
- ORDERED_HASHMAP_FOREACH(vendor_option, link->network->dhcp6_client_send_vendor_options, i) {
+ ORDERED_HASHMAP_FOREACH(vendor_option, link->network->dhcp6_client_send_vendor_options) {
r = sd_dhcp6_client_add_vendor_option(client, vendor_option);
if (r == -EEXIST)
continue;
Manager *m = userdata;
unsigned c = 0;
Link *link;
- Iterator i;
assert(bus);
assert(path);
if (!l)
return -ENOMEM;
- HASHMAP_FOREACH(link, m->links, i) {
+ HASHMAP_FOREACH(link, m->links) {
char *p;
p = link_bus_path(link);
uint8_t scope = RT_SCOPE_NOWHERE;
bool changed = false;
Address *address;
- Iterator i;
assert(link);
if (carrier_state >= LINK_CARRIER_STATE_CARRIER) {
Link *slave;
- SET_FOREACH(slave, link->slaves, i) {
+ SET_FOREACH(slave, link->slaves) {
link_update_operstate(slave, false);
if (slave->carrier_state < LINK_CARRIER_STATE_CARRIER)
}
}
- SET_FOREACH(address, link->addresses, i) {
+ SET_FOREACH(address, link->addresses) {
if (!address_is_ready(address))
continue;
}
/* for operstate we also take foreign addresses into account */
- SET_FOREACH(address, link->addresses_foreign, i) {
+ SET_FOREACH(address, link->addresses_foreign) {
if (!address_is_ready(address))
continue;
static int link_join_netdevs_after_configured(Link *link) {
NetDev *netdev;
- Iterator i;
int r;
- HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
+ HASHMAP_FOREACH(netdev, link->network->stacked_netdevs) {
if (netdev->ifindex > 0)
/* Assume already enslaved. */
continue;
void link_check_ready(Link *link) {
Address *a;
- Iterator i;
assert(link);
return;
}
- SET_FOREACH(a, link->addresses, i)
+ SET_FOREACH(a, link->addresses)
if (!address_is_ready(a)) {
_cleanup_free_ char *str = NULL;
return;
}
- SET_FOREACH(n, link->ndisc_addresses, i)
+ SET_FOREACH(n, link->ndisc_addresses)
if (!n->marked) {
has_ndisc_address = true;
break;
static int static_address_ready_callback(Address *address) {
Address *a;
- Iterator i;
Link *link;
assert(address);
if (!link->addresses_configured)
return 0;
- SET_FOREACH(a, link->static_addresses, i)
+ SET_FOREACH(a, link->static_addresses)
if (!address_is_ready(a)) {
_cleanup_free_ char *str = NULL;
}
/* This should not be called again */
- SET_FOREACH(a, link->static_addresses, i)
+ SET_FOREACH(a, link->static_addresses)
a->callback = NULL;
link->addresses_ready = true;
static uint32_t link_get_requested_mtu_by_stacked_netdevs(Link *link) {
uint32_t mtu = 0;
NetDev *dev;
- Iterator i;
- HASHMAP_FOREACH(dev, link->network->stacked_netdevs, i)
+ HASHMAP_FOREACH(dev, link->network->stacked_netdevs)
if (dev->kind == NETDEV_KIND_VLAN && dev->mtu > 0)
/* See vlan_dev_change_mtu() in kernel. */
mtu = MAX(mtu, link_reduces_vlan_mtu(link) ? dev->mtu + 4 : dev->mtu);
static int link_handle_bound_to_list(Link *link) {
Link *l;
- Iterator i;
int r;
bool required_up = false;
bool link_is_up = false;
if (link->flags & IFF_UP)
link_is_up = true;
- HASHMAP_FOREACH (l, link->bound_to_links, i)
+ HASHMAP_FOREACH (l, link->bound_to_links)
if (link_has_carrier(l)) {
required_up = true;
break;
}
static int link_handle_bound_by_list(Link *link) {
- Iterator i;
Link *l;
int r;
if (hashmap_isempty(link->bound_by_links))
return 0;
- HASHMAP_FOREACH (l, link->bound_by_links, i) {
+ HASHMAP_FOREACH (l, link->bound_by_links) {
r = link_handle_bound_to_list(l);
if (r < 0)
return r;
static int link_new_bound_by_list(Link *link) {
Manager *m;
Link *carrier;
- Iterator i;
int r;
bool list_updated = false;
m = link->manager;
- HASHMAP_FOREACH(carrier, m->links, i) {
+ HASHMAP_FOREACH(carrier, m->links) {
if (!carrier->network)
continue;
if (list_updated)
link_dirty(link);
- HASHMAP_FOREACH(carrier, link->bound_by_links, i) {
+ HASHMAP_FOREACH(carrier, link->bound_by_links) {
r = link_put_carrier(carrier, link, &carrier->bound_to_links);
if (r < 0)
return r;
static int link_new_bound_to_list(Link *link) {
Manager *m;
Link *carrier;
- Iterator i;
int r;
bool list_updated = false;
m = link->manager;
- HASHMAP_FOREACH (carrier, m->links, i) {
+ HASHMAP_FOREACH (carrier, m->links) {
if (strv_fnmatch(link->network->bind_carrier, carrier->ifname)) {
r = link_put_carrier(link, carrier, &link->bound_to_links);
if (r < 0)
if (list_updated)
link_dirty(link);
- HASHMAP_FOREACH (carrier, link->bound_to_links, i) {
+ HASHMAP_FOREACH (carrier, link->bound_to_links) {
r = link_put_carrier(carrier, link, &carrier->bound_by_links);
if (r < 0)
return r;
static void link_free_bound_to_list(Link *link) {
Link *bound_to;
- Iterator i;
- HASHMAP_FOREACH (bound_to, link->bound_to_links, i) {
+ HASHMAP_FOREACH (bound_to, link->bound_to_links) {
hashmap_remove(link->bound_to_links, INT_TO_PTR(bound_to->ifindex));
if (hashmap_remove(bound_to->bound_by_links, INT_TO_PTR(link->ifindex)))
static void link_free_bound_by_list(Link *link) {
Link *bound_by;
- Iterator i;
- HASHMAP_FOREACH (bound_by, link->bound_by_links, i) {
+ HASHMAP_FOREACH (bound_by, link->bound_by_links) {
hashmap_remove(link->bound_by_links, INT_TO_PTR(bound_by->ifindex));
if (hashmap_remove(bound_by->bound_to_links, INT_TO_PTR(link->ifindex))) {
static int link_enter_join_netdev(Link *link) {
NetDev *netdev;
- Iterator i;
int r;
assert(link);
}
}
- HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
+ HASHMAP_FOREACH(netdev, link->network->stacked_netdevs) {
if (netdev->ifindex > 0)
/* Assume already enslaved. */
static bool link_address_is_dynamic(Link *link, Address *address) {
Route *route;
- Iterator i;
assert(link);
assert(address);
/* Even when the address is leased from a DHCP server, networkd assign the address
* without lifetime when KeepConfiguration=dhcp. So, let's check that we have
* corresponding routes with RTPROT_DHCP. */
- SET_FOREACH(route, link->routes_foreign, i) {
+ SET_FOREACH(route, link->routes_foreign) {
if (route->protocol != RTPROT_DHCP)
continue;
Address *address;
Neighbor *neighbor;
Route *route;
- Iterator i;
int r;
/* The kernel doesn't notify us about tentative addresses;
return r;
}
- SET_FOREACH(address, link->addresses_foreign, i) {
+ SET_FOREACH(address, link->addresses_foreign) {
/* we consider IPv6LL addresses to be managed by the kernel */
if (address->family == AF_INET6 && in_addr_is_link_local(AF_INET6, &address->in_addr) == 1 && link_ipv6ll_enabled(link))
continue;
}
}
- SET_FOREACH(neighbor, link->neighbors_foreign, i) {
+ SET_FOREACH(neighbor, link->neighbors_foreign) {
if (link_is_neighbor_configured(link, neighbor)) {
r = neighbor_add(link, neighbor->family, &neighbor->in_addr, &neighbor->lladdr, neighbor->lladdr_size, NULL);
if (r < 0)
}
}
- SET_FOREACH(route, link->routes_foreign, i) {
+ SET_FOREACH(route, link->routes_foreign) {
/* do not touch routes managed by the kernel */
if (route->protocol == RTPROT_KERNEL)
continue;
Address *address, *pool_address;
Neighbor *neighbor;
Route *route;
- Iterator i;
int r;
- SET_FOREACH(address, link->addresses, i) {
+ SET_FOREACH(address, link->addresses) {
/* we consider IPv6LL addresses to be managed by the kernel */
if (address->family == AF_INET6 && in_addr_is_link_local(AF_INET6, &address->in_addr) == 1 && link_ipv6ll_enabled(link))
continue;
}
}
- SET_FOREACH(neighbor, link->neighbors, i) {
+ SET_FOREACH(neighbor, link->neighbors) {
r = neighbor_remove(neighbor, link, NULL);
if (r < 0)
return r;
}
- SET_FOREACH(route, link->routes, i) {
+ SET_FOREACH(route, link->routes) {
/* do not touch routes managed by the kernel */
if (route->protocol == RTPROT_KERNEL)
continue;
static int link_configure_traffic_control(Link *link) {
TrafficControl *tc;
- Iterator i;
int r;
link->tc_configured = false;
link->tc_messages = 0;
- ORDERED_HASHMAP_FOREACH(tc, link->network->tc_by_section, i) {
+ ORDERED_HASHMAP_FOREACH(tc, link->network->tc_by_section) {
r = traffic_control_configure(link, tc);
if (r < 0)
return r;
static int link_configure_sr_iov(Link *link) {
SRIOV *sr_iov;
- Iterator i;
int r;
link->sr_iov_configured = false;
link->sr_iov_messages = 0;
- ORDERED_HASHMAP_FOREACH(sr_iov, link->network->sr_iov_by_section, i) {
+ ORDERED_HASHMAP_FOREACH(sr_iov, link->network->sr_iov_by_section) {
r = sr_iov_configure(link, sr_iov);
if (r < 0)
return r;
static void print_link_hashmap(FILE *f, const char *prefix, Hashmap* h) {
bool space = false;
- Iterator i;
Link *link;
assert(f);
return;
fputs(prefix, f);
- HASHMAP_FOREACH(link, h, i) {
+ HASHMAP_FOREACH(link, h) {
if (space)
fputc(' ', f);
_cleanup_fclose_ FILE *f = NULL;
Route *route;
Address *a;
- Iterator i;
int r;
assert(link);
if (link->network->ipv6_accept_ra_use_dns && link->ndisc_rdnss) {
NDiscRDNSS *dd;
- SET_FOREACH(dd, link->ndisc_rdnss, i)
+ SET_FOREACH(dd, link->ndisc_rdnss)
serialize_in6_addrs(f, &dd->address, 1, &space);
}
fputs("DOMAINS=", f);
space = false;
- ORDERED_SET_FOREACH(p, link->search_domains ?: link->network->search_domains, i)
+ ORDERED_SET_FOREACH(p, link->search_domains ?: link->network->search_domains)
fputs_with_space(f, p, NULL, &space);
if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_YES) {
if (link->network->ipv6_accept_ra_use_domains == DHCP_USE_DOMAINS_YES) {
NDiscDNSSL *dd;
- SET_FOREACH(dd, link->ndisc_dnssl, i)
+ SET_FOREACH(dd, link->ndisc_dnssl)
fputs_with_space(f, NDISC_DNSSL_DOMAIN(dd), NULL, &space);
}
fputs("ROUTE_DOMAINS=", f);
space = false;
- ORDERED_SET_FOREACH(p, link->route_domains ?: link->network->route_domains, i)
+ ORDERED_SET_FOREACH(p, link->route_domains ?: link->network->route_domains)
fputs_with_space(f, p, NULL, &space);
if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_ROUTE) {
if (link->network->ipv6_accept_ra_use_domains == DHCP_USE_DOMAINS_ROUTE) {
NDiscDNSSL *dd;
- SET_FOREACH(dd, link->ndisc_dnssl, i)
+ SET_FOREACH(dd, link->ndisc_dnssl)
fputs_with_space(f, NDISC_DNSSL_DOMAIN(dd), NULL, &space);
}
fputs("DNSSEC_NTA=", f);
space = false;
- SET_FOREACH(n, nta_anchors, i)
+ SET_FOREACH(n, nta_anchors)
fputs_with_space(f, n, NULL, &space);
fputc('\n', f);
}
fputs("ADDRESSES=", f);
space = false;
- SET_FOREACH(a, link->addresses, i) {
+ SET_FOREACH(a, link->addresses) {
_cleanup_free_ char *address_str = NULL;
r = in_addr_to_string(a->family, &a->in_addr, &address_str);
fputs("ROUTES=", f);
space = false;
- SET_FOREACH(route, link->routes, i) {
+ SET_FOREACH(route, link->routes) {
_cleanup_free_ char *route_str = NULL;
r = in_addr_to_string(route->family, &route->dst, &route_str);
static int method_list_links(sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
Manager *manager = userdata;
- Iterator i;
Link *link;
int r;
if (r < 0)
return r;
- HASHMAP_FOREACH(link, manager->links, i) {
+ HASHMAP_FOREACH(link, manager->links) {
_cleanup_free_ char *path = NULL;
path = link_bus_path(link);
static int bus_method_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *manager = userdata;
- Iterator i;
Link *link;
int r;
if (r < 0)
return r;
- HASHMAP_FOREACH(link, manager->links, i) {
+ HASHMAP_FOREACH(link, manager->links) {
r = link_reconfigure(link, false);
if (r < 0)
return r;
static int manager_reset_all(Manager *m) {
Link *link;
- Iterator i;
int r;
assert(m);
- HASHMAP_FOREACH(link, m->links, i) {
+ HASHMAP_FOREACH(link, m->links) {
r = link_carrier_reset(link);
if (r < 0)
log_link_warning_errno(link, r, "Could not reset carrier: %m");
_cleanup_strv_free_ char **p = NULL;
_cleanup_fclose_ FILE *f = NULL;
Link *link;
- Iterator i;
int r;
assert(m);
if (!route_domains)
return -ENOMEM;
- HASHMAP_FOREACH(link, m->links, i) {
+ HASHMAP_FOREACH(link, m->links) {
const struct in_addr *addresses;
if (link->flags & IFF_LOOPBACK)
static int manager_dirty_handler(sd_event_source *s, void *userdata) {
Manager *m = userdata;
Link *link;
- Iterator i;
assert(m);
if (m->dirty)
manager_save(m);
- SET_FOREACH(link, m->dirty_links, i)
+ SET_FOREACH(link, m->dirty_links)
(void) link_save_and_clean(link);
return 1;
void manager_free(Manager *m) {
AddressPool *pool;
Link *link;
- Iterator i;
if (!m)
return;
free(m->state_file);
- HASHMAP_FOREACH(link, m->links, i)
+ HASHMAP_FOREACH(link, m->links)
(void) link_stop_clients(link, true);
m->dhcp6_prefixes = hashmap_free_with_destructor(m->dhcp6_prefixes, dhcp6_pd_free);
int manager_start(Manager *m) {
Link *link;
- Iterator i;
int r;
assert(m);
manager_save(m);
- HASHMAP_FOREACH(link, m->links, i)
+ HASHMAP_FOREACH(link, m->links)
(void) link_save(link);
return 0;
static int ndisc_address_callback(Address *address) {
struct in6_addr router = {};
NDiscAddress *n;
- Iterator i;
assert(address);
assert(address->link);
- SET_FOREACH(n, address->link->ndisc_addresses, i)
+ SET_FOREACH(n, address->link->ndisc_addresses)
if (n->address == address) {
router = n->router;
break;
}
/* Make this called only once */
- SET_FOREACH(n, address->link->ndisc_addresses, i)
+ SET_FOREACH(n, address->link->ndisc_addresses)
if (IN6_ARE_ADDR_EQUAL(&n->router, &router))
n->address->callback = NULL;
NDiscRoute *nr;
NDiscDNSSL *dnssl;
NDiscRDNSS *rdnss;
- Iterator i;
int k, r = 0;
assert(link);
if (!link->ndisc_addresses_configured || !link->ndisc_routes_configured)
return 0;
- SET_FOREACH(na, link->ndisc_addresses, i)
+ SET_FOREACH(na, link->ndisc_addresses)
if (!na->marked && IN6_ARE_ADDR_EQUAL(&na->router, router)) {
set_callback = true;
break;
}
if (set_callback)
- SET_FOREACH(na, link->ndisc_addresses, i)
+ SET_FOREACH(na, link->ndisc_addresses)
if (!na->marked && address_is_ready(na->address)) {
set_callback = false;
break;
}
if (set_callback) {
- SET_FOREACH(na, link->ndisc_addresses, i)
+ SET_FOREACH(na, link->ndisc_addresses)
if (!na->marked && IN6_ARE_ADDR_EQUAL(&na->router, router))
na->address->callback = ndisc_address_callback;
link_dirty(link);
- SET_FOREACH(na, link->ndisc_addresses, i)
+ SET_FOREACH(na, link->ndisc_addresses)
if (na->marked && IN6_ARE_ADDR_EQUAL(&na->router, router)) {
k = address_remove(na->address, link, NULL);
if (k < 0)
r = k;
}
- SET_FOREACH(nr, link->ndisc_routes, i)
+ SET_FOREACH(nr, link->ndisc_routes)
if (nr->marked && IN6_ARE_ADDR_EQUAL(&nr->router, router)) {
k = route_remove(nr->route, link, NULL);
if (k < 0)
r = k;
}
- SET_FOREACH(rdnss, link->ndisc_rdnss, i)
+ SET_FOREACH(rdnss, link->ndisc_rdnss)
if (rdnss->marked && IN6_ARE_ADDR_EQUAL(&rdnss->router, router))
free(set_remove(link->ndisc_rdnss, rdnss));
- SET_FOREACH(dnssl, link->ndisc_dnssl, i)
+ SET_FOREACH(dnssl, link->ndisc_dnssl)
if (dnssl->marked && IN6_ARE_ADDR_EQUAL(&dnssl->router, router))
free(set_remove(link->ndisc_dnssl, dnssl));
NDiscRoute *nr;
NDiscDNSSL *dnssl;
NDiscRDNSS *rdnss;
- Iterator i;
int k, r;
assert(link);
if (!routers)
return -ENOMEM;
- SET_FOREACH(na, link->ndisc_addresses, i)
+ SET_FOREACH(na, link->ndisc_addresses)
if (!set_contains(routers, &na->router)) {
router = newdup(struct in6_addr, &na->router, 1);
if (!router)
TAKE_PTR(router);
}
- SET_FOREACH(nr, link->ndisc_routes, i)
+ SET_FOREACH(nr, link->ndisc_routes)
if (!set_contains(routers, &nr->router)) {
router = newdup(struct in6_addr, &nr->router, 1);
if (!router)
TAKE_PTR(router);
}
- SET_FOREACH(rdnss, link->ndisc_rdnss, i)
+ SET_FOREACH(rdnss, link->ndisc_rdnss)
if (!set_contains(routers, &rdnss->router)) {
router = newdup(struct in6_addr, &rdnss->router, 1);
if (!router)
TAKE_PTR(router);
}
- SET_FOREACH(dnssl, link->ndisc_dnssl, i)
+ SET_FOREACH(dnssl, link->ndisc_dnssl)
if (!set_contains(routers, &dnssl->router)) {
router = newdup(struct in6_addr, &dnssl->router, 1);
if (!router)
}
r = 0;
- SET_FOREACH(a, routers, i) {
+ SET_FOREACH(a, routers) {
k = ndisc_remove_old_one(link, a, false);
if (k < 0)
r = k;
static int ndisc_router_generate_addresses(Link *link, struct in6_addr *address, uint8_t prefixlen, Set **ret) {
_cleanup_set_free_free_ Set *addresses = NULL;
IPv6Token *j;
- Iterator i;
int r;
assert(link);
if (!addresses)
return log_oom();
- ORDERED_SET_FOREACH(j, link->network->ipv6_tokens, i) {
+ ORDERED_SET_FOREACH(j, link->network->ipv6_tokens) {
_cleanup_free_ struct in6_addr *new_address = NULL;
if (j->address_generation_type == IPV6_TOKEN_ADDRESS_GENERATION_PREFIXSTABLE
struct in6_addr addr, *a;
unsigned prefixlen;
usec_t time_now;
- Iterator i;
int r;
assert(link);
address->flags = IFA_F_NOPREFIXROUTE|IFA_F_MANAGETEMPADDR;
address->cinfo.ifa_prefered = lifetime_preferred;
- SET_FOREACH(a, addresses, i) {
+ SET_FOREACH(a, addresses) {
Address *existing_address;
/* see RFC4862 section 5.5.3.e */
struct in6_addr router;
NDiscRDNSS *rdnss;
usec_t time_now;
- Iterator i;
int n, r;
assert(link);
if (n < 0)
return log_link_error_errno(link, n, "Failed to get RDNSS addresses: %m");
- SET_FOREACH(rdnss, link->ndisc_rdnss, i)
+ SET_FOREACH(rdnss, link->ndisc_rdnss)
if (IN6_ARE_ADDR_EQUAL(&rdnss->router, &router))
rdnss->marked = true;
uint32_t lifetime;
usec_t time_now;
NDiscDNSSL *dnssl;
- Iterator i;
char **j;
int r;
if (r < 0)
return log_link_error_errno(link, r, "Failed to get DNSSL addresses: %m");
- SET_FOREACH(dnssl, link->ndisc_dnssl, i)
+ SET_FOREACH(dnssl, link->ndisc_dnssl)
if (IN6_ARE_ADDR_EQUAL(&dnssl->router, &router))
dnssl->marked = true;
uint64_t flags;
NDiscAddress *na;
NDiscRoute *nr;
- Iterator i;
int r;
assert(link);
if (r < 0)
return log_link_error_errno(link, r, "Failed to get router address from RA: %m");
- SET_FOREACH(na, link->ndisc_addresses, i)
+ SET_FOREACH(na, link->ndisc_addresses)
if (IN6_ARE_ADDR_EQUAL(&na->router, &router))
na->marked = true;
- SET_FOREACH(nr, link->ndisc_routes, i)
+ SET_FOREACH(nr, link->ndisc_routes)
if (IN6_ARE_ADDR_EQUAL(&nr->router, &router))
nr->marked = true;
void ndisc_vacuum(Link *link) {
NDiscRDNSS *r;
NDiscDNSSL *d;
- Iterator i;
usec_t time_now;
bool updated = false;
time_now = now(clock_boottime_or_monotonic());
- SET_FOREACH(r, link->ndisc_rdnss, i)
+ SET_FOREACH(r, link->ndisc_rdnss)
if (r->valid_until < time_now) {
free(set_remove(link->ndisc_rdnss, r));
updated = true;
}
- SET_FOREACH(d, link->ndisc_dnssl, i)
+ SET_FOREACH(d, link->ndisc_dnssl)
if (d->valid_until < time_now) {
free(set_remove(link->ndisc_dnssl, d));
updated = true;
char buf[ETHER_ADDR_TO_STRING_MAX];
const struct ether_addr *p;
- Iterator i;
Set *s;
int r;
if (r < 0)
return r;
- SET_FOREACH(p, s, i) {
+ SET_FOREACH(p, s) {
r = sd_bus_message_append(reply, "s", ether_addr_to_string(p, buf));
if (r < 0)
return r;
_cleanup_strv_free_ char **l = NULL;
Manager *m = userdata;
Network *network;
- Iterator i;
int r;
assert(bus);
assert(m);
assert(nodes);
- ORDERED_HASHMAP_FOREACH(network, m->networks, i) {
+ ORDERED_HASHMAP_FOREACH(network, m->networks) {
char *p;
p = network_bus_path(network);
static int network_resolve_stacked_netdevs(Network *network) {
void *name, *kind;
- Iterator i;
int r;
assert(network);
- HASHMAP_FOREACH_KEY(kind, name, network->stacked_netdev_names, i) {
+ HASHMAP_FOREACH_KEY(kind, name, network->stacked_netdev_names) {
_cleanup_(netdev_unrefp) NetDev *netdev = NULL;
r = network_resolve_netdev_one(network, name, PTR_TO_INT(kind), &netdev);
FdbEntry *fdb, *fdb_next;
TrafficControl *tc;
SRIOV *sr_iov;
- Iterator i;
assert(network);
assert(network->filename);
routing_policy_rule_free(rule);
bool has_root = false, has_clsact = false;
- ORDERED_HASHMAP_FOREACH(tc, network->tc_by_section, i)
+ ORDERED_HASHMAP_FOREACH(tc, network->tc_by_section)
if (traffic_control_section_verify(tc, &has_root, &has_clsact) < 0)
traffic_control_free(tc);
- ORDERED_HASHMAP_FOREACH(sr_iov, network->sr_iov_by_section, i)
+ ORDERED_HASHMAP_FOREACH(sr_iov, network->sr_iov_by_section)
if (sr_iov_section_verify(sr_iov) < 0)
sr_iov_free(sr_iov);
int network_reload(Manager *manager) {
OrderedHashmap *new_networks = NULL;
Network *n, *old;
- Iterator i;
int r;
assert(manager);
if (r < 0)
goto failure;
- ORDERED_HASHMAP_FOREACH(n, new_networks, i) {
+ ORDERED_HASHMAP_FOREACH(n, new_networks) {
r = network_get_by_name(manager, n->name, &old);
if (r < 0)
continue; /* The .network file is new. */
enum nl80211_iftype wlan_iftype, const char *ssid, const struct ether_addr *bssid,
Network **ret) {
Network *network;
- Iterator i;
assert(manager);
assert(ret);
- ORDERED_HASHMAP_FOREACH(network, manager->networks, i)
+ ORDERED_HASHMAP_FOREACH(network, manager->networks)
if (net_match_config(network->match_mac, network->match_permanent_mac,
network->match_path, network->match_driver,
network->match_type, network->match_name, network->match_property,
if (route->link) {
NDiscRoute *n;
- Iterator i;
set_remove(route->link->routes, route);
set_remove(route->link->routes_foreign, route);
set_remove(route->link->dhcp6_routes_old, route);
set_remove(route->link->dhcp6_pd_routes, route);
set_remove(route->link->dhcp6_pd_routes_old, route);
- SET_FOREACH(n, route->link->ndisc_routes, i)
+ SET_FOREACH(n, route->link->ndisc_routes)
if (n->route == route)
free(set_remove(route->link->ndisc_routes, n));
}
struct rtnexthop *rtnh;
MultipathRoute *m;
size_t offset;
- Iterator i;
int r;
if (ordered_set_isempty(route->multipath_routes))
};
offset = (uint8_t *) RTA_DATA(rta) - (uint8_t *) rta;
- ORDERED_SET_FOREACH(m, route->multipath_routes, i) {
+ ORDERED_SET_FOREACH(m, route->multipath_routes) {
r = append_nexthop_one(route, m, &rta, offset);
if (r < 0)
return r;
int routing_policy_serialize_rules(Set *rules, FILE *f) {
RoutingPolicyRule *rule = NULL;
- Iterator i;
int r;
assert(f);
- SET_FOREACH(rule, rules, i) {
+ SET_FOREACH(rule, rules) {
_cleanup_free_ char *from_str = NULL, *to_str = NULL;
const char *family_str;
bool space = false;
static bool manager_links_have_routing_policy_rule(Manager *m, RoutingPolicyRule *rule) {
RoutingPolicyRule *link_rule;
- Iterator i;
Link *link;
assert(m);
assert(rule);
- HASHMAP_FOREACH(link, m->links, i) {
+ HASHMAP_FOREACH(link, m->links) {
if (!link->network)
continue;
void routing_policy_rule_purge(Manager *m, Link *link) {
RoutingPolicyRule *rule, *existing;
- Iterator i;
int r;
assert(m);
assert(link);
- SET_FOREACH(rule, m->rules_saved, i) {
+ SET_FOREACH(rule, m->rules_saved) {
existing = set_get(m->rules_foreign, rule);
if (!existing)
continue; /* Saved rule does not exist anymore. */
Manager *manager = userdata;
sd_netlink_message *i;
usec_t usec_now;
- Iterator j;
Link *link;
int r;
manager->speed_meter_usec_old = manager->speed_meter_usec_new;
manager->speed_meter_usec_new = usec_now;
- HASHMAP_FOREACH(link, manager->links, j)
+ HASHMAP_FOREACH(link, manager->links)
link->stats_updated = false;
r = sd_rtnl_message_new_link(manager->rtnl, &req, RTM_GETLINK, 0);
bool manager_configured(Manager *m) {
bool one_ready = false;
- Iterator i;
const char *ifname;
void *p;
Link *l;
if (!hashmap_isempty(m->interfaces)) {
/* wait for all the links given on the command line to appear */
- HASHMAP_FOREACH_KEY(p, ifname, m->interfaces, i) {
+ HASHMAP_FOREACH_KEY(p, ifname, m->interfaces) {
LinkOperationalStateRange *range = p;
l = hashmap_get(m->links_by_name, ifname);
/* wait for all links networkd manages to be in admin state 'configured'
* and at least one link to gain a carrier */
- HASHMAP_FOREACH(l, m->links, i) {
+ HASHMAP_FOREACH(l, m->links) {
if (manager_ignore_link(m, l)) {
log_link_debug(l, "link is ignored");
continue;
static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
Manager *m = userdata;
- Iterator i;
Link *l;
int r;
sd_network_monitor_flush(m->network_monitor);
- HASHMAP_FOREACH(l, m->links, i) {
+ HASHMAP_FOREACH(l, m->links) {
r = link_update_monitor(l);
if (r < 0 && r != -ENODATA)
log_link_warning_errno(l, r, "Failed to update link state, ignoring: %m");
int portable_metadata_hashmap_to_sorted_array(Hashmap *unit_files, PortableMetadata ***ret) {
_cleanup_free_ PortableMetadata **sorted = NULL;
- Iterator iterator;
PortableMetadata *item;
size_t k = 0;
if (!sorted)
return -ENOMEM;
- HASHMAP_FOREACH(item, unit_files, iterator)
+ HASHMAP_FOREACH(item, unit_files)
sorted[k++] = item;
assert(k == hashmap_size(unit_files));
_cleanup_(lookup_paths_free) LookupPaths paths = {};
_cleanup_(image_unrefp) Image *image = NULL;
PortableMetadata *item;
- Iterator iterator;
int r;
assert(name_or_path);
if (r < 0)
return r;
- HASHMAP_FOREACH(item, unit_files, iterator) {
+ HASHMAP_FOREACH(item, unit_files) {
r = unit_file_exists(UNIT_FILE_SYSTEM, &paths, item->name);
if (r < 0)
return sd_bus_error_set_errnof(error, r, "Failed to determine whether unit '%s' exists on the host: %m", item->name);
return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS, "Unit file '%s' is active already, refusing.", item->name);
}
- HASHMAP_FOREACH(item, unit_files, iterator) {
+ HASHMAP_FOREACH(item, unit_files) {
r = attach_unit_file(&paths, image->path, image->type, item, profile, flags, changes, n_changes);
if (r < 0)
return r;
_cleanup_set_free_ Set *unit_files = NULL, *markers = NULL;
_cleanup_closedir_ DIR *d = NULL;
const char *where, *item;
- Iterator iterator;
struct dirent *de;
int ret = 0;
int r;
if (set_isempty(unit_files))
goto not_found;
- SET_FOREACH(item, unit_files, iterator) {
+ SET_FOREACH(item, unit_files) {
_cleanup_free_ char *md = NULL;
const char *suffix;
}
/* Now, also drop any image symlink, for images outside of the sarch path */
- SET_FOREACH(item, markers, iterator) {
+ SET_FOREACH(item, markers) {
_cleanup_free_ char *sl = NULL;
struct stat st;
_cleanup_hashmap_free_ Hashmap *images = NULL;
Manager *m = userdata;
Image *image;
- Iterator i;
int r;
assert(message);
if (r < 0)
return r;
- HASHMAP_FOREACH(image, images, i) {
+ HASHMAP_FOREACH(image, images) {
_cleanup_(sd_bus_error_free) sd_bus_error error_state = SD_BUS_ERROR_NULL;
PortableState state = _PORTABLE_STATE_INVALID;
_cleanup_free_ char *p = NULL;
size_t n_allocated = 0, n = 0;
Manager *m = userdata;
Image *image;
- Iterator i;
int r;
assert(bus);
if (r < 0)
return r;
- HASHMAP_FOREACH(image, images, i) {
+ HASHMAP_FOREACH(image, images) {
char *p;
r = bus_image_path(image, &p);
int manager_image_cache_discover(Manager *m, Hashmap *images, sd_bus_error *error) {
Image *image;
- Iterator i;
int r;
assert(m);
if (r < 0)
return r;
- HASHMAP_FOREACH(image, images, i)
+ HASHMAP_FOREACH(image, images)
(void) manager_image_cache_add(m, image);
return 0;
Manager *m = userdata;
DnsServer *s;
- Iterator i;
Link *l;
int r;
return r;
}
- HASHMAP_FOREACH(l, m->links, i)
+ HASHMAP_FOREACH(l, m->links)
LIST_FOREACH(servers, s, l->dns_servers) {
r = bus_dns_server_append(reply, s, true, extended);
if (r < 0)
Manager *m = userdata;
DnsSearchDomain *d;
- Iterator i;
Link *l;
int r;
return r;
}
- HASHMAP_FOREACH(l, m->links, i) {
+ HASHMAP_FOREACH(l, m->links) {
LIST_FOREACH(domains, d, l->search_domains) {
r = sd_bus_message_append(reply, "(isb)", l->ifindex, d->name, d->route_only);
if (r < 0)
Manager *m = userdata;
const char *domain;
- Iterator i;
int r;
assert(reply);
if (r < 0)
return r;
- SET_FOREACH(domain, m->trust_anchor.negative_by_name, i) {
+ SET_FOREACH(domain, m->trust_anchor.negative_by_name) {
r = sd_bus_message_append(reply, "s", domain);
if (r < 0)
return r;
int dns_cache_export_shared_to_packet(DnsCache *cache, DnsPacket *p) {
unsigned ancount = 0;
- Iterator iterator;
DnsCacheItem *i;
int r;
assert(cache);
assert(p);
- HASHMAP_FOREACH(i, cache->by_key, iterator) {
+ HASHMAP_FOREACH(i, cache->by_key) {
DnsCacheItem *j;
LIST_FOREACH(by_key, j, i) {
}
void dns_cache_dump(DnsCache *cache, FILE *f) {
- Iterator iterator;
DnsCacheItem *i;
if (!cache)
if (!f)
f = stdout;
- HASHMAP_FOREACH(i, cache->by_key, iterator) {
+ HASHMAP_FOREACH(i, cache->by_key) {
DnsCacheItem *j;
LIST_FOREACH(by_key, j, i) {
}
void dns_packet_truncate(DnsPacket *p, size_t sz) {
- Iterator i;
char *s;
void *n;
if (p->size <= sz)
return;
- HASHMAP_FOREACH_KEY(n, s, p->names, i) {
+ HASHMAP_FOREACH_KEY(n, s, p->names) {
if (PTR_TO_SIZE(n) < sz)
continue;
}
static int dns_packet_append_types(DnsPacket *p, Bitmap *types, size_t *start) {
- Iterator i;
uint8_t window = 0;
uint8_t entry = 0;
uint8_t bitmaps[32] = {};
saved_size = p->size;
- BITMAP_FOREACH(n, types, i) {
+ BITMAP_FOREACH(n, types) {
assert(n <= 0xffff);
if ((n >> 8) != window && bitmaps[entry / 8] != 0) {
static int dns_query_candidate_go(DnsQueryCandidate *c) {
DnsTransaction *t;
- Iterator i;
int r;
unsigned n = 0;
assert(c);
/* Start the transactions that are not started yet */
- SET_FOREACH(t, c->transactions, i) {
+ SET_FOREACH(t, c->transactions) {
if (t->state != DNS_TRANSACTION_NULL)
continue;
static DnsTransactionState dns_query_candidate_state(DnsQueryCandidate *c) {
DnsTransactionState state = DNS_TRANSACTION_NO_SERVERS;
DnsTransaction *t;
- Iterator i;
assert(c);
if (c->error_code != 0)
return DNS_TRANSACTION_ERRNO;
- SET_FOREACH(t, c->transactions, i) {
+ SET_FOREACH(t, c->transactions) {
switch (t->state) {
bool has_authenticated = false, has_non_authenticated = false;
DnssecResult dnssec_result_authenticated = _DNSSEC_RESULT_INVALID, dnssec_result_non_authenticated = _DNSSEC_RESULT_INVALID;
DnsTransaction *t;
- Iterator i;
int r;
assert(q);
q->answer_errno = c->error_code;
}
- SET_FOREACH(t, c->transactions, i) {
+ SET_FOREACH(t, c->transactions) {
switch (t->state) {
static char *format_types(Bitmap *types) {
_cleanup_strv_free_ char **strv = NULL;
_cleanup_free_ char *str = NULL;
- Iterator i;
unsigned type;
int r;
- BITMAP_FOREACH(type, types, i) {
+ BITMAP_FOREACH(type, types) {
if (dns_type_to_string(type)) {
r = strv_extend(&strv, dns_type_to_string(type));
if (r < 0)
DnsTransaction *t;
DnsZoneItem *z, *i;
unsigned size = 0;
- Iterator iterator;
char *service_type;
int r;
return 0; /* we reach this point only if changing hostname didn't help */
/* Calculate answer's size. */
- HASHMAP_FOREACH(z, scope->zone.by_key, iterator) {
+ HASHMAP_FOREACH(z, scope->zone.by_key) {
if (z->state != DNS_ZONE_ITEM_ESTABLISHED)
continue;
return log_oom();
/* Second iteration, actually add RRs to the answer. */
- HASHMAP_FOREACH(z, scope->zone.by_key, iterator)
+ HASHMAP_FOREACH(z, scope->zone.by_key)
LIST_FOREACH (by_key, i, z) {
DnsAnswerFlags flags;
}
/* Since all the active services are in the zone make them discoverable now. */
- SET_FOREACH(service_type, types, iterator) {
+ SET_FOREACH(service_type, types) {
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr;
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_PTR,
}
int dns_scope_add_dnssd_services(DnsScope *scope) {
- Iterator i;
DnssdService *service;
DnssdTxtData *txt_data;
int r;
scope->announced = false;
- HASHMAP_FOREACH(service, scope->manager->dnssd_services, i) {
+ HASHMAP_FOREACH(service, scope->manager->dnssd_services) {
service->withdrawn = false;
r = dns_zone_put(&scope->zone, scope, service->ptr_rr, false);
int dns_scope_remove_dnssd_services(DnsScope *scope) {
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
- Iterator i;
DnssdService *service;
DnssdTxtData *txt_data;
int r;
if (r < 0)
return r;
- HASHMAP_FOREACH(service, scope->manager->dnssd_services, i) {
+ HASHMAP_FOREACH(service, scope->manager->dnssd_services) {
dns_zone_remove_rr(&scope->zone, service->ptr_rr);
dns_zone_remove_rr(&scope->zone, service->srv_rr);
LIST_FOREACH(items, txt_data, service->txt_data_items)
if (!m->current_dns_server) {
bool found = false;
- Iterator i;
/* No DNS servers configured, let's see if there are
* any on any links. If not, we use the fallback
* servers */
- HASHMAP_FOREACH(l, m->links, i)
+ HASHMAP_FOREACH(l, m->links)
if (l->dns_servers) {
found = true;
break;
static DnsStream *dns_stream_free(DnsStream *s) {
DnsPacket *p;
- Iterator i;
assert(s);
dnstls_stream_free(s);
#endif
- ORDERED_SET_FOREACH(p, s->write_queue, i)
+ ORDERED_SET_FOREACH(p, s->write_queue)
dns_packet_unref(ordered_set_remove(s->write_queue, p));
dns_packet_unref(s->write_packet);
if (!ordered_set_isempty(m->dns_extra_stub_listeners)) {
DNSStubListenerExtra *l;
- Iterator i;
log_debug("Creating extra stub listeners.");
- ORDERED_SET_FOREACH(l, m->dns_extra_stub_listeners, i) {
+ ORDERED_SET_FOREACH(l, m->dns_extra_stub_listeners) {
if (FLAGS_SET(l->mode, DNS_STUB_LISTENER_UDP))
(void) manager_dns_stub_udp_fd_extra(m, l);
if (FLAGS_SET(l->mode, DNS_STUB_LISTENER_TCP))
static bool dns_transaction_dnssec_is_live(DnsTransaction *t) {
DnsTransaction *dt;
- Iterator i;
assert(t);
- SET_FOREACH(dt, t->dnssec_transactions, i)
+ SET_FOREACH(dt, t->dnssec_transactions)
if (DNS_TRANSACTION_IS_LIVE(dt->state))
return true;
static int dns_transaction_dnssec_ready(DnsTransaction *t) {
DnsTransaction *dt;
- Iterator i;
assert(t);
/* Checks whether the auxiliary DNSSEC transactions of our transaction have completed, or are still
* ongoing. Returns 0, if we aren't ready for the DNSSEC validation, positive if we are. */
- SET_FOREACH(dt, t->dnssec_transactions, i) {
+ SET_FOREACH(dt, t->dnssec_transactions) {
switch (dt->state) {
_cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
bool add_known_answers = false;
DnsTransaction *other;
- Iterator i;
DnsResourceKey *tkey;
_cleanup_set_free_ Set *keys = NULL;
unsigned qdcount;
return r;
}
- SET_FOREACH(tkey, keys, i) {
+ SET_FOREACH(tkey, keys) {
_cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
bool tentative;
static int dns_transaction_find_cyclic(DnsTransaction *t, DnsTransaction *aux) {
DnsTransaction *n;
- Iterator i;
int r;
assert(t);
if (t == aux)
return 1;
- SET_FOREACH(n, aux->dnssec_transactions, i) {
+ SET_FOREACH(n, aux->dnssec_transactions) {
r = dns_transaction_find_cyclic(t, n);
if (r != 0)
return r;
static bool dns_transaction_dnssec_supported_full(DnsTransaction *t) {
DnsTransaction *dt;
- Iterator i;
assert(t);
if (!dns_transaction_dnssec_supported(t))
return false;
- SET_FOREACH(dt, t->dnssec_transactions, i)
+ SET_FOREACH(dt, t->dnssec_transactions)
if (!dns_transaction_dnssec_supported(dt))
return false;
case DNS_TYPE_SOA:
case DNS_TYPE_NS: {
DnsTransaction *dt;
- Iterator i;
/* For SOA or NS RRs we look for a matching DS transaction */
- SET_FOREACH(dt, t->dnssec_transactions, i) {
+ SET_FOREACH(dt, t->dnssec_transactions) {
if (dt->key->class != rr->key->class)
continue;
case DNS_TYPE_DNAME: {
const char *parent = NULL;
DnsTransaction *dt;
- Iterator i;
/*
* CNAME/DNAME RRs cannot be located at a zone apex, hence look directly for the parent SOA.
* DS RRs are signed if the parent is signed, hence also look at the parent SOA
*/
- SET_FOREACH(dt, t->dnssec_transactions, i) {
+ SET_FOREACH(dt, t->dnssec_transactions) {
if (dt->key->class != rr->key->class)
continue;
default: {
DnsTransaction *dt;
- Iterator i;
/* Any other kind of RR (including DNSKEY/NSEC/NSEC3). Let's see if our SOA lookup was authenticated */
- SET_FOREACH(dt, t->dnssec_transactions, i) {
+ SET_FOREACH(dt, t->dnssec_transactions) {
if (dt->key->class != rr->key->class)
continue;
static int dns_transaction_in_private_tld(DnsTransaction *t, const DnsResourceKey *key) {
DnsTransaction *dt;
const char *tld;
- Iterator i;
int r;
/* If DNSSEC downgrade mode is on, checks whether the
if (!dns_name_is_single_label(tld))
return false;
- SET_FOREACH(dt, t->dnssec_transactions, i) {
+ SET_FOREACH(dt, t->dnssec_transactions) {
if (dt->key->class != key->class)
continue;
DnsTransaction *dt;
const char *name;
uint16_t type = 0;
- Iterator i;
int r;
assert(t);
/* For all other RRs we check the SOA on the same level to see
* if it's signed. */
- SET_FOREACH(dt, t->dnssec_transactions, i) {
+ SET_FOREACH(dt, t->dnssec_transactions) {
if (dt->key->class != t->key->class)
continue;
DNS_ANSWER_FOREACH(rrsig, t->answer) {
DnsTransaction *dt;
- Iterator i;
r = dnssec_key_match_rrsig(rr->key, rrsig);
if (r < 0)
if (r == 0)
continue;
- SET_FOREACH(dt, t->dnssec_transactions, i) {
+ SET_FOREACH(dt, t->dnssec_transactions) {
if (dt->key->class != rr->key->class)
continue;
static int dns_transaction_copy_validated(DnsTransaction *t) {
DnsTransaction *dt;
- Iterator i;
int r;
assert(t);
/* Copy all validated RRs from the auxiliary DNSSEC transactions into our set of validated RRs */
- SET_FOREACH(dt, t->dnssec_transactions, i) {
+ SET_FOREACH(dt, t->dnssec_transactions) {
if (DNS_TRANSACTION_IS_LIVE(dt->state))
continue;
static int dns_trust_anchor_dump(DnsTrustAnchor *d) {
DnsAnswer *a;
- Iterator i;
assert(d);
log_info("No positive trust anchors defined.");
else {
log_info("Positive Trust Anchors:");
- HASHMAP_FOREACH(a, d->positive_by_key, i) {
+ HASHMAP_FOREACH(a, d->positive_by_key) {
DnsResourceRecord *rr;
DNS_ANSWER_FOREACH(rr, a)
void dns_zone_verify_all(DnsZone *zone) {
DnsZoneItem *i;
- Iterator iterator;
assert(zone);
- HASHMAP_FOREACH(i, zone->by_key, iterator) {
+ HASHMAP_FOREACH(i, zone->by_key) {
DnsZoneItem *j;
LIST_FOREACH(by_key, j, i)
}
void dns_zone_dump(DnsZone *zone, FILE *f) {
- Iterator iterator;
DnsZoneItem *i;
if (!zone)
if (!f)
f = stdout;
- HASHMAP_FOREACH(i, zone->by_key, iterator) {
+ HASHMAP_FOREACH(i, zone->by_key) {
DnsZoneItem *j;
LIST_FOREACH(by_key, j, i) {
DnssdService *s = userdata;
DnssdTxtData *txt_data;
Manager *m;
- Iterator i;
Link *l;
int r;
if (r == 0)
return 1; /* Polkit will call us back */
- HASHMAP_FOREACH(l, m->links, i) {
+ HASHMAP_FOREACH(l, m->links) {
if (l->mdns_ipv4_scope) {
r = dns_scope_announce(l->mdns_ipv4_scope, true);
if (r < 0)
_cleanup_strv_free_ char **l = NULL;
Manager *m = userdata;
DnssdService *service;
- Iterator i;
unsigned c = 0;
int r;
if (!l)
return -ENOMEM;
- HASHMAP_FOREACH(service, m->dnssd_services, i) {
+ HASHMAP_FOREACH(service, m->dnssd_services) {
char *p;
r = sd_bus_path_encode("/org/freedesktop/resolve1/dnssd", service->name, &p);
}
void dnssd_signal_conflict(Manager *manager, const char *name) {
- Iterator i;
DnssdService *s;
int r;
- HASHMAP_FOREACH(s, manager->dnssd_services, i) {
+ HASHMAP_FOREACH(s, manager->dnssd_services) {
if (s->withdrawn)
continue;
Link *l = userdata;
const char *name;
- Iterator i;
int r;
assert(reply);
if (r < 0)
return r;
- SET_FOREACH(name, l->dnssec_negative_trust_anchors, i) {
+ SET_FOREACH(name, l->dnssec_negative_trust_anchors) {
r = sd_bus_message_append(reply, "s", name);
if (r < 0)
return r;
_cleanup_strv_free_ char **l = NULL;
Manager *m = userdata;
Link *link;
- Iterator i;
unsigned c = 0;
assert(bus);
if (!l)
return -ENOMEM;
- HASHMAP_FOREACH(link, m->links, i) {
+ HASHMAP_FOREACH(link, m->links) {
char *p;
p = link_bus_path(link);
if (!set_isempty(l->dnssec_negative_trust_anchors)) {
bool space = false;
- Iterator i;
char *nta;
fputs("NTAS=", f);
- SET_FOREACH(nta, l->dnssec_negative_trust_anchors, i) {
+ SET_FOREACH(nta, l->dnssec_negative_trust_anchors) {
if (space)
fputc(' ', f);
static int on_network_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
Manager *m = userdata;
- Iterator i;
Link *l;
int r;
sd_network_monitor_flush(m->network_monitor);
- HASHMAP_FOREACH(l, m->links, i) {
+ HASHMAP_FOREACH(l, m->links) {
r = link_update(l);
if (r < 0)
log_warning_errno(r, "Failed to update monitor information for %i: %m", l->ifindex);
DnsServer *server;
size_t size = 0;
DnsScope *scope;
- Iterator i;
Link *l;
assert(s);
dns_server_dump(server, f);
LIST_FOREACH(servers, server, m->fallback_dns_servers)
dns_server_dump(server, f);
- HASHMAP_FOREACH(l, m->links, i)
+ HASHMAP_FOREACH(l, m->links)
LIST_FOREACH(servers, server, l->dns_servers)
dns_server_dump(server, f);
uint32_t manager_find_mtu(Manager *m) {
uint32_t mtu = 0;
Link *l;
- Iterator i;
/* If we don't know on which link a DNS packet would be
* delivered, let's find the largest MTU that works on all
* interfaces we know of */
- HASHMAP_FOREACH(l, m->links, i) {
+ HASHMAP_FOREACH(l, m->links) {
if (l->mtu <= 0)
continue;
}
void manager_refresh_rrs(Manager *m) {
- Iterator i;
Link *l;
DnssdService *s;
m->mdns_host_ipv6_key = dns_resource_key_unref(m->mdns_host_ipv6_key);
if (m->mdns_support == RESOLVE_SUPPORT_YES)
- HASHMAP_FOREACH(s, m->dnssd_services, i)
+ HASHMAP_FOREACH(s, m->dnssd_services)
if (dnssd_update_rrs(s) < 0)
log_warning("Failed to refresh DNS-SD service '%s'", s->name);
- HASHMAP_FOREACH(l, m->links, i) {
+ HASHMAP_FOREACH(l, m->links) {
link_add_rrs(l, true);
link_add_rrs(l, false);
}
}
LinkAddress* manager_find_link_address(Manager *m, int family, const union in_addr_union *in_addr) {
- Iterator i;
Link *l;
assert(m);
- HASHMAP_FOREACH(l, m->links, i) {
+ HASHMAP_FOREACH(l, m->links) {
LinkAddress *a;
a = link_find_address(l, family, in_addr);
int manager_compile_dns_servers(Manager *m, OrderedSet **dns) {
DnsServer *s;
- Iterator i;
Link *l;
int r;
}
/* Then, add the per-link servers */
- HASHMAP_FOREACH(l, m->links, i) {
+ HASHMAP_FOREACH(l, m->links) {
LIST_FOREACH(servers, s, l->dns_servers) {
r = ordered_set_put(*dns, s);
if (r == -EEXIST)
*/
int manager_compile_search_domains(Manager *m, OrderedSet **domains, int filter_route) {
DnsSearchDomain *d;
- Iterator i;
Link *l;
int r;
return r;
}
- HASHMAP_FOREACH(l, m->links, i) {
+ HASHMAP_FOREACH(l, m->links) {
LIST_FOREACH(domains, d, l->search_domains) {
bool manager_dnssec_supported(Manager *m) {
DnsServer *server;
- Iterator i;
Link *l;
assert(m);
if (server && !dns_server_dnssec_supported(server))
return false;
- HASHMAP_FOREACH(l, m->links, i)
+ HASHMAP_FOREACH(l, m->links)
if (!link_dnssec_supported(l))
return false;
}
bool manager_routable(Manager *m, int family) {
- Iterator i;
Link *l;
assert(m);
/* Returns true if the host has at least one interface with a routable address of the specified type */
- HASHMAP_FOREACH(l, m->links, i)
+ HASHMAP_FOREACH(l, m->links)
if (link_relevant(l, family, false))
return true;
}
void manager_reset_server_features(Manager *m) {
- Iterator i;
Link *l;
dns_server_reset_features_all(m->dns_servers);
dns_server_reset_features_all(m->fallback_dns_servers);
- HASHMAP_FOREACH(l, m->links, i)
+ HASHMAP_FOREACH(l, m->links)
dns_server_reset_features_all(l->dns_servers);
log_info("Resetting learnt feature levels on all servers.");
}
bool manager_next_dnssd_names(Manager *m) {
- Iterator i;
DnssdService *s;
bool tried = false;
int r;
assert(m);
- HASHMAP_FOREACH(s, m->dnssd_services, i) {
+ HASHMAP_FOREACH(s, m->dnssd_services) {
_cleanup_free_ char * new_name = NULL;
if (!s->withdrawn)
static void write_resolv_conf_search(
OrderedSet *domains,
FILE *f) {
- Iterator i;
char *domain;
assert(domains);
fputs("search", f);
- ORDERED_SET_FOREACH(domain, domains, i) {
+ ORDERED_SET_FOREACH(domain, domains) {
fputc(' ', f);
fputs(domain, f);
}
}
static int write_uplink_resolv_conf_contents(FILE *f, OrderedSet *dns, OrderedSet *domains) {
- Iterator i;
fputs("# This file is managed by man:systemd-resolved(8). Do not edit.\n"
"#\n"
unsigned count = 0;
DnsServer *s;
- ORDERED_SET_FOREACH(s, dns, i)
+ ORDERED_SET_FOREACH(s, dns)
write_resolv_conf_server(s, f, &count);
}
bool bitmap_equal(const Bitmap *a, const Bitmap *b);
-#define BITMAP_FOREACH(n, b, i) \
- for ((i).idx = 0; bitmap_iterate((b), &(i), (unsigned*)&(n)); )
+#define _BITMAP_FOREACH(n, b, i) \
+ for (Iterator i = {}; bitmap_iterate((b), &i, (unsigned*)&(n)); )
+#define BITMAP_FOREACH(n, b) \
+ _BITMAP_FOREACH(n, b, UNIQ_T(i, UNIQ))
DEFINE_TRIVIAL_CLEANUP_FUNC(Bitmap*, bitmap_free);
size_t n = 0, i;
pid_t *pids;
void *pidp;
- Iterator j;
int width;
/* Order processes by their PID */
pids = newa(pid_t, hashmap_size(cg->pids));
- HASHMAP_FOREACH_KEY(name, pidp, cg->pids, j)
+ HASHMAP_FOREACH_KEY(name, pidp, cg->pids)
pids[n++] = PTR_TO_PID(pidp);
assert(n == hashmap_size(cg->pids));
_cleanup_hashmap_free_ Hashmap *names = NULL;
struct CGroupInfo *cg;
size_t n_allocated = 0, n = 0, k;
- Iterator i;
int width, r;
/* Prints the extra processes, i.e. those that are in cgroups we haven't displayed yet. We show them as
* combined, sorted, linear list. */
- HASHMAP_FOREACH(cg, cgroups, i) {
+ HASHMAP_FOREACH(cg, cgroups) {
const char *name;
void *pidp;
- Iterator j;
if (cg->done)
continue;
if (!GREEDY_REALLOC(pids, n_allocated, n + hashmap_size(cg->pids)))
return -ENOMEM;
- HASHMAP_FOREACH_KEY(name, pidp, cg->pids, j) {
+ HASHMAP_FOREACH_KEY(name, pidp, cg->pids) {
pids[n++] = PTR_TO_PID(pidp);
r = hashmap_put(names, pidp, (void*) name);
_cleanup_strv_free_ char **dirs = NULL;
const char *n;
char **p;
- Iterator i;
int r;
assert(ret);
STRV_FOREACH(p, lookup_path)
(void) unit_file_find_dirs(original_root, unit_path_cache, *p, name, dir_suffix, &dirs);
- SET_FOREACH(n, aliases, i)
+ SET_FOREACH(n, aliases)
STRV_FOREACH(p, lookup_path)
(void) unit_file_find_dirs(original_root, unit_path_cache, *p, n, dir_suffix, &dirs);
}
int fdset_cloexec(FDSet *fds, bool b) {
- Iterator i;
void *p;
int r;
assert(fds);
- SET_FOREACH(p, MAKE_SET(fds), i) {
+ SET_FOREACH(p, MAKE_SET(fds)) {
r = fd_cloexec(PTR_TO_FD(p), b);
if (r < 0)
return r;
int fdset_close_others(FDSet *fds) {
void *e;
- Iterator i;
int *a = NULL;
size_t j = 0, m;
if (m > 0) {
a = newa(int, m);
- SET_FOREACH(e, MAKE_SET(fds), i)
+ SET_FOREACH(e, MAKE_SET(fds))
a[j++] = PTR_TO_FD(e);
}
void fdset_close(FDSet *fds);
-#define FDSET_FOREACH(fd, fds, i) \
- for ((i) = ITERATOR_FIRST, (fd) = fdset_iterate((fds), &(i)); (fd) >= 0; (fd) = fdset_iterate((fds), &(i)))
+#define _FDSET_FOREACH(fd, fds, i) \
+ for (Iterator i = ITERATOR_FIRST; ((fd) = fdset_iterate((fds), &i)) >= 0; )
+#define FDSET_FOREACH(fd, fds) \
+ _FDSET_FOREACH(fd, fds, UNIQ_T(i, UNIQ))
DEFINE_TRIVIAL_CLEANUP_FUNC(FDSet*, fdset_free);
#define _cleanup_fdset_free_ _cleanup_(fdset_freep)
}
int journal_access_check_and_warn(sd_journal *j, bool quiet, bool want_other_users) {
- Iterator it;
void *code;
char *path;
int r = 0;
r = log_error_errno(EACCES, "No journal files were opened due to insufficient permissions.");
}
- HASHMAP_FOREACH_KEY(path, code, j->errors, it) {
+ HASHMAP_FOREACH_KEY(path, code, j->errors) {
int err;
err = abs(PTR_TO_INT(code));
sd_id128_t boot_id;
Hashmap *h = NULL;
size_t n = 0;
- Iterator i;
int r;
assert(j);
goto finish;
}
- HASHMAP_FOREACH(d, h, i) {
+ HASHMAP_FOREACH(d, h) {
assert(d->n_values > 0);
array[n++] = json_variant_ref(d->name);
int r, prio = LOG_INFO;
const char *field;
- Iterator iterator;
assert(j);
assert(f);
if (set_isempty(output_fields))
return output_cat_field(f, j, flags, prio, "MESSAGE", highlight);
- SET_FOREACH(field, output_fields, iterator) {
+ SET_FOREACH(field, output_fields) {
r = output_cat_field(f, j, flags, prio, field, streq(field, "MESSAGE") ? highlight : NULL);
if (r < 0)
return r;
SECCOMP_FOREACH_LOCAL_ARCH(arch) {
_cleanup_(seccomp_releasep) scmp_filter_ctx seccomp = NULL;
- Iterator i;
void *syscall_id, *val;
log_debug("Operating on architecture: %s", seccomp_arch_to_string(arch));
if (r < 0)
return r;
- HASHMAP_FOREACH_KEY(val, syscall_id, set, i) {
+ HASHMAP_FOREACH_KEY(val, syscall_id, set) {
uint32_t a = action;
int id = PTR_TO_INT(syscall_id) - 1;
int error = PTR_TO_INT(val);
SECCOMP_FOREACH_LOCAL_ARCH(arch) {
_cleanup_(seccomp_releasep) scmp_filter_ctx seccomp = NULL;
bool supported;
- Iterator i;
log_debug("Operating on architecture: %s", seccomp_arch_to_string(arch));
* range and then everything that is not in the set. First, we find the lowest and
* highest address family in the set. */
- SET_FOREACH(afp, address_families, i) {
+ SET_FOREACH(afp, address_families) {
int af = PTR_TO_INT(afp);
if (af <= 0 || af >= af_max())
/* If this is a deny list, then generate one rule for each address family that are
* then combined in OR checks. */
- SET_FOREACH(af, address_families, i) {
+ SET_FOREACH(af, address_families) {
r = seccomp_rule_add_exact(
seccomp,
SCMP_ACT_ERRNO(EAFNOSUPPORT),
int seccomp_restrict_archs(Set *archs) {
_cleanup_(seccomp_releasep) scmp_filter_ctx seccomp = NULL;
- Iterator i;
void *id;
int r;
if (!seccomp)
return -ENOMEM;
- SET_FOREACH(id, archs, i) {
+ SET_FOREACH(id, archs) {
r = seccomp_arch_add(seccomp, PTR_TO_UINT32(id) - 1);
if (r < 0 && r != -EEXIST)
return r;
}
/* Let's also put the names in the reverse db. */
- Iterator it;
const char *dummy, *src;
- HASHMAP_FOREACH_KEY(dummy, src, ids, it) {
+ HASHMAP_FOREACH_KEY(dummy, src, ids) {
const char *dst;
r = unit_ids_map_get(ids, src, &dst);
static int apply_all(OrderedHashmap *sysctl_options) {
Option *option;
- Iterator i;
int r = 0;
- ORDERED_HASHMAP_FOREACH(option, sysctl_options, i) {
+ ORDERED_HASHMAP_FOREACH(option, sysctl_options) {
int k;
/* Ignore "negative match" options, they are there only to exclude stuff from globs. */
if (install_client_side()) {
Hashmap *h;
UnitFileList *u;
- Iterator i;
unsigned n_units;
h = hashmap_new(&string_hash_ops);
return log_oom();
}
- HASHMAP_FOREACH(u, h, i) {
+ HASHMAP_FOREACH(u, h) {
if (!output_show_unit_file(u, NULL, NULL))
continue;
_cleanup_fclose_ FILE *original = NULL, *passwd = NULL;
_cleanup_(unlink_and_freep) char *passwd_tmp = NULL;
struct passwd *pw = NULL;
- Iterator iterator;
Item *i;
int r;
return -errno;
}
- ORDERED_HASHMAP_FOREACH(i, todo_uids, iterator) {
+ ORDERED_HASHMAP_FOREACH(i, todo_uids) {
struct passwd n = {
.pw_name = i->name,
.pw_uid = i->uid,
_cleanup_fclose_ FILE *original = NULL, *shadow = NULL;
_cleanup_(unlink_and_freep) char *shadow_tmp = NULL;
struct spwd *sp = NULL;
- Iterator iterator;
long lstchg;
Item *i;
int r;
return -errno;
}
- ORDERED_HASHMAP_FOREACH(i, todo_uids, iterator) {
+ ORDERED_HASHMAP_FOREACH(i, todo_uids) {
struct spwd n = {
.sp_namp = i->name,
.sp_pwdp = (char*) "!*", /* lock this password, and make it invalid */
_cleanup_(unlink_and_freep) char *group_tmp = NULL;
bool group_changed = false;
struct group *gr = NULL;
- Iterator iterator;
Item *i;
int r;
return -errno;
}
- ORDERED_HASHMAP_FOREACH(i, todo_gids, iterator) {
+ ORDERED_HASHMAP_FOREACH(i, todo_gids) {
struct group n = {
.gr_name = i->name,
.gr_gid = i->gid,
_cleanup_fclose_ FILE *original = NULL, *gshadow = NULL;
_cleanup_(unlink_and_freep) char *gshadow_tmp = NULL;
bool group_changed = false;
- Iterator iterator;
Item *i;
int r;
return -errno;
}
- ORDERED_HASHMAP_FOREACH(i, todo_gids, iterator) {
+ ORDERED_HASHMAP_FOREACH(i, todo_gids) {
struct sgrp n = {
.sg_namp = i->name,
.sg_passwd = (char*) "!!",
static int add_implicit(void) {
char *g, **l;
- Iterator iterator;
int r;
/* Implicitly create additional users and groups, if they were listed in "m" lines */
- ORDERED_HASHMAP_FOREACH_KEY(l, g, members, iterator) {
+ ORDERED_HASHMAP_FOREACH_KEY(l, g, members) {
char **m;
STRV_FOREACH(m, l)
_cleanup_(decrypted_image_unrefp) DecryptedImage *decrypted_image = NULL;
_cleanup_(umount_and_rmdir_and_freep) char *unlink_dir = NULL;
_cleanup_close_ int lock = -1;
- Iterator iterator;
Item *i;
int r;
if (r < 0)
return log_error_errno(r, "Failed to read group database: %m");
- ORDERED_HASHMAP_FOREACH(i, groups, iterator)
+ ORDERED_HASHMAP_FOREACH(i, groups)
(void) process_item(i);
- ORDERED_HASHMAP_FOREACH(i, users, iterator)
+ ORDERED_HASHMAP_FOREACH(i, users)
(void) process_item(i);
r = write_files();
static int fix_order(SysvStub *s, Hashmap *all_services) {
SysvStub *other;
- Iterator j;
int r;
assert(s);
if (s->sysv_start_priority < 0)
return 0;
- HASHMAP_FOREACH(other, all_services, j) {
+ HASHMAP_FOREACH(other, all_services) {
if (s == other)
continue;
Set *runlevel_services[ELEMENTSOF(rcnd_table)] = {};
_cleanup_strv_free_ char **sysvrcnd_path = NULL;
SysvStub *service;
- Iterator j;
char **p;
int r;
}
for (unsigned i = 0; i < ELEMENTSOF(rcnd_table); i++)
- SET_FOREACH(service, runlevel_services[i], j) {
+ SET_FOREACH(service, runlevel_services[i]) {
r = strv_extend(&service->before, rcnd_table[i].target);
if (r < 0) {
log_oom();
_cleanup_(free_sysvstub_hashmapp) Hashmap *all_services = NULL;
_cleanup_(lookup_paths_free) LookupPaths lp = {};
SysvStub *service;
- Iterator j;
int r;
assert_se(arg_dest = dest_late);
if (r < 0)
return r;
- HASHMAP_FOREACH(service, all_services, j)
+ HASHMAP_FOREACH(service, all_services)
(void) load_sysv(service);
- HASHMAP_FOREACH(service, all_services, j) {
+ HASHMAP_FOREACH(service, all_services) {
(void) fix_order(service, all_services);
(void) generate_unit_file(service);
}
int main(int argc, const char *argv[]) {
_cleanup_bitmap_free_ Bitmap *b = NULL, *b2 = NULL;
- Iterator it;
unsigned n = (unsigned) -1, i = 0;
b = bitmap_new();
assert_se(bitmap_isset(b, 32) == true);
bitmap_unset(b, 32);
- BITMAP_FOREACH(n, NULL, it)
+ BITMAP_FOREACH(n, NULL)
assert_not_reached("NULL bitmap");
assert_se(bitmap_set(b, 0) == 0);
assert_se(bitmap_set(b, 1) == 0);
assert_se(bitmap_set(b, 256) == 0);
- BITMAP_FOREACH(n, b, it) {
+ BITMAP_FOREACH(n, b) {
assert_se(n == i);
if (i == 0)
i = 1;
i = 0;
- BITMAP_FOREACH(n, b, it) {
+ BITMAP_FOREACH(n, b) {
assert_se(n == i);
if (i == 0)
i = 1;
int fd = -1;
FDSet *fdset = NULL;
char name[] = "/tmp/test-fdset_iterate.XXXXXX";
- Iterator i;
int c = 0;
int a;
assert_se(fdset_put(fdset, fd) >= 0);
assert_se(fdset_put(fdset, fd) >= 0);
- FDSET_FOREACH(a, fdset, i) {
+ FDSET_FOREACH(a, fdset) {
c++;
assert_se(a == fd);
}
static void test_hashmap_foreach_key(void) {
Hashmap *m;
- Iterator i;
bool key_found[] = { false, false, false, false };
const char *s;
const char *key;
NULSTR_FOREACH(key, key_table)
hashmap_put(m, key, (void*) (const char*) "my dummy val");
- HASHMAP_FOREACH_KEY(s, key, m, i) {
+ HASHMAP_FOREACH_KEY(s, key, m) {
assert(s);
if (!key_found[0] && streq(key, "key 1"))
key_found[0] = true;
static void test_hashmap_foreach(void) {
Hashmap *m;
- Iterator i;
bool value_found[] = { false, false, false, false };
char *val1, *val2, *val3, *val4, *s;
unsigned count;
m = NULL;
count = 0;
- HASHMAP_FOREACH(s, m, i)
+ HASHMAP_FOREACH(s, m)
count++;
assert_se(count == 0);
m = hashmap_new(&string_hash_ops);
count = 0;
- HASHMAP_FOREACH(s, m, i)
+ HASHMAP_FOREACH(s, m)
count++;
assert_se(count == 0);
hashmap_put(m, "Key 3", val3);
hashmap_put(m, "Key 4", val4);
- HASHMAP_FOREACH(s, m, i) {
+ HASHMAP_FOREACH(s, m) {
if (!value_found[0] && streq(s, val1))
value_found[0] = true;
else if (!value_found[1] && streq(s, val2))
static void compare_cache(Hashmap *map, IteratedCache *cache) {
const void **keys = NULL, **values = NULL;
unsigned num, idx;
- Iterator iter;
void *k, *v;
assert_se(iterated_cache_get(cache, &keys, &values, &num) == 0);
assert_se(num == 0 || values);
idx = 0;
- HASHMAP_FOREACH_KEY(v, k, map, iter) {
+ HASHMAP_FOREACH_KEY(v, k, map) {
assert_se(v == values[idx]);
assert_se(k == keys[idx]);
const char *p, *q;
UnitFileState state;
bool got_yes = false, got_no = false;
- Iterator j;
UnitFileList *fl;
Hashmap *h;
p = strjoina(root, "/usr/lib/systemd/system/preset-yes.service");
q = strjoina(root, "/usr/lib/systemd/system/preset-no.service");
- HASHMAP_FOREACH(fl, h, j) {
+ HASHMAP_FOREACH(fl, h) {
assert_se(unit_file_get_state(UNIT_FILE_SYSTEM, root, basename(fl->path), &state) >= 0);
assert_se(fl->state == state);
int main(int argc, char* argv[]) {
Hashmap *h;
UnitFileList *p;
- Iterator i;
int r;
const char *const files[] = { "avahi-daemon.service", NULL };
const char *const files2[] = { "/home/lennart/test.service", NULL };
r = unit_file_get_list(UNIT_FILE_SYSTEM, NULL, h, NULL, NULL);
assert_se(r == 0);
- HASHMAP_FOREACH(p, h, i) {
+ HASHMAP_FOREACH(p, h) {
UnitFileState s = _UNIT_FILE_STATE_INVALID;
r = unit_file_get_state(UNIT_FILE_SYSTEM, NULL, basename(p->path), &s);
static int test_unit_file_get_set(void) {
int r;
Hashmap *h;
- Iterator i;
UnitFileList *p;
h = hashmap_new(&string_hash_ops);
if (r < 0)
return EXIT_FAILURE;
- HASHMAP_FOREACH(p, h, i)
+ HASHMAP_FOREACH(p, h)
printf("%s = %s\n", p->path, unit_file_state_to_string(p->state));
unit_file_list_free(h);
static void test_mnt_id(void) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_hashmap_free_free_ Hashmap *h = NULL;
- Iterator i;
char *p;
void *k;
int r;
path = NULL;
}
- HASHMAP_FOREACH_KEY(p, k, h, i) {
+ HASHMAP_FOREACH_KEY(p, k, h) {
int mnt_id = PTR_TO_INT(k), mnt_id2;
r = path_get_mnt_id(p, &mnt_id2);
_cleanup_(lookup_paths_free) LookupPaths lp = {};
_cleanup_hashmap_free_ Hashmap *unit_ids = NULL;
_cleanup_hashmap_free_ Hashmap *unit_names = NULL;
- Iterator i;
const char *k, *dst;
char **v;
usec_t mtime = 0;
assert_se(unit_file_build_name_map(&lp, &mtime, &unit_ids, &unit_names, NULL) == 1);
- HASHMAP_FOREACH_KEY(dst, k, unit_ids, i)
+ HASHMAP_FOREACH_KEY(dst, k, unit_ids)
log_info("ids: %s → %s", k, dst);
- HASHMAP_FOREACH_KEY(v, k, unit_names, i) {
+ HASHMAP_FOREACH_KEY(v, k, unit_names) {
_cleanup_free_ char *j = strv_join(v, ", ");
log_info("aliases: %s ← %s", k, j);
}
char **id;
STRV_FOREACH(id, ids) {
const char *fragment, *name;
- Iterator it;
_cleanup_set_free_free_ Set *names = NULL;
log_info("*** %s ***", *id);
r = unit_file_find_fragment(unit_ids,
assert(r == 0);
log_info("fragment: %s", fragment);
log_info("names:");
- SET_FOREACH(name, names, it)
+ SET_FOREACH(name, names)
log_info(" %s", name);
}
}
static struct Item* find_glob(OrderedHashmap *h, const char *match) {
ItemArray *j;
- Iterator i;
- ORDERED_HASHMAP_FOREACH(j, h, i) {
+ ORDERED_HASHMAP_FOREACH(j, h) {
size_t n;
for (n = 0; n < j->n_items; n++) {
/* Clean up all children first */
if ((operation & (OPERATION_REMOVE|OPERATION_CLEAN)) && !set_isempty(array->children)) {
- Iterator i;
ItemArray *c;
- SET_FOREACH(c, array->children, i) {
+ SET_FOREACH(c, array->children) {
int k;
k = process_item_array(c, operation & (OPERATION_REMOVE|OPERATION_CLEAN));
static int read_config_file(char **config_dirs, const char *fn, bool ignore_enoent, bool *invalid_config) {
_cleanup_(hashmap_freep) Hashmap *uid_cache = NULL, *gid_cache = NULL;
_cleanup_fclose_ FILE *_f = NULL;
- Iterator iterator;
unsigned v = 0;
FILE *f;
Item *i;
}
/* we have to determine age parameter for each entry of type X */
- ORDERED_HASHMAP_FOREACH(i, globs, iterator) {
- Iterator iter;
+ ORDERED_HASHMAP_FOREACH(i, globs) {
Item *j, *candidate_item = NULL;
if (i->type != IGNORE_DIRECTORY_PATH)
continue;
- ORDERED_HASHMAP_FOREACH(j, items, iter) {
+ ORDERED_HASHMAP_FOREACH(j, items) {
if (!IN_SET(j->type, CREATE_DIRECTORY, TRUNCATE_DIRECTORY, CREATE_SUBVOLUME, CREATE_SUBVOLUME_INHERIT_QUOTA, CREATE_SUBVOLUME_NEW_QUOTA))
continue;
_cleanup_(umount_and_rmdir_and_freep) char *unlink_dir = NULL;
_cleanup_strv_free_ char **config_dirs = NULL;
bool invalid_config = false;
- Iterator iterator;
ItemArray *a;
enum {
PHASE_REMOVE_AND_CLEAN,
return r;
/* Let's now link up all child/parent relationships */
- ORDERED_HASHMAP_FOREACH(a, items, iterator) {
+ ORDERED_HASHMAP_FOREACH(a, items) {
r = link_parent(a);
if (r < 0)
return r;
}
- ORDERED_HASHMAP_FOREACH(a, globs, iterator) {
+ ORDERED_HASHMAP_FOREACH(a, globs) {
r = link_parent(a);
if (r < 0)
return r;
continue;
/* The non-globbing ones usually create things, hence we apply them first */
- ORDERED_HASHMAP_FOREACH(a, items, iterator) {
+ ORDERED_HASHMAP_FOREACH(a, items) {
k = process_item_array(a, op);
if (k < 0 && r >= 0)
r = k;
}
/* The globbing ones usually alter things, hence we apply them second. */
- ORDERED_HASHMAP_FOREACH(a, globs, iterator) {
+ ORDERED_HASHMAP_FOREACH(a, globs) {
k = process_item_array(a, op);
if (k < 0 && r >= 0)
r = k;
struct timespec ts;
siginfo_t status = {};
sigset_t set;
- Iterator i;
void *p;
int r, signum;
* Request termination of the remaining processes as those
* are not required anymore.
*/
- SET_FOREACH(p, pids, i)
+ SET_FOREACH(p, pids)
(void) kill(PTR_TO_PID(p), SIGTERM);
/*
/*
* Kill hanging processes.
*/
- SET_FOREACH(p, pids, i) {
+ SET_FOREACH(p, pids) {
log_warning("Failed to terminate child %d, killing it", PTR_TO_PID(p));
(void) kill(PTR_TO_PID(p), SIGKILL);
}
void udev_event_execute_run(UdevEvent *event, usec_t timeout_usec, int timeout_signal) {
const char *command;
void *val;
- Iterator i;
int r;
- ORDERED_HASHMAP_FOREACH_KEY(val, command, event->run_list, i) {
+ ORDERED_HASHMAP_FOREACH_KEY(val, command, event->run_list) {
UdevBuiltinCommand builtin_cmd = PTR_TO_UDEV_BUILTIN_CMD(val);
if (builtin_cmd != _UDEV_BUILTIN_INVALID) {
if (apply_mode || apply_uid || apply_gid || apply_mac) {
bool selinux = false, smack = false;
const char *name, *label;
- Iterator i;
if (apply_mode || apply_uid || apply_gid) {
log_device_debug(dev, "Setting permissions %s, uid=" UID_FMT ", gid=" GID_FMT ", mode=%#o",
mode != MODE_INVALID ? mode & 0777 : stats.st_mode & 0777);
/* apply SECLABEL{$module}=$label */
- ORDERED_HASHMAP_FOREACH_KEY(label, name, seclabel_list, i) {
+ ORDERED_HASHMAP_FOREACH_KEY(label, name, seclabel_list) {
int q;
if (streq(name, "selinux")) {
static int setup_monitor(MonitorNetlinkGroup sender, sd_event *event, sd_device_monitor **ret) {
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor = NULL;
const char *subsystem, *devtype, *tag;
- Iterator i;
int r;
r = device_monitor_new_full(&monitor, sender, -1);
if (r < 0)
return log_error_errno(r, "Failed to attach event: %m");
- HASHMAP_FOREACH_KEY(devtype, subsystem, arg_subsystem_filter, i) {
+ HASHMAP_FOREACH_KEY(devtype, subsystem, arg_subsystem_filter) {
r = sd_device_monitor_filter_add_match_subsystem_devtype(monitor, subsystem, devtype);
if (r < 0)
return log_error_errno(r, "Failed to apply subsystem filter '%s%s%s': %m",
subsystem, devtype ? "/" : "", strempty(devtype));
}
- SET_FOREACH(tag, arg_tag_filter, i) {
+ SET_FOREACH(tag, arg_tag_filter) {
r = sd_device_monitor_filter_add_match_tag(monitor, tag);
if (r < 0)
return log_error_errno(r, "Failed to apply tag filter '%s': %m", tag);
_cleanup_(sd_device_unrefp) sd_device *dev = NULL;
const char *cmd, *key, *value;
sigset_t mask, sigmask_orig;
- Iterator i;
void *val;
int r;
FOREACH_DEVICE_PROPERTY(dev, key, value)
printf("%s=%s\n", key, value);
- ORDERED_HASHMAP_FOREACH_KEY(val, cmd, event->run_list, i) {
+ ORDERED_HASHMAP_FOREACH_KEY(val, cmd, event->run_list) {
char program[UTIL_PATH_SIZE];
(void) udev_event_apply_format(event, cmd, program, sizeof(program), false);
static void event_run(Manager *manager, struct event *event) {
static bool log_children_max_reached = true;
struct worker *worker;
- Iterator i;
int r;
assert(manager);
event->seqnum, r >= 0 ? device_action_to_string(action) : "<unknown>");
}
- HASHMAP_FOREACH(worker, manager->workers, i) {
+ HASHMAP_FOREACH(worker, manager->workers) {
if (worker->state != WORKER_IDLE)
continue;
static void manager_kill_workers(Manager *manager) {
struct worker *worker;
- Iterator i;
assert(manager);
- HASHMAP_FOREACH(worker, manager->workers, i) {
+ HASHMAP_FOREACH(worker, manager->workers) {
if (worker->state == WORKER_KILLED)
continue;
static int run(const char *dest, const char *dest_early, const char *dest_late) {
_cleanup_(hashmap_freep) Hashmap *all_services = NULL;
XdgAutostartService *service;
- Iterator j;
int r;
assert_se(dest_late);
if (r < 0)
return r;
- HASHMAP_FOREACH(service, all_services, j)
+ HASHMAP_FOREACH(service, all_services)
(void) xdg_autostart_service_generate_unit(service, dest_late);
return 0;
projects / thirdparty / systemd.git / commitdiff
