#include <string.h>
#include <assert.h>
+#include "path-util.h"
#include "util.h"
#include "unit-name.h"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
":-_.\\"
-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_TARGET] = "target",
+ [UNIT_DEVICE] = "device",
+ [UNIT_MOUNT] = "mount",
+ [UNIT_AUTOMOUNT] = "automount",
+ [UNIT_SNAPSHOT] = "snapshot",
+ [UNIT_TIMER] = "timer",
+ [UNIT_SWAP] = "swap",
+ [UNIT_PATH] = "path",
+};
+
+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_ERROR] = "error",
+ [UNIT_MERGED] = "merged",
+ [UNIT_MASKED] = "masked"
+};
+
+DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
+
+bool unit_name_is_valid(const char *n, bool template_ok) {
const char *e, *i, *at;
/* Valid formats:
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)
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;
}
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;
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);
size_t a, b;
assert(n);
- assert(unit_name_is_valid_no_type(n, true));
+ assert(unit_name_is_valid(n, true));
assert(suffix);
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);
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) {
+ *(t++) = '\\';
+ *(t++) = 'x';
+ *(t++) = hexchar(c >> 4);
+ *(t++) = hexchar(c);
+ return t;
}
-static char* do_escape(const char *f, char *t) {
+static char *do_escape(const char *f, char *t) {
assert(f);
assert(t);
+ /* do not create units with a leading '.', like for "/.dotdir" mount points */
+ if (*f == '.') {
+ t = do_escape_char(*f, t);
+ f++;
+ }
+
for (; *f; f++) {
if (*f == '/')
*(t++) = '-';
- else if (*f == '-' || *f == '\\' || !strchr(VALID_CHARS, *f)) {
- *(t++) = '\\';
- *(t++) = 'x';
- *(t++) = hexchar(*f >> 4);
- *(t++) = hexchar(*f);
- } else
+ else if (*f == '-' || *f == '\\' || !strchr(VALID_CHARS, *f))
+ t = do_escape_char(*f, t);
+ else
*(t++) = *f;
}
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) {
assert(f);
- if (!(r = strdup(f)))
+ r = strdup(f);
+ if (!r)
return NULL;
for (t = r; *f; 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, "/")) {
+ 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;
b = strlen(i);
- if (!(r = new(char, a + 1 + b + strlen(e) + 1)))
+ r = new(char, a + 1 + b + strlen(e) + 1);
+ if (!r)
return NULL;
k = mempcpy(r, f, a + 1);
k = mempcpy(k, i, b);
} else {
- if (!(r = new(char, a + strlen(e) + 1)))
+ r = new(char, a + strlen(e) + 1);
+ if (!r)
return NULL;
k = mempcpy(r, f, a);
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);
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;
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;
assert(name);
- if (!(w = unit_name_to_prefix(name)))
+ w = unit_name_to_prefix(name);
+ if (!w)
return NULL;
- e = unit_name_unescape(w);
+ e = unit_name_path_unescape(w);
free(w);
+ return e;
+}
+
+char *unit_dbus_path_from_name(const char *name) {
+ char *e, *p;
+
+ assert(name);
+
+ e = bus_path_escape(name);
if (!e)
return NULL;
- if (e[0] != '/') {
- w = strappend("/", e);
- free(e);
+ p = strappend("/org/freedesktop/systemd1/unit/", e);
+ free(e);
- if (!w)
- return NULL;
+ return p;
+}
- e = w;
- }
+char *unit_name_mangle(const char *name) {
+ char *r, *t;
+ const char *f;
+ bool dot = false;
- return e;
-}
+ assert(name);
-char *unit_name_path_unescape(const char *f) {
- char *e;
+ /* Try to turn a string that might not be a unit name into a
+ * sensible unit name. */
- assert(f);
+ if (path_startswith(name, "/dev/") ||
+ path_startswith(name, "/sys/"))
+ return unit_name_from_path(name, ".device");
- if (!(e = unit_name_unescape(f)))
- return NULL;
+ if (path_is_absolute(name))
+ return unit_name_from_path(name, ".mount");
- if (e[0] != '/') {
- char *w;
+ /* We'll only escape the obvious characters here, to play
+ * safe. */
- w = strappend("/", e);
- free(e);
+ r = new(char, strlen(name) * 4 + 1 + sizeof(".service")-1);
+ if (!r)
+ return NULL;
- if (!w)
- return NULL;
+ for (f = name, t = r; *f; f++) {
+
+ if (*f == '.')
+ dot = true;
- e = w;
+ if (*f == '/')
+ *(t++) = '-';
+ else if (!strchr("@" VALID_CHARS, *f))
+ t = do_escape_char(*f, t);
+ else
+ *(t++) = *f;
}
- return e;
+ if (!dot)
+ strcpy(t, ".service");
+ 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);
}
~ianmdlvl / elogind.git / blobdiff