systemctl: require correctly formed unit names when enabling units

[elogind.git] / src / unit.c

diff --git a/src/unit.c b/src/unit.c
index bca4d97993c9acae1411e6aed0530aaa5c1d53b2..71ef2a706da447494a909ddaea074c10b2241e80 100644 (file)
--- a/src/unit.c
+++ b/src/unit.c
@@ -440,6 +440,7 @@ static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
         assert(other);
         assert(d < _UNIT_DEPENDENCY_MAX);
 
+        /* Fix backwards pointers */
         SET_FOREACH(back, other->meta.dependencies[d], i) {
                 UnitDependency k;
 
@@ -577,7 +578,7 @@ const char *unit_description(Unit *u) {
         if (u->meta.description)
                 return u->meta.description;
 
-        return u->meta.id;
+        return strna(u->meta.id);
 }
 
 void unit_dump(Unit *u, FILE *f, const char *prefix) {
@@ -725,6 +726,48 @@ int unit_load_fragment_and_dropin_optional(Unit *u) {
         return 0;
 }
 
+int unit_add_default_target_dependency(Unit *u, Unit *target) {
+        assert(u);
+        assert(target);
+
+        if (target->meta.type != UNIT_TARGET)
+                return 0;
+
+        /* Only add the dependency if boths units are loaded, so that
+         * that loop check below is reliable */
+        if (u->meta.load_state != UNIT_LOADED ||
+            target->meta.load_state != UNIT_LOADED)
+                return 0;
+
+        /* Don't create loops */
+        if (set_get(target->meta.dependencies[UNIT_BEFORE], u))
+                return 0;
+
+        return unit_add_dependency(target, UNIT_AFTER, u, true);
+}
+
+static int unit_add_default_dependencies(Unit *u) {
+        Unit *target;
+        Iterator i;
+        int r;
+
+        assert(u);
+
+        SET_FOREACH(target, u->meta.dependencies[UNIT_REQUIRED_BY], i)
+                if ((r = unit_add_default_target_dependency(u, target)) < 0)
+                        return r;
+
+        SET_FOREACH(target, u->meta.dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
+                if ((r = unit_add_default_target_dependency(u, target)) < 0)
+                        return r;
+
+        SET_FOREACH(target, u->meta.dependencies[UNIT_WANTED_BY], i)
+                if ((r = unit_add_default_target_dependency(u, target)) < 0)
+                        return r;
+
+        return 0;
+}
+
 int unit_load(Unit *u) {
         int r;
 
@@ -750,6 +793,11 @@ int unit_load(Unit *u) {
                 goto fail;
         }
 
+        if (u->meta.load_state == UNIT_LOADED &&
+            u->meta.default_dependencies)
+                if ((r = unit_add_default_dependencies(u)) < 0)
+                        goto fail;
+
         assert((u->meta.load_state != UNIT_MERGED) == !u->meta.merged_into);
 
         unit_add_to_dbus_queue(unit_follow_merge(u));
@@ -882,7 +930,7 @@ bool unit_can_reload(Unit *u) {
         return UNIT_VTABLE(u)->can_reload(u);
 }
 
-static void unit_check_uneeded(Unit *u) {
+static void unit_check_unneeded(Unit *u) {
         Iterator i;
         Unit *other;
 
@@ -964,19 +1012,19 @@ static void retroactively_stop_dependencies(Unit *u) {
         /* Garbage collect services that might not be needed anymore, if enabled */
         SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRES], i)
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
-                        unit_check_uneeded(other);
+                        unit_check_unneeded(other);
         SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
-                        unit_check_uneeded(other);
+                        unit_check_unneeded(other);
         SET_FOREACH(other, u->meta.dependencies[UNIT_WANTS], i)
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
-                        unit_check_uneeded(other);
+                        unit_check_unneeded(other);
         SET_FOREACH(other, u->meta.dependencies[UNIT_REQUISITE], i)
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
-                        unit_check_uneeded(other);
+                        unit_check_unneeded(other);
         SET_FOREACH(other, u->meta.dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
-                        unit_check_uneeded(other);
+                        unit_check_unneeded(other);
 }
 
 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
@@ -1084,7 +1132,7 @@ void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
          * something is already activated. */
 
         if (unexpected && u->meta.manager->n_deserializing <= 0) {
-                if (UNIT_IS_INACTIVE_OR_DEACTIVATING(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
+                if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
                         retroactively_start_dependencies(u);
                 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
                         retroactively_stop_dependencies(u);
@@ -1154,7 +1202,7 @@ void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
 
         /* Maybe we finished startup and are now ready for being
          * stopped because unneeded? */
-        unit_check_uneeded(u);
+        unit_check_unneeded(u);
 
         unit_add_to_dbus_queue(u);
         unit_add_to_gc_queue(u);
@@ -1355,6 +1403,9 @@ int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_referen
         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
         assert(other);
 
+        u = unit_follow_merge(u);
+        other = unit_follow_merge(other);
+
         /* We won't allow dependencies on ourselves. We will not
          * consider them an error however. */
         if (u == other)
@@ -2125,6 +2176,59 @@ Unit *unit_following(Unit *u) {
         return NULL;
 }
 
+bool unit_pending_inactive(Unit *u) {
+        assert(u);
+
+        /* Returns true if the unit is inactive or going down */
+
+        if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
+                return true;
+
+        if (u->meta.job && u->meta.job->type == JOB_STOP)
+                return true;
+
+        return false;
+}
+
+bool unit_pending_active(Unit *u) {
+        assert(u);
+
+        /* Returns true if the unit is inactive or going down */
+
+        if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
+                return true;
+
+        if (u->meta.job &&
+            (u->meta.job->type == JOB_START ||
+             u->meta.job->type == JOB_RELOAD_OR_START ||
+             u->meta.job->type == JOB_RESTART))
+                return true;
+
+        return false;
+}
+
+UnitType unit_name_to_type(const char *n) {
+        UnitType t;
+
+        assert(n);
+
+        for (t = 0; t < _UNIT_TYPE_MAX; t++)
+                if (endswith(n, unit_vtable[t]->suffix))
+                        return t;
+
+        return _UNIT_TYPE_INVALID;
+}
+
+bool unit_name_is_valid(const char *n) {
+        UnitType t;
+
+        t = unit_name_to_type(n);
+        if (t < 0 || t >= _UNIT_TYPE_MAX)
+                return false;
+
+        return unit_name_is_valid_no_type(n);
+}
+
 static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
         [UNIT_STUB] = "stub",
         [UNIT_LOADED] = "loaded",