if (r < 0)
return r;
- if (!unit_name_is_valid(s, false) || !endswith(s, ".slice"))
+ if (!unit_name_is_valid(s, TEMPLATE_INVALID) || !endswith(s, ".slice"))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid slice name %s", s);
if (isempty(s)) {
return r;
while ((r = sd_bus_message_read(message, "s", &other)) > 0) {
- if (!unit_name_is_valid(other, false))
+ if (!unit_name_is_valid(other, TEMPLATE_INVALID))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid unit name %s", other);
if (mode != UNIT_CHECK) {
memcpy(e, w, l);
e[l] = 0;
- n = unit_name_mangle(e, false);
+ n = unit_name_mangle(e, MANGLE_NOGLOB);
if (!n) {
r = -ENOMEM;
goto fail;
* unit name. */
name = basename(*filename);
- if (unit_name_is_valid(name, true)) {
+ if (unit_name_is_valid(name, TEMPLATE_VALID)) {
id = set_get(names, name);
if (!id) {
t = unit_name_to_type(name);
- if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false))
+ if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
ret = manager_get_unit(m, name);
assert(_s);
if (name) {
- if (!unit_name_is_valid(name, false))
+ if (!unit_name_is_valid(name, TEMPLATE_INVALID))
return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
if (unit_name_to_type(name) != UNIT_SNAPSHOT)
if (!s)
return -ENOMEM;
- if (!unit_name_is_valid(s, false)) {
+ if (!unit_name_is_valid(s, TEMPLATE_INVALID)) {
r = -EINVAL;
goto fail;
}
}
if (service) {
- if (!unit_name_is_valid(service, false)) {
+ if (!unit_name_is_valid(service, TEMPLATE_INVALID)) {
log_warning("Unit name %s is not valid, ignoring.", service);
return 0;
}
assert(j);
STRV_FOREACH(i, arg_system_units) {
- u = unit_name_mangle(*i, false);
+ u = unit_name_mangle(*i, MANGLE_NOGLOB);
if (!u)
return log_oom();
r = add_matches_for_unit(j, u);
}
STRV_FOREACH(i, arg_user_units) {
- u = unit_name_mangle(*i, false);
+ u = unit_name_mangle(*i, MANGLE_NOGLOB);
if (!u)
return log_oom();
if (!isempty(arg_slice)) {
_cleanup_free_ char *slice;
- slice = unit_name_mangle_with_suffix(arg_slice, false, ".slice");
+ slice = unit_name_mangle_with_suffix(arg_slice, MANGLE_NOGLOB, ".slice");
if (!slice)
return -ENOMEM;
int r;
if (arg_unit)
- name = unit_name_mangle_with_suffix(arg_unit, false, ".service");
+ name = unit_name_mangle_with_suffix(arg_unit, MANGLE_NOGLOB, ".service");
else
asprintf(&name, "run-%lu.service", (unsigned long) getpid());
if (!name)
assert(bus);
if (arg_unit)
- name = unit_name_mangle_with_suffix(arg_unit, false, ".scope");
+ name = unit_name_mangle_with_suffix(arg_unit, MANGLE_NOGLOB, ".scope");
else
asprintf(&name, "run-%lu.scope", (unsigned long) getpid());
if (!name)
c = strndupa(cgroup, e - cgroup);
c = cg_unescape(c);
- if (!unit_name_is_valid(c, false))
+ if (!unit_name_is_valid(c, TEMPLATE_INVALID))
return -EINVAL;
s = strdup(c);
assert(unit);
assert(ret);
- if (!unit_name_is_valid(unit, false))
+ if (!unit_name_is_valid(unit, TEMPLATE_INVALID))
return -EINVAL;
if (!endswith(unit, ".slice"))
strcpy(stpncpy(n, p, dash - p), ".slice");
- if (!unit_name_is_valid(n, false))
+ if (!unit_name_is_valid(n, TEMPLATE_INVALID))
return -EINVAL;
escaped = cg_escape(n);
STRV_FOREACH(i, files) {
_cleanup_free_ char *path = NULL;
- if (!unit_name_is_valid(*i, true)) {
+ if (!unit_name_is_valid(*i, TEMPLATE_VALID)) {
if (r == 0)
r = -EINVAL;
continue;
STRV_FOREACH(i, files) {
char *path;
- if (!unit_name_is_valid(*i, true)) {
+ if (!unit_name_is_valid(*i, TEMPLATE_VALID)) {
if (r == 0)
r = -EINVAL;
continue;
fn = basename(*i);
if (!path_is_absolute(*i) ||
- !unit_name_is_valid(fn, true)) {
+ !unit_name_is_valid(fn, TEMPLATE_VALID)) {
if (r == 0)
r = -EINVAL;
continue;
if (!name)
name = basename(path);
- if (!unit_name_is_valid(name, true))
+ if (!unit_name_is_valid(name, TEMPLATE_VALID))
return -EINVAL;
if (hashmap_get(c->have_installed, name) ||
if (q < 0)
return q;
- if (!unit_name_is_valid(dst, true)) {
+ if (!unit_name_is_valid(dst, TEMPLATE_VALID)) {
r = -EINVAL;
continue;
}
if (q < 0)
return q;
- if (!unit_name_is_valid(dst, true)) {
+ if (!unit_name_is_valid(dst, TEMPLATE_VALID)) {
r = -EINVAL;
continue;
}
if (root_dir && scope != UNIT_FILE_SYSTEM)
return -EINVAL;
- if (!unit_name_is_valid(name, true))
+ if (!unit_name_is_valid(name, TEMPLATE_VALID))
return -EINVAL;
r = lookup_paths_init_from_scope(&paths, scope);
STRV_FOREACH(i, files) {
- if (!unit_name_is_valid(*i, true))
+ if (!unit_name_is_valid(*i, TEMPLATE_VALID))
return -EINVAL;
r = unit_file_query_preset(scope, *i);
if (ignore_file(de->d_name))
continue;
- if (!unit_name_is_valid(de->d_name, true))
+ if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
continue;
if (hashmap_get(h, de->d_name))
DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
-bool unit_name_is_valid(const char *n, bool template_ok) {
+bool unit_name_is_valid(const char *n, enum template_valid template_ok) {
const char *e, *i, *at;
/* Valid formats:
*/
assert(n);
+ assert(IN_SET(template_ok, TEMPLATE_VALID, TEMPLATE_INVALID));
if (strlen(n) >= UNIT_NAME_MAX)
return false;
if (at == n)
return false;
- if (!template_ok && at+1 == e)
+ if (!template_ok == TEMPLATE_VALID && at+1 == e)
return false;
}
size_t a, b;
assert(n);
- assert(unit_name_is_valid(n, true));
+ assert(unit_name_is_valid(n, TEMPLATE_VALID));
assert(suffix);
assert(suffix[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, bool allow_globs) {
+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 ? "@" VALID_CHARS "[]!-*?" : "@" VALID_CHARS;
+ 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");
* 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, bool allow_globs, const char *suffix) {
+char *unit_name_mangle_with_suffix(const char *name, enum unit_name_mangle allow_globs, const char *suffix) {
char *r, *t;
const char *f;
char* unit_name_to_prefix(const char *n);
char* unit_name_to_prefix_and_instance(const char *n);
-bool unit_name_is_valid(const char *n, bool template_ok) _pure_;
+enum template_valid {
+ TEMPLATE_INVALID,
+ TEMPLATE_VALID,
+};
+
+bool unit_name_is_valid(const char *n, enum template_valid template_ok) _pure_;
bool unit_prefix_is_valid(const char *p) _pure_;
bool unit_instance_is_valid(const char *i) _pure_;
char *unit_dbus_path_from_name(const char *name);
int unit_name_from_dbus_path(const char *path, char **name);
-char *unit_name_mangle(const char *name, bool allow_globs);
-char *unit_name_mangle_with_suffix(const char *name, bool allow_globs, const char *suffix);
+enum unit_name_mangle {
+ MANGLE_NOGLOB,
+ MANGLE_GLOB,
+};
+
+char *unit_name_mangle(const char *name, enum unit_name_mangle allow_globs);
+char *unit_name_mangle_with_suffix(const char *name, enum unit_name_mangle allow_globs, const char *suffix);
int build_subslice(const char *slice, const char*name, char **subslice);
assert(bus);
if (args[1]) {
- unit = unit_name_mangle(args[1], false);
+ unit = unit_name_mangle(args[1], MANGLE_NOGLOB);
if (!unit)
return log_oom();
u = unit;
unsigned n_changes = 0;
int r;
- unit = unit_name_mangle_with_suffix(args[1], false, ".target");
+ unit = unit_name_mangle_with_suffix(args[1], MANGLE_NOGLOB, ".target");
if (!unit)
return log_oom();
assert(name);
- n = unit_name_mangle(name, false);
+ n = unit_name_mangle(name, MANGLE_NOGLOB);
if (!n)
return log_oom();
char **i;
int r;
- n = unit_name_mangle(name, false);
+ n = unit_name_mangle(name, MANGLE_NOGLOB);
if (!n)
return log_oom();
char *t;
if (suffix)
- t = unit_name_mangle_with_suffix(*name, true, suffix);
+ t = unit_name_mangle_with_suffix(*name, MANGLE_GLOB, suffix);
else
- t = unit_name_mangle(*name, true);
+ t = unit_name_mangle(*name, MANGLE_GLOB);
if (!t)
return log_oom();
if (r < 0)
return bus_log_create_error(r);
- n = unit_name_mangle(args[1], false);
+ n = unit_name_mangle(args[1], MANGLE_NOGLOB);
if (!n)
return log_oom();
int r;
if (strv_length(args) > 1)
- n = unit_name_mangle_with_suffix(args[1], false, ".snapshot");
+ n = unit_name_mangle_with_suffix(args[1], MANGLE_NOGLOB, ".snapshot");
else
n = strdup("");
if (!n)
if (is_path(*name))
*i = strdup(*name);
else
- *i = unit_name_mangle(*name, false);
+ *i = unit_name_mangle(*name, MANGLE_NOGLOB);
if (!*i) {
strv_free(l);
puts(t); \
k = unit_name_to_path(t); \
puts(k); \
- assert(streq(k, expected ? expected : path)); \
+ assert(streq(k, expected ? expected : path)); \
}
expect("/waldo", ".mount", NULL);
puts("-------------------------------------------------");
#undef expect
-#define expect(pattern, path, suffix, expected) \
- { \
- _cleanup_free_ char *t = \
+#define expect(pattern, path, suffix, expected) \
+ { \
+ _cleanup_free_ char *t = \
unit_name_from_path_instance(pattern, path, suffix); \
- puts(t); \
- assert(streq(t, expected)); \
+ puts(t); \
+ assert(streq(t, expected)); \
}
expect("waldo", "/waldo", ".mount", "waldo@waldo.mount");
puts("-------------------------------------------------");
#undef expect
-#define expect(pattern) \
- { \
- _cleanup_free_ char *k, *t; \
- assert_se(t = unit_name_mangle(pattern, false)); \
- assert_se(k = unit_name_mangle(t, false)); \
- puts(t); \
- assert_se(streq(t, k)); \
+#define expect(pattern) \
+ { \
+ _cleanup_free_ char *k, *t; \
+ assert_se(t = unit_name_mangle(pattern, MANGLE_NOGLOB)); \
+ assert_se(k = unit_name_mangle(t, MANGLE_NOGLOB)); \
+ puts(t); \
+ assert_se(streq(t, k)); \
}
expect("/home");