--- /dev/null
+systemd
+*.o
--- /dev/null
+
+- 8ch indent, no tabs
+
+- structs in MixedCase, variables, functions in lower_case
+
+- the destructors always unregister the object from the next bigger
+ object, not the other way around
+
+- to minimize strict aliasing violations we prefer unions over casting
+
+- for robustness reasons destructors should be able to destruct
+ half-initialized objects, too
+
+- error codes are returned as negative Exxx. i.e. return EINVAL. There
+ are some exceptions: for constructors its is OK to return NULL on
+ OOM. For lookup functions NULL is fine too for "not found".
--- /dev/null
+CFLAGS=-Wall -Wextra -O0 -g -pipe
+LIBS=-lrt
+
+systemd: main.o name.o util.o set.o hashmap.o strv.o job.o manager.o
+ $(CC) $(CFLAGS) -o $@ $^ $(LIBS)
+
+clean:
+ rm -f *.o systemd
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "util.h"
+#include "hashmap.h"
+#include "macro.h"
+
+#define NBUCKETS 127
+
+struct hashmap_entry {
+ const void *key;
+ void *value;
+
+ struct hashmap_entry *bucket_next, *bucket_previous;
+ struct hashmap_entry *iterate_next, *iterate_previous;
+};
+
+struct Hashmap {
+ hash_func_t hash_func;
+ compare_func_t compare_func;
+
+ struct hashmap_entry *iterate_list_head, *iterate_list_tail;
+ unsigned n_entries;
+};
+
+#define BY_HASH(h) ((struct hashmap_entry**) ((uint8_t*) (h) + ALIGN(sizeof(Hashmap))))
+
+unsigned string_hash_func(const void *p) {
+ unsigned hash = 0;
+ const char *c;
+
+ for (c = p; *c; c++)
+ hash = 31 * hash + (unsigned) *c;
+
+ return hash;
+}
+
+int string_compare_func(const void *a, const void *b) {
+ return strcmp(a, b);
+}
+
+unsigned trivial_hash_func(const void *p) {
+ return PTR_TO_UINT(p);
+}
+
+int trivial_compare_func(const void *a, const void *b) {
+ return a < b ? -1 : (a > b ? 1 : 0);
+}
+
+Hashmap *hashmap_new(hash_func_t hash_func, compare_func_t compare_func) {
+ Hashmap *h;
+
+ if (!(h = malloc0(ALIGN(sizeof(Hashmap)) + NBUCKETS * ALIGN(sizeof(struct hashmap_entry*)))))
+ return NULL;
+
+ h->hash_func = hash_func ? hash_func : trivial_hash_func;
+ h->compare_func = compare_func ? compare_func : trivial_compare_func;
+
+ h->n_entries = 0;
+ h->iterate_list_head = h->iterate_list_tail = NULL;
+
+ return h;
+}
+
+static void remove_entry(Hashmap *h, struct hashmap_entry *e) {
+ assert(h);
+ assert(e);
+
+ /* Remove from iteration list */
+ if (e->iterate_next)
+ e->iterate_next->iterate_previous = e->iterate_previous;
+ else
+ h->iterate_list_tail = e->iterate_previous;
+
+ if (e->iterate_previous)
+ e->iterate_previous->iterate_next = e->iterate_next;
+ else
+ h->iterate_list_head = e->iterate_next;
+
+ /* Remove from hash table bucket list */
+ if (e->bucket_next)
+ e->bucket_next->bucket_previous = e->bucket_previous;
+
+ if (e->bucket_previous)
+ e->bucket_previous->bucket_next = e->bucket_next;
+ else {
+ unsigned hash = h->hash_func(e->key) % NBUCKETS;
+ BY_HASH(h)[hash] = e->bucket_next;
+ }
+
+ free(e);
+
+ assert(h->n_entries >= 1);
+ h->n_entries--;
+}
+
+void hashmap_free(Hashmap*h) {
+
+ if (!h)
+ return;
+
+ while (h->iterate_list_head)
+ remove_entry(h, h->iterate_list_head);
+
+ free(h);
+}
+
+static struct hashmap_entry *hash_scan(Hashmap *h, unsigned hash, const void *key) {
+ struct hashmap_entry *e;
+ assert(h);
+ assert(hash < NBUCKETS);
+
+ for (e = BY_HASH(h)[hash]; e; e = e->bucket_next)
+ if (h->compare_func(e->key, key) == 0)
+ return e;
+
+ return NULL;
+}
+
+int hashmap_put(Hashmap *h, const void *key, void *value) {
+ struct hashmap_entry *e;
+ unsigned hash;
+
+ assert(h);
+
+ hash = h->hash_func(key) % NBUCKETS;
+
+ if (hash_scan(h, hash, key))
+ return -EEXIST;
+
+ if (!(e = new(struct hashmap_entry, 1)))
+ return -ENOMEM;
+
+ e->key = key;
+ e->value = value;
+
+ /* Insert into hash table */
+ e->bucket_next = BY_HASH(h)[hash];
+ e->bucket_previous = NULL;
+ if (BY_HASH(h)[hash])
+ BY_HASH(h)[hash]->bucket_previous = e;
+ BY_HASH(h)[hash] = e;
+
+ /* Insert into iteration list */
+ e->iterate_previous = h->iterate_list_tail;
+ e->iterate_next = NULL;
+ if (h->iterate_list_tail) {
+ assert(h->iterate_list_head);
+ h->iterate_list_tail->iterate_next = e;
+ } else {
+ assert(!h->iterate_list_head);
+ h->iterate_list_head = e;
+ }
+ h->iterate_list_tail = e;
+
+ h->n_entries++;
+ assert(h->n_entries >= 1);
+
+ return 0;
+}
+
+void* hashmap_get(Hashmap *h, const void *key) {
+ unsigned hash;
+ struct hashmap_entry *e;
+
+ if (!h)
+ return NULL;
+
+ hash = h->hash_func(key) % NBUCKETS;
+
+ if (!(e = hash_scan(h, hash, key)))
+ return NULL;
+
+ return e->value;
+}
+
+void* hashmap_remove(Hashmap *h, const void *key) {
+ struct hashmap_entry *e;
+ unsigned hash;
+ void *data;
+
+ if (!h)
+ return NULL;
+
+ hash = h->hash_func(key) % NBUCKETS;
+
+ if (!(e = hash_scan(h, hash, key)))
+ return NULL;
+
+ data = e->value;
+ remove_entry(h, e);
+
+ return data;
+}
+
+void *hashmap_iterate(Hashmap *h, void **state, const void **key) {
+ struct hashmap_entry *e;
+
+ assert(state);
+
+ if (!h)
+ goto at_end;
+
+ if (*state == (void*) -1)
+ goto at_end;
+
+ if (!*state && !h->iterate_list_head)
+ goto at_end;
+
+ e = *state ? *state : h->iterate_list_head;
+
+ if (e->iterate_next)
+ *state = e->iterate_next;
+ else
+ *state = (void*) -1;
+
+ if (key)
+ *key = e->key;
+
+ return e->value;
+
+at_end:
+ *state = (void *) -1;
+
+ if (key)
+ *key = NULL;
+
+ return NULL;
+}
+
+void *hashmap_iterate_backwards(Hashmap *h, void **state, const void **key) {
+ struct hashmap_entry *e;
+
+ assert(state);
+
+ if (!h)
+ goto at_beginning;
+
+ if (*state == (void*) -1)
+ goto at_beginning;
+
+ if (!*state && !h->iterate_list_tail)
+ goto at_beginning;
+
+ e = *state ? *state : h->iterate_list_tail;
+
+ if (e->iterate_previous)
+ *state = e->iterate_previous;
+ else
+ *state = (void*) -1;
+
+ if (key)
+ *key = e->key;
+
+ return e->value;
+
+at_beginning:
+ *state = (void *) -1;
+
+ if (key)
+ *key = NULL;
+
+ return NULL;
+}
+
+void* hashmap_first(Hashmap *h) {
+
+ if (!h)
+ return NULL;
+
+ if (!h->iterate_list_head)
+ return NULL;
+
+ return h->iterate_list_head->value;
+}
+
+void* hashmap_last(Hashmap *h) {
+
+ if (!h)
+ return NULL;
+
+ if (!h->iterate_list_tail)
+ return NULL;
+
+ return h->iterate_list_tail->value;
+}
+
+void* hashmap_steal_first(Hashmap *h) {
+ void *data;
+
+ if (!h)
+ return NULL;
+
+ if (!h->iterate_list_head)
+ return NULL;
+
+ data = h->iterate_list_head->value;
+ remove_entry(h, h->iterate_list_head);
+
+ return data;
+}
+
+unsigned hashmap_size(Hashmap *h) {
+
+ if (!h)
+ return 0;
+
+ return h->n_entries;
+}
+
+bool hashmap_isempty(Hashmap *h) {
+
+ if (!h)
+ return true;
+
+ return h->n_entries == 0;
+}
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifndef foohashmaphfoo
+#define foohashmaphfoo
+
+#include <stdbool.h>
+
+/* Pretty straightforward hash table implementation. As a minor
+ * optimization a NULL hashmap object will be treated as empty hashmap
+ * for all read operations. That way it is not necessary to
+ * instantiate an object for each Hashmap use. */
+
+typedef struct Hashmap Hashmap;
+
+typedef unsigned (*hash_func_t)(const void *p);
+typedef int (*compare_func_t)(const void *a, const void *b);
+
+unsigned string_hash_func(const void *p);
+int string_compare_func(const void *a, const void *b);
+
+unsigned trivial_hash_func(const void *p);
+int trivial_compare_func(const void *a, const void *b);
+
+Hashmap *hashmap_new(hash_func_t hash_func, compare_func_t compare_func);
+void hashmap_free(Hashmap*);
+
+int hashmap_put(Hashmap *h, const void *key, void *value);
+void* hashmap_get(Hashmap *h, const void *key);
+void* hashmap_remove(Hashmap *h, const void *key);
+
+unsigned hashmap_size(Hashmap *h);
+bool hashmap_isempty(Hashmap *h);
+
+void *hashmap_iterate(Hashmap *h, void **state, const void **key);
+void *hashmap_iterate_backwards(Hashmap *h, void **state, const void **key);
+
+void *hashmap_steal_first(Hashmap *h);
+void* hashmap_first(Hashmap *h);
+void* hashmap_last(Hashmap *h);
+
+#define HASHMAP_FOREACH(e, h, state) \
+ for ((state) = NULL, (e) = hashmap_iterate((h), &(state), NULL); (e); (e) = hashmap_iterate((h), &(state), NULL))
+
+#define HASHMAP_FOREACH_BACKWARDS(e, h, state) \
+ for ((state) = NULL, (e) = hashmap_iterate_backwards((h), &(state), NULL); (e); (e) = hashmap_iterate_backwards((h), &(state), NULL))
+
+#endif
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#include <assert.h>
+
+#include "macro.h"
+#include "job.h"
+
+Job* job_new(Manager *m, JobType type, Name *name) {
+ Job *j;
+
+ assert(m);
+ assert(type < _JOB_TYPE_MAX);
+ assert(name);
+
+ if (!(j = new0(Job, 1)))
+ return NULL;
+
+ j->manager = m;
+ j->id = m->current_job_id++;
+ j->type = type;
+ j->name = name;
+
+ /* We don't link it here, that's what job_link() is for */
+
+ return j;
+}
+
+int job_link(Job *j) {
+ int r;
+
+ assert(j);
+ assert(!j->linked);
+
+ if ((r = hashmap_put(j->manager->jobs, UINT32_TO_PTR(j->id), j)) < 0)
+ return r;
+
+ j->name->meta.job = j;
+
+ j->linked = true;
+
+ return 0;
+}
+
+void job_free(Job *j) {
+ assert(j);
+
+ /* Detach from next 'bigger' objects */
+
+ if (j->linked) {
+ if (j->name && j->name->meta.job == j)
+ j->name->meta.job = NULL;
+
+ hashmap_remove(j->manager->jobs, UINT32_TO_PTR(j->id));
+ }
+
+ /* Free data and next 'smaller' objects */
+
+ free(j);
+}
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifndef foojobhfoo
+#define foojobhfoo
+
+#include <stdbool.h>
+#include <inttypes.h>
+
+typedef struct Job Job;
+typedef enum JobType JobType;
+typedef enum JobMode JobMode;
+
+#include "manager.h"
+#include "name.h"
+#include "hashmap.h"
+#include "list.h"
+
+enum JobType {
+ JOB_START,
+ JOB_STOP,
+ JOB_VERIFY_STARTED,
+ JOB_RELOAD,
+ JOB_RESTART,
+ JOB_TRY_RESTART, /* restart if running */
+ JOB_RESTART_FINISH, /* 2nd part of a restart, i.e. the actual starting */
+ _JOB_TYPE_MAX
+};
+
+typedef enum JobState {
+ JOB_WAITING,
+ JOB_RUNNING,
+ JOB_DONE,
+ _JOB_STATE_MAX
+} JobState;
+
+enum JobMode {
+ JOB_FAIL,
+ JOB_REPLACE,
+ _JOB_MODE_MAX
+};
+
+struct Job {
+ Manager *manager;
+ uint32_t id;
+
+ JobType type;
+ JobState state;
+ Name *name;
+
+ bool linked:1;
+};
+
+Job* job_new(Manager *m, JobType type, Name *name);
+int job_link(Job *job);
+void job_free(Job *job);
+
+#endif
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifndef foolisthfoo
+#define foolisthfoo
+
+/* The head of the linked list. Use this in the structure that shall
+ * contain the head of the linked list */
+#define LIST_HEAD(t,name) \
+ t *name
+
+/* The pointers in the linked list's items. Use this in the item structure */
+#define LIST_FIELDS(t) \
+ t *next, *prev
+
+/* Initialize the list's head */
+#define LIST_HEAD_INIT(t,item) \
+ do { \
+ (item) = (t*) NULL; } \
+ while(false)
+
+/* Initialize a list item */
+#define LIST_INIT(t,item) \
+ do { \
+ t *_item = (item); \
+ assert(_item); \
+ _item->prev = _item->next = NULL; \
+ } while(false)
+
+/* Prepend an item to the list */
+#define LIST_PREPEND(t,head,item) \
+ do { \
+ t **_head = &(head), *_item = (item); \
+ assert(_item); \
+ if ((_item->next = *_head)) \
+ _item->next->prev = _item; \
+ _item->prev = NULL; \
+ *_head = _item; \
+ } while(false)
+
+/* Remove an item from the list */
+#define LIST_REMOVE(t,head,item) \
+ do { \
+ t **_head = &(head), *_item = (item); \
+ assert(_item); \
+ if (_item->next) \
+ _item->next->prev = _item->prev; \
+ if (_item->prev) \
+ _item->prev->next = _item->next; \
+ else { \
+ assert(*_head == _item); \
+ *_head = _item->next; \
+ } \
+ _item->next = _item->prev = NULL; \
+ } while(false)
+
+/* Find the head of the list */
+#define LIST_FIND_HEAD(t,item,head) \
+ do { \
+ t **_head = (head), *_item = (item); \
+ *_head = _item; \
+ assert(_head); \
+ while ((*_head)->prev) \
+ *_head = (*_head)->prev; \
+ } while (false)
+
+/* Insert an item after another one (a = where, b = what) */
+#define LIST_INSERT_AFTER(t,head,a,b) \
+ do { \
+ t **_head = &(head), *_a = (a), *_b = (b); \
+ assert(_b); \
+ if (!_a) { \
+ if ((_b->next = *_head)) \
+ _b->next->prev = _b; \
+ _b->prev = NULL; \
+ *_head = _b; \
+ } else { \
+ if ((_b->next = _a->next)) \
+ _b->next->prev = _b; \
+ _b->prev = _a; \
+ _a->next = _b; \
+ } \
+ } while(false)
+
+#define LIST_FOREACH(i,head) \
+ for (i = (head); i; i = i->next)
+
+#define LIST_FOREACH_SAFE(i,n,head) \
+ for (i = (head); i && ((n = i->next), 1); i = n)
+
+#endif
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifndef foomacrohfoo
+#define foomacrohfoo
+
+#include <assert.h>
+#include <sys/types.h>
+
+#define __printf_attr(a,b) __attribute__ ((format (printf, a, b)))
+#define __sentinel __attribute__ ((sentinel))
+#define __noreturn __attribute__((noreturn))
+#define __unused __attribute__ ((unused))
+#define __destructor __attribute__ ((destructor))
+#define __pure __attribute__ ((pure))
+#define __const __attribute__ ((const))
+#define __deprecated __attribute__ ((deprecated))
+#define __packed __attribute__ ((packed))
+#define __malloc __attribute__ ((malloc))
+
+/* Rounds up */
+static inline size_t ALIGN(size_t l) {
+ return ((l + sizeof(void*) - 1) & ~(sizeof(void*) - 1));
+}
+
+#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0]))
+
+#define MAX(a,b) \
+ __extension__ ({ \
+ typeof(a) _a = (a); \
+ typeof(b) _b = (b); \
+ _a > _b ? _a : _b; \
+ })
+
+#define MIN(a,b) \
+ __extension__ ({ \
+ typeof(a) _a = (a); \
+ typeof(b) _b = (b); \
+ _a < _b ? _a : _b; \
+ })
+
+#define CLAMP(x, low, high) \
+ __extension__ ({ \
+ typeof(x) _x = (x); \
+ typeof(low) _low = (low); \
+ typeof(high) _high = (high); \
+ ((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \
+ })
+
+
+
+#define assert_not_reached(t) assert(!(t))
+
+#define assert_se(x) assert(x)
+
+#define assert_cc(expr) \
+ do { \
+ switch (0) { \
+ case 0: \
+ case !!(expr): \
+ ; \
+ } \
+ } while (false)
+
+#define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))
+#define UINT_TO_PTR(u) ((void*) ((uintptr_t) (u)))
+
+#define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
+#define UINT32_TO_PTR(u) ((void*) ((uintptr_t) (u)))
+
+#define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
+#define INT_TO_PTR(u) ((void*) ((intptr_t) (u)))
+
+#define TO_INT32(p) ((int32_t) ((intptr_t) (p)))
+#define INT32_TO_PTR(u) ((void*) ((intptr_t) (u)))
+
+#endif
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#include "manager.h"
+
+int main(int argc, char *argv[]) {
+ Manager *m = NULL;
+ Name *milestone = NULL;
+ Job *job = NULL;
+ int r, retval = 1;
+
+ if (!(m = manager_new()) < 0) {
+ fprintf(stderr, "Failed to allocate manager object: %s\n", strerror(ENOMEM));
+ goto finish;
+ }
+
+
+ if ((r = manager_load_name(m, "default.milestone", &milestone) < 0)) {
+ fprintf(stderr, "Failed to load default milestone: %s\n", strerror(-r));
+ goto finish;
+ }
+
+ if ((r = manager_add_job(m, JOB_START, milestone, JOB_REPLACE, &job)) < 0) {
+ fprintf(stderr, "Failed to start default milestone: %s\n", strerror(-r));
+ goto finish;
+ }
+
+ retval = 0;
+
+finish:
+ if (m)
+ manager_free(m);
+
+ return retval;
+}
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#include <assert.h>
+#include <errno.h>
+
+#include "manager.h"
+#include "hashmap.h"
+#include "macro.h"
+#include "strv.h"
+
+Manager* manager_new(void) {
+ Manager *m;
+
+ if (!(m = new0(Manager, 1)))
+ return NULL;
+
+ if (!(m->names = hashmap_new(string_hash_func, string_compare_func)))
+ goto fail;
+
+ if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
+ goto fail;
+
+ if (!(m->jobs_to_add = hashmap_new(trivial_hash_func, trivial_compare_func)))
+ goto fail;
+
+ if (!(m->jobs_to_remove = set_new(trivial_hash_func, trivial_compare_func)))
+ goto fail;
+
+ return m;
+
+fail:
+ manager_free(m);
+ return NULL;
+}
+
+void manager_free(Manager *m) {
+ Name *n;
+
+ assert(m);
+
+ while ((n = hashmap_first(m->names)))
+ name_free(n);
+
+ hashmap_free(m->names);
+ hashmap_free(m->jobs);
+
+ /* FIXME: This is incomplete */
+
+ hashmap_free(m->jobs_to_add);
+ set_free(m->jobs_to_remove);
+
+ free(m);
+}
+
+int manager_add_job(Manager *m, JobType type, Name *name, JobMode mode, Job **_ret) {
+ Job *ret, *other;
+ void *state;
+ Name *dep;
+ int r;
+
+ assert(m);
+ assert(type < _JOB_TYPE_MAX);
+ assert(name);
+ assert(mode < _JOB_MODE_MAX);
+ assert(_ret);
+
+ /* Check for conflicts, first against the jobs we shall
+ * create */
+ if ((other = hashmap_get(m->jobs_to_add, name))) {
+
+ if (other->type != type)
+ return -EEXIST;
+
+ } else if (name->meta.job) {
+
+ if (name->meta.job->type != type) {
+
+ if (mode == JOB_FAIL)
+ return -EEXIST;
+
+ if ((r = set_put(m->jobs_to_remove, name->meta.job)) < 0)
+ return r;
+ }
+ }
+
+ if (!(ret = job_new(m, type, name)))
+ return -ENOMEM;
+
+ if ((r = hashmap_put(m->jobs_to_add, name, ret)) < 0)
+ goto fail;
+
+ if (type == JOB_START || type == JOB_VERIFY_STARTED || type == JOB_RESTART_FINISH) {
+ SET_FOREACH(dep, ret->name->meta.requires, state)
+ if ((r = manager_add_job(m, type, dep, mode, NULL)) < 0)
+ goto fail;
+ SET_FOREACH(dep, ret->name->meta.soft_requires, state)
+ if ((r = manager_add_job(m, type, dep, JOB_FAIL, NULL)) < 0)
+ goto fail;
+ SET_FOREACH(dep, ret->name->meta.wants, state)
+ if ((r = manager_add_job(m, type, dep, JOB_FAIL, NULL)) < 0)
+ goto fail;
+ SET_FOREACH(dep, ret->name->meta.requisite, state)
+ if ((r = manager_add_job(m, JOB_VERIFY_STARTED, dep, mode, NULL)) < 0)
+ goto fail;
+ SET_FOREACH(dep, ret->name->meta.soft_requisite, state)
+ if ((r = manager_add_job(m, JOB_VERIFY_STARTED, dep, JOB_FAIL, NULL)) < 0)
+ goto fail;
+ SET_FOREACH(dep, ret->name->meta.conflicts, state)
+ if ((r = manager_add_job(m, type, dep, mode, NULL)) < 0)
+ goto fail;
+
+ } else if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
+
+ SET_FOREACH(dep, ret->name->meta.required_by, state)
+ if ((r = manager_add_job(m, type, dep, mode, NULL)) < 0)
+ goto fail;
+ }
+
+ if (_ret)
+ *_ret = ret;
+
+ return 0;
+
+fail:
+ job_free(ret);
+
+ return r;
+}
+
+
+Job *manager_get_job(Manager *m, uint32_t id) {
+ assert(m);
+
+ return hashmap_get(m->jobs, UINT32_TO_PTR(id));
+}
+
+Name *manager_get_name(Manager *m, const char *name) {
+ assert(m);
+ assert(name);
+
+ return hashmap_get(m->names, name);
+}
+
+static int detect_type(Name *name) {
+ char **n;
+
+ assert(name);
+
+ name->meta.type = _NAME_TYPE_INVALID;
+
+ STRV_FOREACH(n, name->meta.names) {
+ NameType t;
+
+ if ((t = name_type_from_string(*n)) == _NAME_TYPE_INVALID)
+ return -EINVAL;
+
+ if (name->meta.type == _NAME_TYPE_INVALID) {
+ name->meta.type = t;
+ continue;
+ }
+
+ if (name->meta.type != t)
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int fragment_load(Name *n) {
+ assert(n);
+
+ /*... */
+
+ return 0;
+}
+
+static int sysv_load(Service *s) {
+ assert(s);
+
+ /*... */
+
+ return 0;
+}
+
+static int fstab_load(Name *n) {
+ assert(n);
+ assert(n->meta.type == NAME_MOUNT || n->meta.type == NAME_AUTOMOUNT);
+
+ /*... */
+
+ return 0;
+}
+
+static int snapshot_load(Snapshot *s) {
+ assert(s);
+
+ /*... */
+
+ return 0;
+}
+
+static int load(Name *name) {
+ int r;
+
+ assert(name);
+
+ if (name->meta.state != NAME_STUB)
+ return 0;
+
+ if ((r = detect_type(name)) < 0)
+ return r;
+
+ if (name->meta.type == NAME_SERVICE) {
+
+ /* Load a .service file */
+ if ((r = fragment_load(name)) == 0)
+ goto finish;
+
+ /* Load a classic init script */
+ if (r == -ENOENT)
+ if ((r = sysv_load(SERVICE(name))) == 0)
+ goto finish;
+
+ } else if (name->meta.type == NAME_MOUNT ||
+ name->meta.type == NAME_AUTOMOUNT) {
+
+ if ((r = fstab_load(name)) == 0)
+ goto finish;
+
+ } else if (name->meta.type == NAME_SNAPSHOT) {
+
+ if ((r = snapshot_load(SNAPSHOT(name))) == 0)
+ goto finish;
+
+ } else {
+ if ((r = fragment_load(name)) == 0)
+ goto finish;
+ }
+
+ name->meta.state = NAME_FAILED;
+ return r;
+
+finish:
+ name->meta.state = NAME_LOADED;
+ return 0;
+}
+
+static int dispatch_load_queue(Manager *m) {
+ Meta *meta;
+
+ assert(m);
+
+ /* Dispatches the load queue. Takes a name from the queue and
+ * tries to load its data until the queue is empty */
+
+ while ((meta = m->load_queue)) {
+ load(NAME(meta));
+ LIST_REMOVE(Meta, m->load_queue, meta);
+ }
+
+ return 0;
+}
+
+
+
+int manager_load_name(Manager *m, const char *name, Name **_ret) {
+ Name *ret;
+ NameType t;
+ int r;
+
+ assert(m);
+ assert(name);
+ assert(_ret);
+/* This will load the service information files, but not actually
+ * start any services or anything */
+
+
+ if ((ret = manager_get_name(m, name)))
+ goto finish;
+
+ if ((t = name_type_from_string(name)) == _NAME_TYPE_INVALID)
+ return -EINVAL;
+
+ if (!(ret = name_new(m)))
+ return -ENOMEM;
+
+ ret->meta.type = t;
+
+ if (!(ret->meta.names = strv_new(name, NULL))) {
+ name_free(ret);
+ return -ENOMEM;
+ }
+
+ if ((r = name_link(ret)) < 0) {
+ name_free(ret);
+ return r;
+ }
+
+ /* At this point the new entry is created and linked. However,
+ * not loaded. Now load this entry and all its dependencies
+ * recursively */
+
+ dispatch_load_queue(m);
+
+finish:
+
+ *_ret = ret;
+ return 0;
+}
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifndef foomanagerhfoo
+#define foomanagerhfoo
+
+#include <stdbool.h>
+#include <inttypes.h>
+
+typedef struct Manager Manager;
+
+#include "name.h"
+#include "job.h"
+#include "hashmap.h"
+#include "list.h"
+#include "set.h"
+
+struct Manager {
+ uint32_t current_job_id;
+
+ /* Active jobs and names */
+ Hashmap *names; /* name string => Name object n:1 */
+ Hashmap *jobs; /* job id => Job object 1:1 */
+
+ /* Names that need to be loaded */
+ LIST_HEAD(Meta, load_queue); /* this is actually more a stack than a queue, but uh. */
+
+ /* Jobs to be added resp. removed. */
+ Hashmap *jobs_to_add; /* Name object => Job object 1:1 */
+ Set *jobs_to_remove;
+};
+
+Manager* manager_new(void);
+void manager_free(Manager *m);
+
+Job *manager_get_job(Manager *m, uint32_t id);
+Name *manager_get_name(Manager *m, const char *name);
+
+int manager_load_name(Manager *m, const char *name, Name **_ret);
+int manager_add_job(Manager *m, JobType job, Name *name, JobMode mode, Job **_ret);
+
+#endif
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#include <assert.h>
+#include <errno.h>
+
+#include "set.h"
+#include "name.h"
+#include "macro.h"
+#include "strv.h"
+
+NameType name_type_from_string(const char *n) {
+ NameType t;
+ static const char* suffixes[_NAME_TYPE_MAX] = {
+ [NAME_SERVICE] = ".service",
+ [NAME_TIMER] = ".timer",
+ [NAME_SOCKET] = ".socket",
+ [NAME_MILESTONE] = ".milestone",
+ [NAME_DEVICE] = ".device",
+ [NAME_MOUNT] = ".mount",
+ [NAME_AUTOMOUNT] = ".automount",
+ [NAME_SNAPSHOT] = ".snapshot",
+ };
+
+ assert(n);
+
+ for (t = 0; t < _NAME_TYPE_MAX; t++)
+ if (endswith(n, suffixes[t]))
+ return t;
+
+ return _NAME_TYPE_INVALID;
+}
+
+Name *name_new(Manager *m) {
+ Name *n;
+
+ assert(m);
+
+ if (!(n = new0(Name, 1)))
+ return NULL;
+
+ /* Not much initialization happening here at this time */
+ n->meta.manager = m;
+ n->meta.type = _NAME_TYPE_INVALID;
+ n->meta.state = NAME_STUB;
+
+ /* We don't link the name here, that is left for name_link() */
+
+ return n;
+}
+
+int name_link(Name *n) {
+ char **t;
+ int r;
+
+ assert(n);
+ assert(!n->meta.linked);
+
+ STRV_FOREACH(t, n->meta.names)
+ if ((r = hashmap_put(n->meta.manager->names, *t, n)) < 0)
+ goto fail;
+
+ if (n->meta.state == NAME_STUB)
+ LIST_PREPEND(Meta, n->meta.manager->load_queue, &n->meta);
+
+ n->meta.linked = true;
+
+ return 0;
+
+fail:
+ t--;
+ STRV_FOREACH_BACKWARDS(t, n->meta.names)
+ hashmap_remove(n->meta.manager->names, *t);
+
+ return r;
+}
+
+void name_free(Name *name) {
+
+ assert(name);
+
+ /* Detach from next 'bigger' objects */
+
+ if (name->meta.linked) {
+ char **t;
+
+ STRV_FOREACH(t, name->meta.names)
+ hashmap_remove(name->meta.manager->names, *t);
+
+ if (name->meta.job)
+ job_free(name->meta.job);
+ }
+
+ /* Free data and next 'smaller' objects */
+
+ if (name->meta.job)
+ job_free(name->meta.job);
+
+ /* FIXME: Other names pointing to us should probably drop their refs to us when we get destructed */
+ set_free(name->meta.requires);
+ set_free(name->meta.soft_requires);
+ set_free(name->meta.wants);
+ set_free(name->meta.requisite);
+ set_free(name->meta.soft_requires);
+ set_free(name->meta.conflicts);
+ set_free(name->meta.before);
+ set_free(name->meta.after);
+
+ switch (name->meta.type) {
+
+ case NAME_SOCKET: {
+ unsigned i;
+ Socket *s = SOCKET(name);
+
+ for (i = 0; i < s->n_fds; i++)
+ nointr_close(s->fds[i]);
+ break;
+ }
+
+ case NAME_DEVICE: {
+ Device *d = DEVICE(name);
+
+ free(d->sysfs);
+ break;
+ }
+
+ case NAME_MOUNT: {
+ Mount *m = MOUNT(name);
+
+ free(m->path);
+ break;
+ }
+
+ case NAME_AUTOMOUNT: {
+ Automount *a = AUTOMOUNT(name);
+
+ free(a->path);
+ break;
+ }
+
+ default:
+ ;
+ }
+
+ free(name->meta.description);
+ strv_free(name->meta.names);
+
+ free(name);
+}
+
+bool name_is_ready(Name *name) {
+
+ assert(name);
+
+ if (name->meta.state != NAME_LOADED)
+ return false;
+
+ assert(name->meta.type < _NAME_TYPE_MAX);
+
+ switch (name->meta.type) {
+ case NAME_SERVICE: {
+ Service *s = SERVICE(name);
+
+ return
+ s->state == SERVICE_RUNNING ||
+ s->state == SERVICE_RELOAD_PRE ||
+ s->state == SERVICE_RELOAD ||
+ s->state == SERVICE_RELOAD_POST;
+ }
+
+ case NAME_TIMER: {
+ Timer *t = TIMER(name);
+
+ return
+ t->state == TIMER_WAITING ||
+ t->state == TIMER_RUNNING;
+ }
+
+ case NAME_SOCKET: {
+ Socket *s = SOCKET(name);
+
+ return
+ s->state == SOCKET_LISTENING ||
+ s->state == SOCKET_RUNNING;
+ }
+
+ case NAME_MILESTONE:
+ return MILESTONE(name)->state == MILESTONE_ACTIVE;
+
+ case NAME_DEVICE:
+ return DEVICE(name)->state == DEVICE_AVAILABLE;
+
+ case NAME_MOUNT:
+ return MOUNT(name)->state == MOUNT_MOUNTED;
+
+ case NAME_AUTOMOUNT: {
+ Automount *a = AUTOMOUNT(name);
+
+ return
+ a->state == AUTOMOUNT_WAITING ||
+ a->state == AUTOMOUNT_RUNNING;
+ }
+
+ case NAME_SNAPSHOT:
+ return SNAPSHOT(name)->state == SNAPSHOT_ACTIVE;
+
+
+ case _NAME_TYPE_MAX:
+ case _NAME_TYPE_INVALID:
+ ;
+ }
+
+ assert_not_reached("Unknown name type.");
+ return false;
+}
+
+static int ensure_in_set(Set **s, void *data) {
+ int r;
+
+ assert(s);
+ assert(data);
+
+ if (!*s)
+ if (!(*s = set_new(trivial_hash_func, trivial_compare_func)))
+ return -ENOMEM;
+
+ if ((r = set_put(*s, data) < 0))
+ if (r != -EEXIST)
+ return r;
+
+ return 0;
+}
+
+int name_augment(Name *n) {
+ int r;
+ void* state;
+ Name *other;
+
+ assert(n);
+
+ /* Adds in the missing links to make all dependencies both-ways */
+
+ SET_FOREACH(other, n->meta.before, state)
+ if ((r = ensure_in_set(&other->meta.after, n) < 0))
+ return r;
+ SET_FOREACH(other, n->meta.after, state)
+ if ((r = ensure_in_set(&other->meta.before, n) < 0))
+ return r;
+
+ SET_FOREACH(other, n->meta.conflicts, state)
+ if ((r = ensure_in_set(&other->meta.conflicts, n) < 0))
+ return r;
+
+ SET_FOREACH(other, n->meta.requires, state)
+ if ((r = ensure_in_set(&other->meta.required_by, n) < 0))
+ return r;
+ SET_FOREACH(other, n->meta.soft_requires, state)
+ if ((r = ensure_in_set(&other->meta.required_by, n) < 0))
+ return r;
+ SET_FOREACH(other, n->meta.requisite, state)
+ if ((r = ensure_in_set(&other->meta.required_by, n) < 0))
+ return r;
+ SET_FOREACH(other, n->meta.soft_requisite, state)
+ if ((r = ensure_in_set(&other->meta.required_by, n) < 0))
+ return r;
+
+ return r;
+}
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifndef foonamehfoo
+#define foonamehfoo
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef union Name Name;
+typedef struct Meta Meta;
+typedef struct Service Service;
+typedef struct Timer Timer;
+typedef struct Socket Socket;
+typedef struct Milestone Milestone;
+typedef struct Device Device;
+typedef struct Mount Mount;
+typedef struct Automount Automount;
+typedef struct Snapshot Snapshot;
+
+#include "job.h"
+#include "manager.h"
+#include "set.h"
+#include "util.h"
+#include "list.h"
+
+typedef enum NameType {
+ NAME_SERVICE = 0,
+ NAME_TIMER,
+ NAME_SOCKET,
+ NAME_MILESTONE,
+ NAME_DEVICE,
+ NAME_MOUNT,
+ NAME_AUTOMOUNT,
+ NAME_SNAPSHOT,
+ _NAME_TYPE_MAX,
+ _NAME_TYPE_INVALID = -1,
+} NameType;
+
+typedef enum NameState {
+ NAME_STUB,
+ NAME_LOADED,
+ NAME_FAILED
+} NameState;
+
+struct Meta {
+ Manager *manager;
+ NameType type;
+ NameState state;
+
+ char **names;
+
+ /* Positive dependencies */
+ Set *requires, *soft_requires, *wants, *requisite, *soft_requisite;
+ Set *required_by; /* inverse of 'requires', 'soft_requires', 'requisite' and 'soft_requisite' is 'required_by' */
+
+ /* Negative dependencies */
+ Set *conflicts; /* inverse of 'conflicts' is 'conflicts' */
+
+ /* Order */
+ Set *before, *after; /* inverse of before is after and vice versa */
+
+ /* Information */
+ char *description;
+
+ /* If there is something to do with this name, then this is
+ * the job for it */
+ Job *job;
+
+ bool linked:1;
+
+ /* Load queue */
+ LIST_FIELDS(Meta);
+};
+
+typedef enum ServiceState {
+ SERVICE_DEAD,
+ SERVICE_BEFORE,
+ SERVICE_START_PRE,
+ SERVICE_START,
+ SERVICE_START_POST,
+ SERVICE_RUNNING,
+ SERVICE_RELOAD_PRE,
+ SERVICE_RELOAD,
+ SERVICE_RELOAD_POST,
+ SERVICE_STOP_PRE,
+ SERVICE_STOP,
+ SERVICE_SIGTERM,
+ SERVICE_SIGKILL,
+ SERVICE_STOP_POST,
+ SERVICE_HOLDOFF,
+ SERVICE_MAINTAINANCE
+} ServiceState;
+
+typedef enum ServiceMode {
+ SERVICE_ONCE,
+ SERVICE_RESTART
+} ServiceMode;
+
+struct Service {
+ Meta meta;
+
+ ServiceState state;
+ ServiceMode mode;
+};
+
+typedef enum TimerState {
+ TIMER_DEAD,
+ TIMER_BEFORE,
+ TIMER_START_PRE,
+ TIMER_START,
+ TIMER_START_POST,
+ TIMER_WAITING,
+ TIMER_RUNNING,
+ TIMER_STOP_PRE,
+ TIMER_STOP,
+ TIMER_STOP_POST,
+ TIMER_MAINTAINANCE
+} TimerState;
+
+struct Timer {
+ Meta meta;
+
+ TimerState state;
+ Service *subject;
+
+ clockid_t clock_id;
+ usec_t next_elapse;
+};
+
+typedef enum SocketState {
+ SOCKET_DEAD,
+ SOCKET_BEFORE,
+ SOCKET_START_PRE,
+ SOCKET_START,
+ SOCKET_START_POST,
+ SOCKET_LISTENING,
+ SOCKET_RUNNING,
+ SOCKET_STOP_PRE,
+ SOCKET_STOP,
+ SOCKET_STOP_POST,
+ SOCKET_MAINTAINANCE
+} SocketState;
+
+struct Socket {
+ Meta meta;
+
+ SocketState state;
+ int *fds;
+ unsigned n_fds;
+
+ Service *subject;
+};
+
+typedef enum MilestoneState {
+ MILESTONE_DEAD,
+ MILESTONE_BEFORE,
+ MILESTONE_ACTIVE
+} MilestoneState;
+
+struct Milestone {
+ Meta meta;
+
+ MilestoneState state;
+};
+
+typedef enum DeviceState {
+ DEVICE_DEAD,
+ DEVICE_BEFORE,
+ DEVICE_AVAILABLE
+} DeviceState;
+
+struct Device {
+ Meta meta;
+
+ DeviceState state;
+ char *sysfs;
+};
+
+typedef enum MountState {
+ MOUNT_DEAD,
+ MOUNT_BEFORE,
+ MOUNT_MOUNTED
+} MountState;
+
+struct Mount {
+ Meta meta;
+
+ MountState state;
+ char *path;
+};
+
+typedef enum AutomountState {
+ AUTOMOUNT_DEAD,
+ AUTOMOUNT_BEFORE,
+ AUTOMOUNT_START_PRE,
+ AUTOMOUNT_START,
+ AUTOMOUNT_START_POST,
+ AUTOMOUNT_WAITING,
+ AUTOMOUNT_RUNNING,
+ AUTOMOUNT_STOP_PRE,
+ AUTOMOUNT_STOP,
+ AUTOMOUNT_STOP_POST,
+ AUTOMOUNT_MAINTAINANCE
+} AutomountState;
+
+struct Automount {
+ Meta meta;
+
+ AutomountState state;
+ char *path;
+ Mount *subject;
+};
+
+typedef enum SnapshotState {
+ SNAPSHOT_DEAD,
+ SNAPSHOT_BEFORE,
+ SNAPSHOT_ACTIVE
+} SnapshotState;
+
+struct Snapshot {
+ Meta meta;
+
+ SnapshotState state;
+ bool cleanup:1;
+};
+
+union Name {
+ Meta meta;
+ Service service;
+ Timer timer;
+ Socket socket;
+ Milestone milestone;
+ Device device;
+ Mount mount;
+ Automount automount;
+ Snapshot snapshot;
+};
+
+/* For casting a name into the various name types */
+
+#define DEFINE_CAST(UPPERCASE, MixedCase, lowercase) \
+ static inline MixedCase* UPPERCASE(Name *name) { \
+ if (name->meta.type != NAME_##UPPERCASE) \
+ return NULL; \
+ \
+ return &name->lowercase; \
+ }
+
+DEFINE_CAST(SERVICE, Service, service);
+DEFINE_CAST(TIMER, Timer, timer);
+DEFINE_CAST(SOCKET, Socket, socket);
+DEFINE_CAST(MILESTONE, Milestone, milestone);
+DEFINE_CAST(DEVICE, Device, device);
+DEFINE_CAST(MOUNT, Mount, mount);
+DEFINE_CAST(AUTOMOUNT, Automount, automount);
+DEFINE_CAST(SNAPSHOT, Snapshot, snapshot);
+
+/* For casting the various name types into a name */
+#define NAME(o) ((Name*) (o))
+
+bool name_is_ready(Name *name);
+NameType name_type_from_string(const char *n);
+
+Name *name_new(Manager *m);
+void name_free(Name *name);
+int name_link(Name *name);
+
+int name_augment(Name *n);
+
+#endif
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+
+#include "set.h"
+#include "hashmap.h"
+
+#define MAKE_SET(h) ((Set*) (h))
+#define MAKE_HASHMAP(s) ((Hashmap*) (s))
+
+/* For now this is not much more than a wrapper around a hashmap */
+
+Set *set_new(hash_func_t hash_func, compare_func_t compare_func) {
+ return MAKE_SET(hashmap_new(hash_func, compare_func));
+}
+
+void set_free(Set* s) {
+ hashmap_free(MAKE_HASHMAP(s));
+}
+
+int set_put(Set *s, void *value) {
+ return hashmap_put(MAKE_HASHMAP(s), value, value);
+}
+
+void *set_get(Set *s, void *value) {
+ return hashmap_get(MAKE_HASHMAP(s), value);
+}
+
+void *set_remove(Set *s, void *value) {
+ return hashmap_remove(MAKE_HASHMAP(s), value);
+}
+
+unsigned set_size(Set *s) {
+ return hashmap_size(MAKE_HASHMAP(s));
+}
+
+bool set_isempty(Set *s) {
+ return hashmap_isempty(MAKE_HASHMAP(s));
+}
+
+void *set_iterate(Set *s, void **state) {
+ return hashmap_iterate(MAKE_HASHMAP(s), state, NULL);
+}
+
+void *set_iterate_backwards(Set *s, void **state) {
+ return hashmap_iterate_backwards(MAKE_HASHMAP(s), state, NULL);
+}
+
+void *set_steal_first(Set *s) {
+ return hashmap_steal_first(MAKE_HASHMAP(s));
+}
+
+void* set_first(Set *s) {
+ return hashmap_first(MAKE_HASHMAP(s));
+}
+
+void* set_last(Set *s) {
+ return hashmap_last(MAKE_HASHMAP(s));
+}
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifndef foosethfoo
+#define foosethfoo
+
+/* Pretty straightforward set implementation. Internally based on the
+ * hashmap. That means that as a minor optimization a NULL set
+ * object will be treated as empty set for all read
+ * operations. That way it is not necessary to instantiate an object
+ * for each set use. */
+
+#include "hashmap.h"
+
+typedef struct Set Set;
+
+Set *set_new(hash_func_t hash_func, compare_func_t compare_func);
+void set_free(Set* set);
+
+int set_put(Set *s, void *value);
+void *set_get(Set *s, void *value);
+void *set_remove(Set *s, void *value);
+
+unsigned set_size(Set *s);
+bool set_isempty(Set *s);
+
+void *set_iterate(Set *h, void **state);
+void *set_iterate_backwards(Set *h, void **state);
+
+void *set_steal_first(Set *h);
+void* set_first(Set *h);
+void* set_last(Set *h);
+
+#define SET_FOREACH(e, s, state) \
+ for ((state) = NULL, (e) = set_iterate((s), &(state)); (e); (e) = set_iterate((s), &(state)))
+
+#define SET_FOREACH_BACKWARDS(e, s, state) \
+ for ((state) = NULL, (e) = set_iterate_backwards((s), &(state)); (e); (e) = set_iterate_backwards((s), &(state)))
+
+#endif
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include "util.h"
+#include "strv.h"
+
+char *strv_find(char **l, const char *name) {
+ assert(l);
+ assert(name);
+
+ for (; *l; l++)
+ if (streq(*l, name))
+ return *l;
+
+ return NULL;
+}
+
+void strv_free(char **l) {
+ char **k;
+
+ if (!l)
+ return;
+
+ for (k = l; *k; k++)
+ free(*k);
+
+ free(l);
+}
+
+char **strv_copy(char **l) {
+ char **r, **k;
+
+ if (!(r = new(char*, strv_length(l)+1)))
+ return NULL;
+
+ for (k = r; *l; k++, l++)
+ if (!(*k = strdup(*l)))
+ goto fail;
+
+ *k = NULL;
+ return r;
+
+fail:
+ for (k--, l--; k >= r; k--, l--)
+ free(*k);
+
+ return NULL;
+}
+
+unsigned strv_length(char **l) {
+ unsigned n = 0;
+
+ if (!l)
+ return 0;
+
+ for (; *l; l++)
+ n++;
+
+ return n;
+}
+
+char **strv_new(const char *x, ...) {
+ const char *s;
+ char **a;
+ unsigned n = 0, i = 0;
+ va_list ap;
+
+ if (x) {
+ n = 1;
+
+ va_start(ap, x);
+
+ while (va_arg(ap, const char*))
+ n++;
+
+ va_end(ap);
+ }
+
+ if (!(a = new(char*, n+1)))
+ return NULL;
+
+ if (x) {
+ if (!(a[i] = strdup(x))) {
+ free(a);
+ return NULL;
+ }
+
+ i++;
+
+ va_start(ap, x);
+
+ while ((s = va_arg(ap, const char*))) {
+ if (!(a[i] = strdup(s)))
+ goto fail;
+
+ i++;
+ }
+
+ va_end(ap);
+ }
+
+ a[i] = NULL;
+ return a;
+
+fail:
+
+ for (; i > 0; i--)
+ if (a[i-1])
+ free(a[i-1]);
+
+ free(a);
+ return NULL;
+}
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifndef foostrvhfoo
+#define foostrvhfoo
+
+#include "macro.h"
+
+char *strv_find(char **l, const char *name);
+void strv_free(char **l);
+char **strv_copy(char **l);
+unsigned strv_length(char **l);
+
+char **strv_new(const char *x, ...) __sentinel;
+
+#define STRV_FOREACH(s, l) \
+ for ((s) = (l); (l) && *(s); (s)++)
+
+#define STRV_FOREACH_BACKWARDS(s, l) \
+ for (; (l) && ((s) >= (l)); (s)--)
+
+#endif
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#include <assert.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "macro.h"
+#include "util.h"
+
+usec_t now(clockid_t clock) {
+ struct timespec ts;
+
+ assert_se(clock_gettime(clock, &ts) == 0);
+
+ return timespec_load(&ts);
+}
+
+usec_t timespec_load(const struct timespec *ts) {
+ assert(ts);
+
+ return
+ (usec_t) ts->tv_sec * USEC_PER_SEC +
+ (usec_t) ts->tv_nsec / NSEC_PER_USEC;
+}
+
+struct timespec *timespec_store(struct timespec *ts, usec_t u) {
+ assert(ts);
+
+ ts->tv_sec = (time_t) (u / USEC_PER_SEC);
+ ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
+
+ return ts;
+}
+
+usec_t timeval_load(const struct timeval *tv) {
+ assert(tv);
+
+ return
+ (usec_t) tv->tv_sec * USEC_PER_SEC +
+ (usec_t) tv->tv_usec;
+}
+
+struct timeval *timeval_store(struct timeval *tv, usec_t u) {
+ assert(tv);
+
+ tv->tv_sec = (time_t) (u / USEC_PER_SEC);
+ tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
+
+ return tv;
+}
+
+bool endswith(const char *s, const char *postfix) {
+ size_t sl, pl;
+
+ assert(s);
+ assert(postfix);
+
+ sl = strlen(s);
+ pl = strlen(postfix);
+
+ if (sl < pl)
+ return false;
+
+ return memcmp(s + sl - pl, postfix, pl) == 0;
+}
+
+bool startswith(const char *s, const char *prefix) {
+ size_t sl, pl;
+
+ assert(s);
+ assert(prefix);
+
+ sl = strlen(s);
+ pl = strlen(prefix);
+
+ if (sl < pl)
+ return false;
+
+ return memcmp(s, prefix, pl) == 0;
+}
+
+int nointr_close(int fd) {
+ assert(fd >= 0);
+
+ for (;;) {
+ int r;
+
+ if ((r = close(fd)) >= 0)
+ return r;
+
+ if (errno != EINTR)
+ return r;
+ }
+}
--- /dev/null
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+#ifndef fooutilhfoo
+#define fooutilhfoo
+
+#include <inttypes.h>
+#include <time.h>
+#include <sys/time.h>
+#include <stdbool.h>
+
+typedef uint64_t usec_t;
+
+#define USEC_PER_SEC 1000000ULL
+#define NSEC_PER_USEC 1000ULL
+
+usec_t now(clockid_t clock);
+
+usec_t timespec_load(const struct timespec *ts);
+struct timespec *timespec_store(struct timespec *ts, usec_t u);
+
+usec_t timeval_load(const struct timeval *tv);
+struct timeval *timeval_store(struct timeval *tv, usec_t u);
+
+#define streq(a,b) (strcmp((a),(b)) == 0)
+
+#define new(t, n) ((t*) malloc(sizeof(t)*(n)))
+
+#define new0(t, n) ((t*) calloc((n), sizeof(t)))
+
+#define malloc0(n) (calloc((n), 1))
+
+static inline const char* yes_no(bool b) {
+ return b ? "yes" : "no";
+}
+
+static inline const char* strempty(const char *s) {
+ return s ? s : "";
+}
+
+static inline const char* strnull(const char *s) {
+ return s ? s : "(null)";
+}
+
+bool endswith(const char *s, const char *postfix);
+bool startswith(const char *s, const char *prefix);
+
+int nointr_close(int fd);
+
+#endif
projects / systemd / commitdiff