chiark / gitweb /
unit: move UnitDependency to unit-name
[elogind.git] / src / shared / unit-name.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <string.h>
24 #include <assert.h>
25
26 #include "path-util.h"
27 #include "bus-label.h"
28 #include "util.h"
29 #include "unit-name.h"
30 #include "def.h"
31 #include "strv.h"
32
33 #define VALID_CHARS                             \
34         DIGITS LETTERS                          \
35         ":-_.\\"
36
37 static const char* const unit_type_table[_UNIT_TYPE_MAX] = {
38         [UNIT_SERVICE] = "service",
39         [UNIT_SOCKET] = "socket",
40         [UNIT_BUSNAME] = "busname",
41         [UNIT_TARGET] = "target",
42         [UNIT_SNAPSHOT] = "snapshot",
43         [UNIT_DEVICE] = "device",
44         [UNIT_MOUNT] = "mount",
45         [UNIT_AUTOMOUNT] = "automount",
46         [UNIT_SWAP] = "swap",
47         [UNIT_TIMER] = "timer",
48         [UNIT_PATH] = "path",
49         [UNIT_SLICE] = "slice",
50         [UNIT_SCOPE] = "scope"
51 };
52
53 DEFINE_STRING_TABLE_LOOKUP(unit_type, UnitType);
54
55 static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
56         [UNIT_STUB] = "stub",
57         [UNIT_LOADED] = "loaded",
58         [UNIT_NOT_FOUND] = "not-found",
59         [UNIT_ERROR] = "error",
60         [UNIT_MERGED] = "merged",
61         [UNIT_MASKED] = "masked"
62 };
63
64 DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
65
66 bool unit_name_is_valid(const char *n, enum template_valid template_ok) {
67         const char *e, *i, *at;
68
69         /* Valid formats:
70          *
71          *         string@instance.suffix
72          *         string.suffix
73          */
74
75         assert(IN_SET(template_ok, TEMPLATE_VALID, TEMPLATE_INVALID));
76
77         if (isempty(n))
78                 return false;
79
80         if (strlen(n) >= UNIT_NAME_MAX)
81                 return false;
82
83         e = strrchr(n, '.');
84         if (!e || e == n)
85                 return false;
86
87         if (unit_type_from_string(e + 1) < 0)
88                 return false;
89
90         for (i = n, at = NULL; i < e; i++) {
91
92                 if (*i == '@' && !at)
93                         at = i;
94
95                 if (!strchr("@" VALID_CHARS, *i))
96                         return false;
97         }
98
99         if (at) {
100                 if (at == n)
101                         return false;
102
103                 if (!template_ok == TEMPLATE_VALID && at+1 == e)
104                         return false;
105         }
106
107         return true;
108 }
109
110 bool unit_instance_is_valid(const char *i) {
111
112         /* The max length depends on the length of the string, so we
113          * don't really check this here. */
114
115         if (isempty(i))
116                 return false;
117
118         /* We allow additional @ in the instance string, we do not
119          * allow them in the prefix! */
120
121         return in_charset(i, "@" VALID_CHARS);
122 }
123
124 bool unit_prefix_is_valid(const char *p) {
125
126         /* We don't allow additional @ in the instance string */
127
128         if (isempty(p))
129                 return false;
130
131         return in_charset(p, VALID_CHARS);
132 }
133
134 int unit_name_to_instance(const char *n, char **instance) {
135         const char *p, *d;
136         char *i;
137
138         assert(n);
139         assert(instance);
140
141         /* Everything past the first @ and before the last . is the instance */
142         p = strchr(n, '@');
143         if (!p) {
144                 *instance = NULL;
145                 return 0;
146         }
147
148         d = strrchr(n, '.');
149         if (!d)
150                 return -EINVAL;
151         if (d < p)
152                 return -EINVAL;
153
154         i = strndup(p+1, d-p-1);
155         if (!i)
156                 return -ENOMEM;
157
158         *instance = i;
159         return 1;
160 }
161
162 char *unit_name_to_prefix_and_instance(const char *n) {
163         const char *d;
164
165         assert(n);
166
167         assert_se(d = strrchr(n, '.'));
168         return strndup(n, d - n);
169 }
170
171 char *unit_name_to_prefix(const char *n) {
172         const char *p;
173
174         assert(n);
175
176         p = strchr(n, '@');
177         if (p)
178                 return strndup(n, p - n);
179
180         return unit_name_to_prefix_and_instance(n);
181 }
182
183 char *unit_name_change_suffix(const char *n, const char *suffix) {
184         char *e, *r;
185         size_t a, b;
186
187         assert(n);
188         assert(suffix);
189         assert(suffix[0] == '.');
190
191         assert_se(e = strrchr(n, '.'));
192         a = e - n;
193         b = strlen(suffix);
194
195         r = new(char, a + b + 1);
196         if (!r)
197                 return NULL;
198
199         strcpy(mempcpy(r, n, a), suffix);
200         return r;
201 }
202
203 char *unit_name_build(const char *prefix, const char *instance, const char *suffix) {
204         assert(prefix);
205         assert(suffix);
206
207         if (!instance)
208                 return strappend(prefix, suffix);
209
210         return strjoin(prefix, "@", instance, suffix, NULL);
211 }
212
213 static char *do_escape_char(char c, char *t) {
214         assert(t);
215
216         *(t++) = '\\';
217         *(t++) = 'x';
218         *(t++) = hexchar(c >> 4);
219         *(t++) = hexchar(c);
220
221         return t;
222 }
223
224 static char *do_escape(const char *f, char *t) {
225         assert(f);
226         assert(t);
227
228         /* do not create units with a leading '.', like for "/.dotdir" mount points */
229         if (*f == '.') {
230                 t = do_escape_char(*f, t);
231                 f++;
232         }
233
234         for (; *f; f++) {
235                 if (*f == '/')
236                         *(t++) = '-';
237                 else if (*f == '-' || *f == '\\' || !strchr(VALID_CHARS, *f))
238                         t = do_escape_char(*f, t);
239                 else
240                         *(t++) = *f;
241         }
242
243         return t;
244 }
245
246 char *unit_name_escape(const char *f) {
247         char *r, *t;
248
249         assert(f);
250
251         r = new(char, strlen(f)*4+1);
252         if (!r)
253                 return NULL;
254
255         t = do_escape(f, r);
256         *t = 0;
257
258         return r;
259 }
260
261 char *unit_name_unescape(const char *f) {
262         char *r, *t;
263
264         assert(f);
265
266         r = strdup(f);
267         if (!r)
268                 return NULL;
269
270         for (t = r; *f; f++) {
271                 if (*f == '-')
272                         *(t++) = '/';
273                 else if (*f == '\\') {
274                         int a, b;
275
276                         if (f[1] != 'x' ||
277                             (a = unhexchar(f[2])) < 0 ||
278                             (b = unhexchar(f[3])) < 0) {
279                                 /* Invalid escape code, let's take it literal then */
280                                 *(t++) = '\\';
281                         } else {
282                                 *(t++) = (char) ((a << 4) | b);
283                                 f += 3;
284                         }
285                 } else
286                         *(t++) = *f;
287         }
288
289         *t = 0;
290
291         return r;
292 }
293
294 char *unit_name_path_escape(const char *f) {
295         _cleanup_free_ char *p = NULL;
296
297         assert(f);
298
299         p = strdup(f);
300         if (!p)
301                 return NULL;
302
303         path_kill_slashes(p);
304
305         if (STR_IN_SET(p, "/", ""))
306                 return strdup("-");
307
308         return unit_name_escape(p[0] == '/' ? p + 1 : p);
309 }
310
311 char *unit_name_path_unescape(const char *f) {
312         char *e, *w;
313
314         assert(f);
315
316         e = unit_name_unescape(f);
317         if (!e)
318                 return NULL;
319
320         if (e[0] != '/') {
321                 w = strappend("/", e);
322                 free(e);
323                 return w;
324         }
325
326         return e;
327 }
328
329 bool unit_name_is_template(const char *n) {
330         const char *p, *e;
331
332         assert(n);
333
334         p = strchr(n, '@');
335         if (!p)
336                 return false;
337
338         e = strrchr(p+1, '.');
339         if (!e)
340                 return false;
341
342         return e == p + 1;
343 }
344
345 bool unit_name_is_instance(const char *n) {
346         const char *p, *e;
347
348         assert(n);
349
350         p = strchr(n, '@');
351         if (!p)
352                 return false;
353
354         e = strrchr(p+1, '.');
355         if (!e)
356                 return false;
357
358         return e > p + 1;
359 }
360
361 char *unit_name_replace_instance(const char *f, const char *i) {
362         const char *p, *e;
363         char *r;
364         size_t a, b;
365
366         assert(f);
367         assert(i);
368
369         p = strchr(f, '@');
370         if (!p)
371                 return strdup(f);
372
373         e = strrchr(f, '.');
374         if (!e)
375                 e = strchr(f, 0);
376
377         a = p - f;
378         b = strlen(i);
379
380         r = new(char, a + 1 + b + strlen(e) + 1);
381         if (!r)
382                 return NULL;
383
384         strcpy(mempcpy(mempcpy(r, f, a + 1), i, b), e);
385         return r;
386 }
387
388 char *unit_name_template(const char *f) {
389         const char *p, *e;
390         char *r;
391         size_t a;
392
393         assert(f);
394
395         p = strchr(f, '@');
396         if (!p)
397                 return strdup(f);
398
399         e = strrchr(f, '.');
400         if (!e)
401                 e = strchr(f, 0);
402
403         a = p - f;
404
405         r = new(char, a + 1 + strlen(e) + 1);
406         if (!r)
407                 return NULL;
408
409         strcpy(mempcpy(r, f, a + 1), e);
410         return r;
411 }
412
413 char *unit_name_from_path(const char *path, const char *suffix) {
414         _cleanup_free_ char *p = NULL;
415
416         assert(path);
417         assert(suffix);
418
419         p = unit_name_path_escape(path);
420         if (!p)
421                 return NULL;
422
423         return strappend(p, suffix);
424 }
425
426 char *unit_name_from_path_instance(const char *prefix, const char *path, const char *suffix) {
427         _cleanup_free_ char *p = NULL;
428
429         assert(prefix);
430         assert(path);
431         assert(suffix);
432
433         p = unit_name_path_escape(path);
434         if (!p)
435                 return NULL;
436
437         return strjoin(prefix, "@", p, suffix, NULL);
438 }
439
440 char *unit_name_to_path(const char *name) {
441         _cleanup_free_ char *w = NULL;
442
443         assert(name);
444
445         w = unit_name_to_prefix(name);
446         if (!w)
447                 return NULL;
448
449         return unit_name_path_unescape(w);
450 }
451
452 char *unit_dbus_path_from_name(const char *name) {
453         _cleanup_free_ char *e = NULL;
454
455         assert(name);
456
457         e = bus_label_escape(name);
458         if (!e)
459                 return NULL;
460
461         return strappend("/org/freedesktop/systemd1/unit/", e);
462 }
463
464 int unit_name_from_dbus_path(const char *path, char **name) {
465         const char *e;
466         char *n;
467
468         e = startswith(path, "/org/freedesktop/systemd1/unit/");
469         if (!e)
470                 return -EINVAL;
471
472         n = bus_label_unescape(e);
473         if (!n)
474                 return -ENOMEM;
475
476         *name = n;
477         return 0;
478 }
479
480 /**
481  *  Try to turn a string that might not be a unit name into a
482  *  sensible unit name.
483  */
484 char *unit_name_mangle(const char *name, enum unit_name_mangle allow_globs) {
485         const char *valid_chars, *f;
486         char *r, *t;
487
488         assert(name);
489         assert(IN_SET(allow_globs, MANGLE_GLOB, MANGLE_NOGLOB));
490
491         if (is_device_path(name))
492                 return unit_name_from_path(name, ".device");
493
494         if (path_is_absolute(name))
495                 return unit_name_from_path(name, ".mount");
496
497         /* We'll only escape the obvious characters here, to play
498          * safe. */
499
500         valid_chars = allow_globs == MANGLE_GLOB ? "@" VALID_CHARS "[]!-*?" : "@" VALID_CHARS;
501
502         r = new(char, strlen(name) * 4 + strlen(".service") + 1);
503         if (!r)
504                 return NULL;
505
506         for (f = name, t = r; *f; f++) {
507                 if (*f == '/')
508                         *(t++) = '-';
509                 else if (!strchr(valid_chars, *f))
510                         t = do_escape_char(*f, t);
511                 else
512                         *(t++) = *f;
513         }
514
515         if (unit_name_to_type(name) < 0)
516                 strcpy(t, ".service");
517         else
518                 *t = 0;
519
520         return r;
521 }
522
523 /**
524  *  Similar to unit_name_mangle(), but is called when we know
525  *  that this is about a specific unit type.
526  */
527 char *unit_name_mangle_with_suffix(const char *name, enum unit_name_mangle allow_globs, const char *suffix) {
528         char *r, *t;
529         const char *f;
530
531         assert(name);
532         assert(IN_SET(allow_globs, MANGLE_GLOB, MANGLE_NOGLOB));
533         assert(suffix);
534         assert(suffix[0] == '.');
535
536         r = new(char, strlen(name) * 4 + strlen(suffix) + 1);
537         if (!r)
538                 return NULL;
539
540         for (f = name, t = r; *f; f++) {
541                 if (*f == '/')
542                         *(t++) = '-';
543                 else if (!strchr(VALID_CHARS, *f))
544                         t = do_escape_char(*f, t);
545                 else
546                         *(t++) = *f;
547         }
548
549         if (!endswith(name, suffix))
550                 strcpy(t, suffix);
551         else
552                 *t = 0;
553
554         return r;
555 }
556
557 UnitType unit_name_to_type(const char *n) {
558         const char *e;
559
560         assert(n);
561
562         e = strrchr(n, '.');
563         if (!e)
564                 return _UNIT_TYPE_INVALID;
565
566         return unit_type_from_string(e + 1);
567 }
568
569 int build_subslice(const char *slice, const char*name, char **subslice) {
570         char *ret;
571
572         assert(slice);
573         assert(name);
574         assert(subslice);
575
576         if (streq(slice, "-.slice"))
577                 ret = strappend(name, ".slice");
578         else {
579                 char *e;
580
581                 e = endswith(slice, ".slice");
582                 if (!e)
583                         return -EINVAL;
584
585                 ret = new(char, (e - slice) + 1 + strlen(name) + 6 + 1);
586                 if (!ret)
587                         return -ENOMEM;
588
589                 stpcpy(stpcpy(stpcpy(mempcpy(ret, slice, e - slice), "-"), name), ".slice");
590         }
591
592         *subslice = ret;
593         return 0;
594 }
595
596 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
597         [UNIT_REQUIRES] = "Requires",
598         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
599         [UNIT_REQUISITE] = "Requisite",
600         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
601         [UNIT_WANTS] = "Wants",
602         [UNIT_BINDS_TO] = "BindsTo",
603         [UNIT_PART_OF] = "PartOf",
604         [UNIT_REQUIRED_BY] = "RequiredBy",
605         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
606         [UNIT_WANTED_BY] = "WantedBy",
607         [UNIT_BOUND_BY] = "BoundBy",
608         [UNIT_CONSISTS_OF] = "ConsistsOf",
609         [UNIT_CONFLICTS] = "Conflicts",
610         [UNIT_CONFLICTED_BY] = "ConflictedBy",
611         [UNIT_BEFORE] = "Before",
612         [UNIT_AFTER] = "After",
613         [UNIT_ON_FAILURE] = "OnFailure",
614         [UNIT_TRIGGERS] = "Triggers",
615         [UNIT_TRIGGERED_BY] = "TriggeredBy",
616         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
617         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
618         [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
619         [UNIT_REFERENCES] = "References",
620         [UNIT_REFERENCED_BY] = "ReferencedBy",
621 };
622
623 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);