X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fshared%2Funit-name.c;h=2924c473df4674a28691ed018689ccc8400532be;hp=1440d2f2eac59ca4271c476c13e9d56cb8f5144c;hb=bdd13f6be4b588568683a1ab54f421fc6a636dbb;hpb=4b7126538c25268c79ff10d166920934f149a329

diff --git a/src/shared/unit-name.c b/src/shared/unit-name.c
index 1440d2f2e..2924c473d 100644
--- a/src/shared/unit-name.c
+++ b/src/shared/unit-name.c
@@ -24,16 +24,45 @@
 #include <assert.h>
 
 #include "path-util.h"
+#include "bus-label.h"
 #include "util.h"
 #include "unit-name.h"
+#include "def.h"
 
 #define VALID_CHARS                             \
-        "0123456789"                            \
-        "abcdefghijklmnopqrstuvwxyz"            \
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"            \
+        DIGITS LETTERS                          \
         ":-_.\\"
 
-bool unit_name_is_valid_no_type(const char *n, bool template_ok) {
+static const char* const unit_type_table[_UNIT_TYPE_MAX] = {
+        [UNIT_SERVICE] = "service",
+        [UNIT_SOCKET] = "socket",
+        [UNIT_BUSNAME] = "busname",
+        [UNIT_TARGET] = "target",
+        [UNIT_SNAPSHOT] = "snapshot",
+        [UNIT_DEVICE] = "device",
+        [UNIT_MOUNT] = "mount",
+        [UNIT_AUTOMOUNT] = "automount",
+        [UNIT_SWAP] = "swap",
+        [UNIT_TIMER] = "timer",
+        [UNIT_PATH] = "path",
+        [UNIT_SLICE] = "slice",
+        [UNIT_SCOPE] = "scope"
+};
+
+DEFINE_STRING_TABLE_LOOKUP(unit_type, UnitType);
+
+static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
+        [UNIT_STUB] = "stub",
+        [UNIT_LOADED] = "loaded",
+        [UNIT_NOT_FOUND] = "not-found",
+        [UNIT_ERROR] = "error",
+        [UNIT_MERGED] = "merged",
+        [UNIT_MASKED] = "masked"
+};
+
+DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
+
+bool unit_name_is_valid(const char *n, enum template_valid template_ok) {
         const char *e, *i, *at;
 
         /* Valid formats:
@@ -43,6 +72,7 @@ bool unit_name_is_valid_no_type(const char *n, bool template_ok) {
          */
 
         assert(n);
+        assert(IN_SET(template_ok, TEMPLATE_VALID, TEMPLATE_INVALID));
 
         if (strlen(n) >= UNIT_NAME_MAX)
                 return false;
@@ -51,6 +81,9 @@ bool unit_name_is_valid_no_type(const char *n, bool template_ok) {
         if (!e || e == n)
                 return false;
 
+        if (unit_type_from_string(e + 1) < 0)
+                return false;
+
         for (i = n, at = NULL; i < e; i++) {
 
                 if (*i == '@' && !at)
@@ -64,7 +97,7 @@ bool unit_name_is_valid_no_type(const char *n, bool template_ok) {
                 if (at == n)
                         return false;
 
-                if (!template_ok && at+1 == e)
+                if (!template_ok == TEMPLATE_VALID && at+1 == e)
                         return false;
         }
 
@@ -112,7 +145,8 @@ int unit_name_to_instance(const char *n, char **instance) {
         assert(instance);
 
         /* Everything past the first @ and before the last . is the instance */
-        if (!(p = strchr(n, '@'))) {
+        p = strchr(n, '@');
+        if (!p) {
                 *instance = NULL;
                 return 0;
         }
@@ -120,7 +154,8 @@ int unit_name_to_instance(const char *n, char **instance) {
         assert_se(d = strrchr(n, '.'));
         assert(p < d);
 
-        if (!(i = strndup(p+1, d-p-1)))
+        i = strndup(p+1, d-p-1);
+        if (!i)
                 return -ENOMEM;
 
         *instance = i;
@@ -140,7 +175,8 @@ char *unit_name_to_prefix_and_instance(const char *n) {
 char *unit_name_to_prefix(const char *n) {
         const char *p;
 
-        if ((p = strchr(n, '@')))
+        p = strchr(n, '@');
+        if (p)
                 return strndup(n, p - n);
 
         return unit_name_to_prefix_and_instance(n);
@@ -151,14 +187,16 @@ char *unit_name_change_suffix(const char *n, const char *suffix) {
         size_t a, b;
 
         assert(n);
-        assert(unit_name_is_valid_no_type(n, true));
+        assert(unit_name_is_valid(n, TEMPLATE_VALID));
         assert(suffix);
+        assert(suffix[0] == '.');
 
         assert_se(e = strrchr(n, '.'));
         a = e - n;
         b = strlen(suffix);
 
-        if (!(r = new(char, a + b + 1)))
+        r = new(char, a + b + 1);
+        if (!r)
                 return NULL;
 
         memcpy(r, n, a);
@@ -176,7 +214,7 @@ char *unit_name_build(const char *prefix, const char *instance, const char *suff
         if (!instance)
                 return strappend(prefix, suffix);
 
-        return join(prefix, "@", instance, suffix, NULL);
+        return strjoin(prefix, "@", instance, suffix, NULL);
 }
 
 static char *do_escape_char(char c, char *t) {
@@ -209,60 +247,17 @@ static char *do_escape(const char *f, char *t) {
         return t;
 }
 
-char *unit_name_build_escape(const char *prefix, const char *instance, const char *suffix) {
-        char *r, *t;
-        size_t a, b, c;
-
-        assert(prefix);
-        assert(suffix);
-
-        /* Takes a arbitrary string for prefix and instance plus a
-         * suffix and makes a nice string suitable as unit name of it,
-         * escaping all weird chars on the way.
-         *
-         * / becomes -, and all chars not allowed in a unit name get
-         * escaped as \xFF, including \ and -, of course. This
-         * escaping is hence reversible.
-         *
-         * This is primarily useful to make nice unit names from
-         * strings, but is actually useful for any kind of string.
-         */
-
-        a = strlen(prefix);
-        c = strlen(suffix);
-
-        if (instance) {
-                b = strlen(instance);
-
-                if (!(r = new(char, a*4 + 1 + b*4 + c + 1)))
-                        return NULL;
-
-                t = do_escape(prefix, r);
-                *(t++) = '@';
-                t = do_escape(instance, t);
-        } else {
-
-                if (!(r = new(char, a*4 + c + 1)))
-                        return NULL;
-
-                t = do_escape(prefix, r);
-        }
-
-        strcpy(t, suffix);
-        return r;
-}
-
 char *unit_name_escape(const char *f) {
         char *r, *t;
 
-        if (!(r = new(char, strlen(f)*4+1)))
+        r = new(char, strlen(f)*4+1);
+        if (!r)
                 return NULL;
 
         t = do_escape(f, r);
         *t = 0;
 
         return r;
-
 }
 
 char *unit_name_unescape(const char *f) {
@@ -270,7 +265,8 @@ char *unit_name_unescape(const char *f) {
 
         assert(f);
 
-        if (!(r = strdup(f)))
+        r = strdup(f);
+        if (!r)
                 return NULL;
 
         for (t = r; *f; f++) {
@@ -297,48 +293,99 @@ char *unit_name_unescape(const char *f) {
         return r;
 }
 
+char *unit_name_path_escape(const char *f) {
+        char *p, *e;
+
+        assert(f);
+
+        p = strdup(f);
+        if (!p)
+                return NULL;
+
+        path_kill_slashes(p);
+
+        if (streq(p, "/") || streq(p, "")) {
+                free(p);
+                return strdup("-");
+        }
+
+        e = unit_name_escape(p[0] == '/' ? p + 1 : p);
+        free(p);
+
+        return e;
+}
+
+char *unit_name_path_unescape(const char *f) {
+        char *e;
+
+        assert(f);
+
+        e = unit_name_unescape(f);
+        if (!e)
+                return NULL;
+
+        if (e[0] != '/') {
+                char *w;
+
+                w = strappend("/", e);
+                free(e);
+
+                return w;
+        }
+
+        return e;
+}
+
 bool unit_name_is_template(const char *n) {
         const char *p;
 
         assert(n);
 
-        if (!(p = strchr(n, '@')))
+        p = strchr(n, '@');
+        if (!p)
                 return false;
 
         return p[1] == '.';
 }
 
+bool unit_name_is_instance(const char *n) {
+        const char *p;
+
+        assert(n);
+
+        p = strchr(n, '@');
+        if (!p)
+                return false;
+
+        return p[1] != '.';
+}
+
 char *unit_name_replace_instance(const char *f, const char *i) {
         const char *p, *e;
         char *r, *k;
-        size_t a;
+        size_t a, b;
 
         assert(f);
 
         p = strchr(f, '@');
-        assert_se(e = strrchr(f, '.'));
-
-        a = p - f;
-
-        if (p) {
-                size_t b;
-
-                b = strlen(i);
-
-                if (!(r = new(char, a + 1 + b + strlen(e) + 1)))
-                        return NULL;
+        if (!p)
+                return strdup(f);
 
-                k = mempcpy(r, f, a + 1);
-                k = mempcpy(k, i, b);
-        } else {
+        e = strrchr(f, '.');
+        if (!e)
+                assert_se(e = strchr(f, 0));
 
-                if (!(r = new(char, a + strlen(e) + 1)))
-                        return NULL;
+        a = p - f;
+        b = strlen(i);
 
-                k = mempcpy(r, f, a);
-        }
+        r = new(char, a + 1 + b + strlen(e) + 1);
+        if (!r)
+                return NULL;
 
+        k = mempcpy(r, f, a + 1);
+        k = mempcpy(k, i, b);
         strcpy(k, e);
+
         return r;
 }
 
@@ -347,18 +394,19 @@ char *unit_name_template(const char *f) {
         char *r;
         size_t a;
 
-        if (!(p = strchr(f, '@')))
+        p = strchr(f, '@');
+        if (!p)
                 return strdup(f);
 
         assert_se(e = strrchr(f, '.'));
         a = p - f + 1;
 
-        if (!(r = new(char, a + strlen(e) + 1)))
+        r = new(char, a + strlen(e) + 1);
+        if (!r)
                 return NULL;
 
         strcpy(mempcpy(r, f, a), e);
         return r;
-
 }
 
 char *unit_name_from_path(const char *path, const char *suffix) {
@@ -367,19 +415,11 @@ char *unit_name_from_path(const char *path, const char *suffix) {
         assert(path);
         assert(suffix);
 
-        if (!(p = strdup(path)))
+        p = unit_name_path_escape(path);
+        if (!p)
                 return NULL;
 
-        path_kill_slashes(p);
-
-        path = p[0] == '/' ? p + 1 : p;
-
-        if (path[0] == 0) {
-                free(p);
-                return strappend("-", suffix);
-        }
-
-        r = unit_name_build_escape(path, NULL, suffix);
+        r = strappend(p, suffix);
         free(p);
 
         return r;
@@ -388,73 +428,172 @@ char *unit_name_from_path(const char *path, const char *suffix) {
 char *unit_name_from_path_instance(const char *prefix, const char *path, const char *suffix) {
         char *p, *r;
 
+        assert(prefix);
         assert(path);
         assert(suffix);
 
-        if (!(p = strdup(path)))
+        p = unit_name_path_escape(path);
+        if (!p)
                 return NULL;
 
-        path_kill_slashes(p);
-
-        path = p[0] == '/' ? p + 1 : p;
-
-        if (path[0] == 0) {
-                free(p);
-                return unit_name_build_escape(prefix, "-", suffix);
-        }
-
-        r = unit_name_build_escape(prefix, path, suffix);
+        r = strjoin(prefix, "@", p, suffix, NULL);
         free(p);
 
         return r;
 }
 
 char *unit_name_to_path(const char *name) {
-        char *w, *e;
+        _cleanup_free_ char *w = NULL;
 
         assert(name);
 
-        if (!(w = unit_name_to_prefix(name)))
+        w = unit_name_to_prefix(name);
+        if (!w)
                 return NULL;
 
-        e = unit_name_unescape(w);
-        free(w);
+        return unit_name_path_unescape(w);
+}
+
+char *unit_dbus_path_from_name(const char *name) {
+        _cleanup_free_ char *e = NULL;
+
+        assert(name);
 
+        e = bus_label_escape(name);
         if (!e)
                 return NULL;
 
-        if (e[0] != '/') {
-                w = strappend("/", e);
-                free(e);
+        return strappend("/org/freedesktop/systemd1/unit/", e);
+}
 
-                if (!w)
-                        return NULL;
+int unit_name_from_dbus_path(const char *path, char **name) {
+        const char *e;
+        char *n;
 
-                e = w;
+        e = startswith(path, "/org/freedesktop/systemd1/unit/");
+        if (!e)
+                return -EINVAL;
+
+        n = bus_label_unescape(e);
+        if (!n)
+                return -ENOMEM;
+
+        *name = n;
+        return 0;
+}
+
+
+/**
+ *  Try to turn a string that might not be a unit name into a
+ *  sensible unit name.
+ */
+char *unit_name_mangle(const char *name, enum unit_name_mangle allow_globs) {
+        char *r, *t;
+        const char *f;
+        const char* valid_chars = allow_globs == MANGLE_GLOB ? "@" VALID_CHARS "[]!-*?" : "@" VALID_CHARS;
+
+        assert(name);
+        assert(IN_SET(allow_globs, MANGLE_GLOB, MANGLE_NOGLOB));
+
+        if (is_device_path(name))
+                return unit_name_from_path(name, ".device");
+
+        if (path_is_absolute(name))
+                return unit_name_from_path(name, ".mount");
+
+        /* We'll only escape the obvious characters here, to play
+         * safe. */
+
+        r = new(char, strlen(name) * 4 + 1 + sizeof(".service")-1);
+        if (!r)
+                return NULL;
+
+        for (f = name, t = r; *f; f++) {
+                if (*f == '/')
+                        *(t++) = '-';
+                else if (!strchr(valid_chars, *f))
+                        t = do_escape_char(*f, t);
+                else
+                        *(t++) = *f;
         }
 
-        return e;
+        if (unit_name_to_type(name) < 0)
+                strcpy(t, ".service");
+        else
+                *t = 0;
+
+        return r;
 }
 
-char *unit_name_path_unescape(const char *f) {
-        char *e;
 
-        assert(f);
+/**
+ *  Similar to unit_name_mangle(), but is called when we know
+ *  that this is about a specific unit type.
+ */
+char *unit_name_mangle_with_suffix(const char *name, enum unit_name_mangle allow_globs, const char *suffix) {
+        char *r, *t;
+        const char *f;
+
+        assert(name);
+        assert(suffix);
+        assert(suffix[0] == '.');
 
-        if (!(e = unit_name_unescape(f)))
+        r = new(char, strlen(name) * 4 + strlen(suffix) + 1);
+        if (!r)
                 return NULL;
 
-        if (e[0] != '/') {
-                char *w;
+        for (f = name, t = r; *f; f++) {
+                if (*f == '/')
+                        *(t++) = '-';
+                else if (!strchr(VALID_CHARS, *f))
+                        t = do_escape_char(*f, t);
+                else
+                        *(t++) = *f;
+        }
 
-                w = strappend("/", e);
-                free(e);
+        if (!endswith(name, suffix))
+                strcpy(t, suffix);
+        else
+                *t = 0;
+
+        return r;
+}
+
+UnitType unit_name_to_type(const char *n) {
+        const char *e;
+
+        assert(n);
+
+        e = strrchr(n, '.');
+        if (!e)
+                return _UNIT_TYPE_INVALID;
+
+        return unit_type_from_string(e + 1);
+}
+
+int build_subslice(const char *slice, const char*name, char **subslice) {
+        char *ret;
+
+        assert(slice);
+        assert(name);
+        assert(subslice);
+
+        if (streq(slice, "-.slice"))
+                ret = strappend(name, ".slice");
+        else {
+                char *e;
+
+                e = endswith(slice, ".slice");
+                if (!e)
+                        return -EINVAL;
 
-                if (!w)
-                        return NULL;
+                ret = new(char, (e - slice) + 1 + strlen(name) + 6 + 1);
+                if (!ret)
+                        return -ENOMEM;
 
-                e = w;
+                stpcpy(stpcpy(stpcpy(mempcpy(ret, slice, e - slice), "-"), name), ".slice");
         }
 
-        return e;
+        *subslice = ret;
+        return 0;
 }