src/core/unit-printf.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 "systemd/sd-id128.h"
  23 #include "unit.h"
  24 #include "specifier.h"
  25 #include "path-util.h"
  26 #include "strv.h"
  27 #include "unit-name.h"
  28 #include "unit-printf.h"
  29 #include "macro.h"
  30
  31 static char *specifier_prefix_and_instance(char specifier, void *data, void *userdata) {
  32         Unit *u = userdata;
  33         assert(u);
  34
  35         return unit_name_to_prefix_and_instance(u->id);
  36 }
  37
  38 static char *specifier_prefix(char specifier, void *data, void *userdata) {
  39         Unit *u = userdata;
  40         assert(u);
  41
  42         return unit_name_to_prefix(u->id);
  43 }
  44
  45 static char *specifier_prefix_unescaped(char specifier, void *data, void *userdata) {
  46         Unit *u = userdata;
  47         char *p, *r;
  48
  49         assert(u);
  50
  51         p = unit_name_to_prefix(u->id);
  52         if (!p)
  53                 return NULL;
  54
  55         r = unit_name_unescape(p);
  56         free(p);
  57
  58         return r;
  59 }
  60
  61 static char *specifier_instance_unescaped(char specifier, void *data, void *userdata) {
  62         Unit *u = userdata;
  63         assert(u);
  64
  65         if (u->instance)
  66                 return unit_name_unescape(u->instance);
  67
  68         return strdup("");
  69 }
  70
  71 static char *specifier_filename(char specifier, void *data, void *userdata) {
  72         Unit *u = userdata;
  73         assert(u);
  74
  75         if (u->instance)
  76                 return unit_name_path_unescape(u->instance);
  77
  78         return unit_name_to_path(u->id);
  79 }
  80
  81 static char *specifier_cgroup(char specifier, void *data, void *userdata) {
  82         Unit *u = userdata;
  83         assert(u);
  84
  85         return unit_default_cgroup_path(u);
  86 }
  87
  88 static char *specifier_cgroup_root(char specifier, void *data, void *userdata) {
  89         Unit *u = userdata;
  90         char *p;
  91         assert(u);
  92
  93         if (specifier == 'r')
  94                 return strdup(u->manager->cgroup_hierarchy);
  95
  96         if (path_get_parent(u->manager->cgroup_hierarchy, &p) < 0)
  97                 return strdup("");
  98
  99         if (streq(p, "/")) {
 100                 free(p);
 101                 return strdup("");
 102         }
 103
 104         return p;
 105 }
 106
 107 static char *specifier_runtime(char specifier, void *data, void *userdata) {
 108         Unit *u = userdata;
 109         assert(u);
 110
 111         if (u->manager->running_as == SYSTEMD_USER) {
 112                 const char *e;
 113
 114                 e = getenv("XDG_RUNTIME_DIR");
 115                 if (e)
 116                         return strdup(e);
 117         }
 118
 119         return strdup("/run");
 120 }
 121
 122 static char *specifier_user_name(char specifier, void *data, void *userdata) {
 123         Unit *u = userdata;
 124         ExecContext *c;
 125         int r;
 126         const char *username;
 127         char _cleanup_free_ *tmp = NULL;
 128         uid_t uid;
 129         char *printed = NULL;
 130
 131         assert(u);
 132
 133         c = unit_get_exec_context(u);
 134
 135         if (c && c->user)
 136                 username = c->user;
 137         else
 138                 /* get USER env from env or our own uid */
 139                 username = tmp = getusername_malloc();
 140
 141         /* fish username from passwd */
 142         r = get_user_creds(&username, &uid, NULL, NULL, NULL);
 143         if (r < 0)
 144                 return NULL;
 145
 146         switch (specifier) {
 147                 case 'U':
 148                         if (asprintf(&printed, "%d", uid) < 0)
 149                                 return NULL;
 150                         break;
 151                 case 'u':
 152                         printed = strdup(username);
 153                         break;
 154         }
 155
 156         return printed;
 157 }
 158
 159 static char *specifier_user_home(char specifier, void *data, void *userdata) {
 160         Unit *u = userdata;
 161         ExecContext *c;
 162         int r;
 163         const char *username, *home;
 164
 165         assert(u);
 166
 167         c = unit_get_exec_context(u);
 168
 169         /* return HOME if set, otherwise from passwd */
 170         if (!c || !c->user) {
 171                 char *h;
 172
 173                 r = get_home_dir(&h);
 174                 if (r < 0)
 175                         return NULL;
 176
 177                 return h;
 178         }
 179
 180         username = c->user;
 181         r = get_user_creds(&username, NULL, NULL, &home, NULL);
 182         if (r < 0)
 183                return NULL;
 184
 185         return strdup(home);
 186 }
 187
 188 static char *specifier_user_shell(char specifier, void *data, void *userdata) {
 189         Unit *u = userdata;
 190         ExecContext *c;
 191         int r;
 192         const char *username, *shell;
 193
 194         assert(u);
 195
 196         c = unit_get_exec_context(u);
 197
 198         /* return HOME if set, otherwise from passwd */
 199         if (!c || !c->user) {
 200                 char *sh;
 201
 202                 r = get_shell(&sh);
 203                 if (r < 0)
 204                         return strdup("/bin/sh");
 205
 206                 return sh;
 207         }
 208
 209         username = c->user;
 210         r = get_user_creds(&username, NULL, NULL, NULL, &shell);
 211         if (r < 0)
 212                 return strdup("/bin/sh");
 213
 214         return strdup(shell);
 215 }
 216
 217 char *unit_name_printf(Unit *u, const char* format) {
 218
 219         /*
 220          * This will use the passed string as format string and
 221          * replace the following specifiers:
 222          *
 223          * %n: the full id of the unit                 (foo@bar.waldo)
 224          * %N: the id of the unit without the suffix   (foo@bar)
 225          * %p: the prefix                              (foo)
 226          * %i: the instance                            (bar)
 227          */
 228
 229         const Specifier table[] = {
 230                 { 'n', specifier_string,              u->id },
 231                 { 'N', specifier_prefix_and_instance, NULL },
 232                 { 'p', specifier_prefix,              NULL },
 233                 { 'i', specifier_string,              u->instance },
 234                 { 0, NULL, NULL }
 235         };
 236
 237         assert(u);
 238         assert(format);
 239
 240         return specifier_printf(format, table, u);
 241 }
 242
 243 char *unit_full_printf(Unit *u, const char *format) {
 244
 245         /* This is similar to unit_name_printf() but also supports
 246          * unescaping. Also, adds a couple of additional codes:
 247          *
 248          * %f the the instance if set, otherwise the id
 249          * %c cgroup path of unit
 250          * %r root cgroup path of this systemd instance (e.g. "/user/lennart/shared/systemd-4711")
 251          * %R parent of root cgroup path (e.g. "/usr/lennart/shared")
 252          * %t the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
 253          * %U the UID of the configured user or running user
 254          * %u the username of the configured user or running user
 255          * %h the homedir of the configured user or running user
 256          * %s the shell of the configured user or running user
 257          * %m the machine ID of the running system
 258          * %H the host name of the running system
 259          * %b the boot ID of the running system
 260          */
 261
 262         const Specifier table[] = {
 263                 { 'n', specifier_string,              u->id },
 264                 { 'N', specifier_prefix_and_instance, NULL },
 265                 { 'p', specifier_prefix,              NULL },
 266                 { 'P', specifier_prefix_unescaped,    NULL },
 267                 { 'i', specifier_string,              u->instance },
 268                 { 'I', specifier_instance_unescaped,  NULL },
 269
 270                 { 'f', specifier_filename,            NULL },
 271                 { 'c', specifier_cgroup,              NULL },
 272                 { 'r', specifier_cgroup_root,         NULL },
 273                 { 'R', specifier_cgroup_root,         NULL },
 274                 { 't', specifier_runtime,             NULL },
 275                 { 'U', specifier_user_name,           NULL },
 276                 { 'u', specifier_user_name,           NULL },
 277                 { 'h', specifier_user_home,           NULL },
 278                 { 's', specifier_user_shell,          NULL },
 279
 280                 { 'm', specifier_machine_id,          NULL },
 281                 { 'H', specifier_host_name,           NULL },
 282                 { 'b', specifier_boot_id,             NULL },
 283                 { 0, NULL, NULL }
 284         };
 285
 286         assert(format);
 287
 288         return specifier_printf(format, table, u);
 289 }
 290
 291 char **unit_full_printf_strv(Unit *u, char **l) {
 292         size_t n;
 293         char **r, **i, **j;
 294
 295         /* Applies unit_full_printf to every entry in l */
 296
 297         assert(u);
 298
 299         n = strv_length(l);
 300         r = new(char*, n+1);
 301         if (!r)
 302                 return NULL;
 303
 304         for (i = l, j = r; *i; i++, j++) {
 305                 *j = unit_full_printf(u, *i);
 306                 if (!*j)
 307                         goto fail;
 308         }
 309
 310         *j = NULL;
 311         return r;
 312
 313 fail:
 314         for (j--; j >= r; j--)
 315                 free(*j);
 316
 317         free(r);
 318
 319         return NULL;
 320 }