src/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 General Public License as published by
  10   the Free Software Foundation; either version 2 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   General Public License for more details.
  17
  18   You should have received a copy of the GNU 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 "util.h"
  27 #include "unit-name.h"
  28
  29 #define VALID_CHARS                             \
  30         "0123456789"                            \
  31         "abcdefghijklmnopqrstuvwxyz"            \
  32         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"            \
  33         ":-_.\\"
  34
  35 bool unit_name_is_valid_no_type(const char *n, bool template_ok) {
  36         const char *e, *i, *at;
  37
  38         /* Valid formats:
  39          *
  40          *         string@instance.suffix
  41          *         string.suffix
  42          */
  43
  44         assert(n);
  45
  46         if (strlen(n) >= UNIT_NAME_MAX)
  47                 return false;
  48
  49         e = strrchr(n, '.');
  50         if (!e || e == n)
  51                 return false;
  52
  53         for (i = n, at = NULL; i < e; i++) {
  54
  55                 if (*i == '@' && !at)
  56                         at = i;
  57
  58                 if (!strchr("@" VALID_CHARS, *i))
  59                         return false;
  60         }
  61
  62         if (at) {
  63                 if (at == n)
  64                         return false;
  65
  66                 if (!template_ok && at+1 == e)
  67                         return false;
  68         }
  69
  70         return true;
  71 }
  72
  73 bool unit_instance_is_valid(const char *i) {
  74         assert(i);
  75
  76         /* The max length depends on the length of the string, so we
  77          * don't really check this here. */
  78
  79         if (i[0] == 0)
  80                 return false;
  81
  82         /* We allow additional @ in the instance string, we do not
  83          * allow them in the prefix! */
  84
  85         for (; *i; i++)
  86                 if (!strchr("@" VALID_CHARS, *i))
  87                         return false;
  88
  89         return true;
  90 }
  91
  92 bool unit_prefix_is_valid(const char *p) {
  93
  94         /* We don't allow additional @ in the instance string */
  95
  96         if (p[0] == 0)
  97                 return false;
  98
  99         for (; *p; p++)
 100                 if (!strchr(VALID_CHARS, *p))
 101                         return false;
 102
 103         return true;
 104 }
 105
 106 int unit_name_to_instance(const char *n, char **instance) {
 107         const char *p, *d;
 108         char *i;
 109
 110         assert(n);
 111         assert(instance);
 112
 113         /* Everything past the first @ and before the last . is the instance */
 114         if (!(p = strchr(n, '@'))) {
 115                 *instance = NULL;
 116                 return 0;
 117         }
 118
 119         assert_se(d = strrchr(n, '.'));
 120         assert(p < d);
 121
 122         if (!(i = strndup(p+1, d-p-1)))
 123                 return -ENOMEM;
 124
 125         *instance = i;
 126         return 0;
 127 }
 128
 129 char *unit_name_to_prefix_and_instance(const char *n) {
 130         const char *d;
 131
 132         assert(n);
 133
 134         assert_se(d = strrchr(n, '.'));
 135
 136         return strndup(n, d - n);
 137 }
 138
 139 char *unit_name_to_prefix(const char *n) {
 140         const char *p;
 141
 142         if ((p = strchr(n, '@')))
 143                 return strndup(n, p - n);
 144
 145         return unit_name_to_prefix_and_instance(n);
 146 }
 147
 148 char *unit_name_change_suffix(const char *n, const char *suffix) {
 149         char *e, *r;
 150         size_t a, b;
 151
 152         assert(n);
 153         assert(unit_name_is_valid_no_type(n, true));
 154         assert(suffix);
 155
 156         assert_se(e = strrchr(n, '.'));
 157         a = e - n;
 158         b = strlen(suffix);
 159
 160         if (!(r = new(char, a + b + 1)))
 161                 return NULL;
 162
 163         memcpy(r, n, a);
 164         memcpy(r+a, suffix, b+1);
 165
 166         return r;
 167 }
 168
 169 char *unit_name_build(const char *prefix, const char *instance, const char *suffix) {
 170         assert(prefix);
 171         assert(unit_prefix_is_valid(prefix));
 172         assert(!instance || unit_instance_is_valid(instance));
 173         assert(suffix);
 174
 175         if (!instance)
 176                 return strappend(prefix, suffix);
 177
 178         return join(prefix, "@", instance, suffix, NULL);
 179 }
 180
 181 static char* do_escape(const char *f, char *t) {
 182         assert(f);
 183         assert(t);
 184
 185         for (; *f; f++) {
 186                 if (*f == '/')
 187                         *(t++) = '-';
 188                 else if (*f == '-' || *f == '\\' || !strchr(VALID_CHARS, *f)) {
 189                         *(t++) = '\\';
 190                         *(t++) = 'x';
 191                         *(t++) = hexchar(*f >> 4);
 192                         *(t++) = hexchar(*f);
 193                 } else
 194                         *(t++) = *f;
 195         }
 196
 197         return t;
 198 }
 199
 200 char *unit_name_build_escape(const char *prefix, const char *instance, const char *suffix) {
 201         char *r, *t;
 202         size_t a, b, c;
 203
 204         assert(prefix);
 205         assert(suffix);
 206
 207         /* Takes a arbitrary string for prefix and instance plus a
 208          * suffix and makes a nice string suitable as unit name of it,
 209          * escaping all weird chars on the way.
 210          *
 211          * / becomes ., and all chars not allowed in a unit name get
 212          * escaped as \xFF, including \ and ., of course. This
 213          * escaping is hence reversible.
 214          *
 215          * This is primarily useful to make nice unit names from
 216          * strings, but is actually useful for any kind of string.
 217          */
 218
 219         a = strlen(prefix);
 220         c = strlen(suffix);
 221
 222         if (instance) {
 223                 b = strlen(instance);
 224
 225                 if (!(r = new(char, a*4 + 1 + b*4 + c + 1)))
 226                         return NULL;
 227
 228                 t = do_escape(prefix, r);
 229                 *(t++) = '@';
 230                 t = do_escape(instance, t);
 231         } else {
 232
 233                 if (!(r = new(char, a*4 + c + 1)))
 234                         return NULL;
 235
 236                 t = do_escape(prefix, r);
 237         }
 238
 239         strcpy(t, suffix);
 240         return r;
 241 }
 242
 243 char *unit_name_escape(const char *f) {
 244         char *r, *t;
 245
 246         if (!(r = new(char, strlen(f)*4+1)))
 247                 return NULL;
 248
 249         t = do_escape(f, r);
 250         *t = 0;
 251
 252         return r;
 253
 254 }
 255
 256 char *unit_name_unescape(const char *f) {
 257         char *r, *t;
 258
 259         assert(f);
 260
 261         if (!(r = strdup(f)))
 262                 return NULL;
 263
 264         for (t = r; *f; f++) {
 265                 if (*f == '-')
 266                         *(t++) = '/';
 267                 else if (*f == '\\') {
 268                         int a, b;
 269
 270                         if (f[1] != 'x' ||
 271                             (a = unhexchar(f[2])) < 0 ||
 272                             (b = unhexchar(f[3])) < 0) {
 273                                 /* Invalid escape code, let's take it literal then */
 274                                 *(t++) = '\\';
 275                         } else {
 276                                 *(t++) = (char) ((a << 4) | b);
 277                                 f += 3;
 278                         }
 279                 } else
 280                         *(t++) = *f;
 281         }
 282
 283         *t = 0;
 284
 285         return r;
 286 }
 287
 288 bool unit_name_is_template(const char *n) {
 289         const char *p;
 290
 291         assert(n);
 292
 293         if (!(p = strchr(n, '@')))
 294                 return false;
 295
 296         return p[1] == '.';
 297 }
 298
 299 char *unit_name_replace_instance(const char *f, const char *i) {
 300         const char *p, *e;
 301         char *r, *k;
 302         size_t a;
 303
 304         assert(f);
 305
 306         p = strchr(f, '@');
 307         assert_se(e = strrchr(f, '.'));
 308
 309         a = p - f;
 310
 311         if (p) {
 312                 size_t b;
 313
 314                 b = strlen(i);
 315
 316                 if (!(r = new(char, a + 1 + b + strlen(e) + 1)))
 317                         return NULL;
 318
 319                 k = mempcpy(r, f, a + 1);
 320                 k = mempcpy(k, i, b);
 321         } else {
 322
 323                 if (!(r = new(char, a + strlen(e) + 1)))
 324                         return NULL;
 325
 326                 k = mempcpy(r, f, a);
 327         }
 328
 329         strcpy(k, e);
 330         return r;
 331 }
 332
 333 char *unit_name_template(const char *f) {
 334         const char *p, *e;
 335         char *r;
 336         size_t a;
 337
 338         if (!(p = strchr(f, '@')))
 339                 return strdup(f);
 340
 341         assert_se(e = strrchr(f, '.'));
 342         a = p - f + 1;
 343
 344         if (!(r = new(char, a + strlen(e) + 1)))
 345                 return NULL;
 346
 347         strcpy(mempcpy(r, f, a), e);
 348         return r;
 349
 350 }
 351
 352 char *unit_name_from_path(const char *path, const char *suffix) {
 353         char *p, *r;
 354
 355         assert(path);
 356         assert(suffix);
 357
 358         if (!(p = strdup(path)))
 359                 return NULL;
 360
 361         path_kill_slashes(p);
 362
 363         path = p[0] == '/' ? p + 1 : p;
 364
 365         if (path[0] == 0) {
 366                 free(p);
 367                 return strappend("-", suffix);
 368         }
 369
 370         r = unit_name_build_escape(path, NULL, suffix);
 371         free(p);
 372
 373         return r;
 374 }
 375
 376 char *unit_name_from_path_instance(const char *prefix, const char *path, const char *suffix) {
 377         char *p, *r;
 378
 379         assert(path);
 380         assert(suffix);
 381
 382         if (!(p = strdup(path)))
 383                 return NULL;
 384
 385         path_kill_slashes(p);
 386
 387         path = p[0] == '/' ? p + 1 : p;
 388
 389         if (path[0] == 0) {
 390                 free(p);
 391                 return unit_name_build_escape(prefix, "-", suffix);
 392         }
 393
 394         r = unit_name_build_escape(prefix, path, suffix);
 395         free(p);
 396
 397         return r;
 398 }
 399
 400 char *unit_name_to_path(const char *name) {
 401         char *w, *e;
 402
 403         assert(name);
 404
 405         if (!(w = unit_name_to_prefix(name)))
 406                 return NULL;
 407
 408         e = unit_name_unescape(w);
 409         free(w);
 410
 411         if (!e)
 412                 return NULL;
 413
 414         if (e[0] != '/') {
 415                 w = strappend("/", e);
 416                 free(e);
 417
 418                 if (!w)
 419                         return NULL;
 420
 421                 e = w;
 422         }
 423
 424         return e;
 425 }
 426
 427 char *unit_name_path_unescape(const char *f) {
 428         char *e;
 429
 430         assert(f);
 431
 432         if (!(e = unit_name_unescape(f)))
 433                 return NULL;
 434
 435         if (e[0] != '/') {
 436                 char *w;
 437
 438                 w = strappend("/", e);
 439                 free(e);
 440
 441                 if (!w)
 442                         return NULL;
 443
 444                 e = w;
 445         }
 446
 447         return e;
 448 }