unit-printf.c 9.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include "systemd/sd-id128.h"
#include "unit.h"
#include "specifier.h"
#include "path-util.h"
#include "strv.h"
#include "unit-name.h"
#include "unit-printf.h"

static char *specifier_prefix_and_instance(char specifier, void *data, void *userdata) {
        Unit *u = userdata;
        assert(u);

        return unit_name_to_prefix_and_instance(u->id);
}

static char *specifier_prefix(char specifier, void *data, void *userdata) {
        Unit *u = userdata;
        assert(u);

        return unit_name_to_prefix(u->id);
}

static char *specifier_prefix_unescaped(char specifier, void *data, void *userdata) {
        Unit *u = userdata;
        char *p, *r;

        assert(u);

        p = unit_name_to_prefix(u->id);
        if (!p)
                return NULL;

        r = unit_name_unescape(p);
        free(p);

        return r;
}

static char *specifier_instance_unescaped(char specifier, void *data, void *userdata) {
        Unit *u = userdata;
        assert(u);

        if (u->instance)
                return unit_name_unescape(u->instance);

        return strdup("");
}

static char *specifier_filename(char specifier, void *data, void *userdata) {
        Unit *u = userdata;
        assert(u);

        if (u->instance)
                return unit_name_path_unescape(u->instance);

        return unit_name_to_path(u->id);
}

static char *specifier_cgroup(char specifier, void *data, void *userdata) {
        Unit *u = userdata;
        assert(u);

        return unit_default_cgroup_path(u);
}

static char *specifier_cgroup_root(char specifier, void *data, void *userdata) {
        Unit *u = userdata;
        char *p;
        assert(u);

        if (specifier == 'r')
                return strdup(u->manager->cgroup_hierarchy);

        if (path_get_parent(u->manager->cgroup_hierarchy, &p) < 0)
                return strdup("");

        if (streq(p, "/")) {
                free(p);
                return strdup("");
        }

        return p;
}

static char *specifier_runtime(char specifier, void *data, void *userdata) {
        Unit *u = userdata;
        assert(u);

110
        if (u->manager->running_as == SYSTEMD_USER) {
111
112
113
114
115
116
117
118
119
120
121
                const char *e;

                e = getenv("XDG_RUNTIME_DIR");
                if (e)
                        return strdup(e);
        }

        return strdup("/run");
}

static char *specifier_user_name(char specifier, void *data, void *userdata) {
122
123
        Unit *u = userdata;
        ExecContext *c;
124
125
126
        int r;
        const char *username;

127
128
        assert(u);

129
130
131
132
        c = unit_get_exec_context(u);
        if (!c)
                return NULL;

133
        /* get USER env from our own env if set */
134
        if (!c->user)
135
136
137
                return getusername_malloc();

        /* fish username from passwd */
138
        username = c->user;
139
140
141
142
143
144
145
146
        r = get_user_creds(&username, NULL, NULL, NULL, NULL);
        if (r < 0)
                return NULL;

        return strdup(username);
}

static char *specifier_user_home(char specifier, void *data, void *userdata) {
147
148
        Unit *u = userdata;
        ExecContext *c;
149
150
151
        int r;
        const char *username, *home;

152
153
        assert(u);

154
155
156
157
        c = unit_get_exec_context(u);
        if (!c)
                return NULL;

158
        /* return HOME if set, otherwise from passwd */
159
        if (!c->user) {
160
161
162
163
164
165
166
167
168
                char *h;

                r = get_home_dir(&h);
                if (r < 0)
                        return NULL;

                return h;
        }

169
        username = c->user;
170
171
172
173
174
175
176
177
        r = get_user_creds(&username, NULL, NULL, &home, NULL);
        if (r < 0)
               return NULL;

        return strdup(home);
}

static char *specifier_user_shell(char specifier, void *data, void *userdata) {
178
179
        Unit *u = userdata;
        ExecContext *c;
180
181
182
        int r;
        const char *username, *shell;

183
184
        assert(u);

185
186
187
188
        c = unit_get_exec_context(u);
        if (!c)
                return NULL;

189
        /* return HOME if set, otherwise from passwd */
190
        if (!c->user) {
191
192
193
194
195
196
197
198
199
                char *sh;

                r = get_shell(&sh);
                if (r < 0)
                        return strdup("/bin/sh");

                return sh;
        }

200
        username = c->user;
201
202
203
204
205
206
207
        r = get_user_creds(&username, NULL, NULL, NULL, &shell);
        if (r < 0)
                return strdup("/bin/sh");

        return strdup(shell);
}

208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
static char *specifier_machine_id(char specifier, void *data, void *userdata) {
        sd_id128_t id;
        char *buf;
        int r;

        r = sd_id128_get_machine(&id);
        if (r < 0)
                return NULL;

        buf = new(char, 33);
        if (!buf)
                return NULL;

        return sd_id128_to_string(id, buf);
}

static char *specifier_boot_id(char specifier, void *data, void *userdata) {
        sd_id128_t id;
        char *buf;
        int r;

        r = sd_id128_get_boot(&id);
        if (r < 0)
                return NULL;

        buf = new(char, 33);
        if (!buf)
                return NULL;

        return sd_id128_to_string(id, buf);
}

static char *specifier_host_name(char specifier, void *data, void *userdata) {
        return gethostname_malloc();
}

244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
char *unit_name_printf(Unit *u, const char* format) {

        /*
         * This will use the passed string as format string and
         * replace the following specifiers:
         *
         * %n: the full id of the unit                 (foo@bar.waldo)
         * %N: the id of the unit without the suffix   (foo@bar)
         * %p: the prefix                              (foo)
         * %i: the instance                            (bar)
         */

        const Specifier table[] = {
                { 'n', specifier_string,              u->id },
                { 'N', specifier_prefix_and_instance, NULL },
                { 'p', specifier_prefix,              NULL },
                { 'i', specifier_string,              u->instance },
                { 0, NULL, NULL }
        };

        assert(u);
        assert(format);

        return specifier_printf(format, table, u);
}

char *unit_full_printf(Unit *u, const char *format) {

        /* This is similar to unit_name_printf() but also supports
         * unescaping. Also, adds a couple of additional codes:
         *
         * %f the the instance if set, otherwise the id
         * %c cgroup path of unit
         * %r root cgroup path of this systemd instance (e.g. "/user/lennart/shared/systemd-4711")
         * %R parent of root cgroup path (e.g. "/usr/lennart/shared")
         * %t the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
         * %u the username of the configured user or running user
         * %h the homedir of the configured user or running user
         * %s the shell of the configured user or running user
283
284
285
         * %m the machine ID of the running system
         * %b the boot ID of the running system
         * %H the host name of the running system
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
         */

        const Specifier table[] = {
                { 'n', specifier_string,              u->id },
                { 'N', specifier_prefix_and_instance, NULL },
                { 'p', specifier_prefix,              NULL },
                { 'P', specifier_prefix_unescaped,    NULL },
                { 'i', specifier_string,              u->instance },
                { 'I', specifier_instance_unescaped,  NULL },

                { 'f', specifier_filename,            NULL },
                { 'c', specifier_cgroup,              NULL },
                { 'r', specifier_cgroup_root,         NULL },
                { 'R', specifier_cgroup_root,         NULL },
                { 't', specifier_runtime,             NULL },
                { 'u', specifier_user_name,           NULL },
                { 'h', specifier_user_home,           NULL },
                { 's', specifier_user_shell,          NULL },
304
305
306
307

                { 'm', specifier_machine_id,          NULL },
                { 'H', specifier_host_name,           NULL },
                { 'b', specifier_boot_id,             NULL },
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
                { 0, NULL, NULL }
        };

        assert(u);
        assert(format);

        return specifier_printf(format, table, u);
}

char **unit_full_printf_strv(Unit *u, char **l) {
        size_t n;
        char **r, **i, **j;

        /* Applies unit_full_printf to every entry in l */

        assert(u);

        n = strv_length(l);
        r = new(char*, n+1);
        if (!r)
                return NULL;

        for (i = l, j = r; *i; i++, j++) {
                *j = unit_full_printf(u, *i);
                if (!*j)
                        goto fail;
        }

        *j = NULL;
        return r;

fail:
        for (j--; j >= r; j--)
                free(*j);

        free(r);

        return NULL;
}