chiark / gitweb /
do not create /dev/rtc symlink, let systemd search for it if needed
[elogind.git] / src / shared / path-lookup.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 <assert.h>
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <errno.h>
28
29 #include "util.h"
30 #include "mkdir.h"
31 #include "strv.h"
32 #include "path-util.h"
33 #include "path-lookup.h"
34
35 static const char* const systemd_running_as_table[_SYSTEMD_RUNNING_AS_MAX] = {
36         [SYSTEMD_SYSTEM] = "system",
37         [SYSTEMD_USER] = "user"
38 };
39
40 DEFINE_STRING_TABLE_LOOKUP(systemd_running_as, SystemdRunningAs);
41
42 int user_config_home(char **config_home) {
43         const char *e;
44         char *r;
45
46         e = getenv("XDG_CONFIG_HOME");
47         if (e) {
48                 r = strappend(e, "/systemd/user");
49                 if (!r)
50                         return -ENOMEM;
51
52                 *config_home = r;
53                 return 1;
54         } else {
55                 const char *home;
56
57                 home = getenv("HOME");
58                 if (home) {
59                         r = strappend(home, "/.config/systemd/user");
60                         if (!r)
61                                 return -ENOMEM;
62
63                         *config_home = r;
64                         return 1;
65                 }
66         }
67
68         return 0;
69 }
70
71 static char** user_dirs(
72                 const char *generator,
73                 const char *generator_early,
74                 const char *generator_late) {
75
76         const char * const config_unit_paths[] = {
77                 USER_CONFIG_UNIT_PATH,
78                 "/etc/systemd/user",
79                 "/run/systemd/user",
80                 NULL
81         };
82
83         const char * const data_unit_paths[] = {
84                 "/usr/local/lib/systemd/user",
85                 "/usr/local/share/systemd/user",
86                 USER_DATA_UNIT_PATH,
87                 "/usr/lib/systemd/user",
88                 "/usr/share/systemd/user",
89                 NULL
90         };
91
92         const char *home, *e;
93         char *config_home = NULL, *data_home = NULL;
94         char **config_dirs = NULL, **data_dirs = NULL;
95         char **r = NULL, **t;
96
97         /* Implement the mechanisms defined in
98          *
99          * http://standards.freedesktop.org/basedir-spec/basedir-spec-0.6.html
100          *
101          * We look in both the config and the data dirs because we
102          * want to encourage that distributors ship their unit files
103          * as data, and allow overriding as configuration.
104          */
105
106         if (user_config_home(&config_home) < 0)
107                 goto fail;
108
109         home = getenv("HOME");
110
111         e = getenv("XDG_CONFIG_DIRS");
112         if (e) {
113                 config_dirs = strv_split(e, ":");
114                 if (!config_dirs)
115                         goto fail;
116         }
117
118         /* We don't treat /etc/xdg/systemd here as the spec
119          * suggests because we assume that that is a link to
120          * /etc/systemd/ anyway. */
121
122         e = getenv("XDG_DATA_HOME");
123         if (e) {
124                 if (asprintf(&data_home, "%s/systemd/user", e) < 0)
125                         goto fail;
126
127         } else if (home) {
128                 if (asprintf(&data_home, "%s/.local/share/systemd/user", home) < 0)
129                         goto fail;
130
131                 /* There is really no need for two unit dirs in $HOME,
132                  * except to be fully compliant with the XDG spec. We
133                  * now try to link the two dirs, so that we can
134                  * minimize disk seeks a little. Further down we'll
135                  * then filter out this link, if it is actually is
136                  * one. */
137
138                 mkdir_parents_label(data_home, 0777);
139                 (void) symlink("../../../.config/systemd/user", data_home);
140         }
141
142         e = getenv("XDG_DATA_DIRS");
143         if (e)
144                 data_dirs = strv_split(e, ":");
145         else
146                 data_dirs = strv_new("/usr/local/share",
147                                      "/usr/share",
148                                      NULL);
149         if (!data_dirs)
150                 goto fail;
151
152         /* Now merge everything we found. */
153         if (generator_early) {
154                 t = strv_append(r, generator_early);
155                 if (!t)
156                         goto fail;
157                 strv_free(r);
158                 r = t;
159         }
160
161         if (config_home) {
162                 t = strv_append(r, config_home);
163                 if (!t)
164                         goto fail;
165                 strv_free(r);
166                 r = t;
167         }
168
169         if (!strv_isempty(config_dirs)) {
170                 t = strv_merge_concat(r, config_dirs, "/systemd/user");
171                 if (!t)
172                         goto finish;
173                 strv_free(r);
174                 r = t;
175         }
176
177         t = strv_merge(r, (char**) config_unit_paths);
178         if (!t)
179                 goto fail;
180         strv_free(r);
181         r = t;
182
183         if (generator) {
184                 t = strv_append(r, generator);
185                 if (!t)
186                         goto fail;
187                 strv_free(r);
188                 r = t;
189         }
190
191         if (data_home) {
192                 t = strv_append(r, data_home);
193                 if (!t)
194                         goto fail;
195                 strv_free(r);
196                 r = t;
197         }
198
199         if (!strv_isempty(data_dirs)) {
200                 t = strv_merge_concat(r, data_dirs, "/systemd/user");
201                 if (!t)
202                         goto fail;
203                 strv_free(r);
204                 r = t;
205         }
206
207         t = strv_merge(r, (char**) data_unit_paths);
208         if (!t)
209                 goto fail;
210         strv_free(r);
211         r = t;
212
213         if (generator_late) {
214                 t = strv_append(r, generator_late);
215                 if (!t)
216                         goto fail;
217                 strv_free(r);
218                 r = t;
219         }
220
221         if (!path_strv_make_absolute_cwd(r))
222                 goto fail;
223
224 finish:
225         free(config_home);
226         strv_free(config_dirs);
227         free(data_home);
228         strv_free(data_dirs);
229
230         return r;
231
232 fail:
233         strv_free(r);
234         r = NULL;
235         goto finish;
236 }
237
238 int lookup_paths_init(
239                 LookupPaths *p,
240                 SystemdRunningAs running_as,
241                 bool personal,
242                 const char *generator,
243                 const char *generator_early,
244                 const char *generator_late) {
245
246         const char *e;
247
248         assert(p);
249
250         /* First priority is whatever has been passed to us via env
251          * vars */
252         e = getenv("SYSTEMD_UNIT_PATH");
253         if (e) {
254                 p->unit_path = path_split_and_make_absolute(e);
255                 if (!p->unit_path)
256                         return -ENOMEM;
257         } else
258                 p->unit_path = NULL;
259
260         if (strv_isempty(p->unit_path)) {
261                 /* Nothing is set, so let's figure something out. */
262                 strv_free(p->unit_path);
263
264                 /* For the user units we include share/ in the search
265                  * path in order to comply with the XDG basedir
266                  * spec. For the system stuff we avoid such
267                  * nonsense. OTOH we include /lib in the search path
268                  * for the system stuff but avoid it for user
269                  * stuff. */
270
271                 if (running_as == SYSTEMD_USER) {
272
273                         if (personal)
274                                 p->unit_path = user_dirs(generator, generator_early, generator_late);
275                         else
276                                 p->unit_path = strv_new(
277                                                 /* If you modify this you also want to modify
278                                                  * systemduserunitpath= in systemd.pc.in, and
279                                                  * the arrays in user_dirs() above! */
280                                                 STRV_IFNOTNULL(generator_early),
281                                                 USER_CONFIG_UNIT_PATH,
282                                                 "/etc/systemd/user",
283                                                 "/run/systemd/user",
284                                                 STRV_IFNOTNULL(generator),
285                                                 "/usr/local/lib/systemd/user",
286                                                 "/usr/local/share/systemd/user",
287                                                 USER_DATA_UNIT_PATH,
288                                                 "/usr/lib/systemd/user",
289                                                 "/usr/share/systemd/user",
290                                                 STRV_IFNOTNULL(generator_late),
291                                                 NULL);
292
293                         if (!p->unit_path)
294                                 return -ENOMEM;
295
296                 } else {
297                         p->unit_path = strv_new(
298                                         /* If you modify this you also want to modify
299                                          * systemdsystemunitpath= in systemd.pc.in! */
300                                         STRV_IFNOTNULL(generator_early),
301                                         SYSTEM_CONFIG_UNIT_PATH,
302                                         "/etc/systemd/system",
303                                         "/run/systemd/system",
304                                         STRV_IFNOTNULL(generator),
305                                         "/usr/local/lib/systemd/system",
306                                         SYSTEM_DATA_UNIT_PATH,
307                                         "/usr/lib/systemd/system",
308 #ifdef HAVE_SPLIT_USR
309                                         "/lib/systemd/system",
310 #endif
311                                         STRV_IFNOTNULL(generator_late),
312                                         NULL);
313
314                         if (!p->unit_path)
315                                 return -ENOMEM;
316                 }
317         }
318
319         if (!path_strv_canonicalize(p->unit_path))
320                 return -ENOMEM;
321
322         strv_uniq(p->unit_path);
323
324         if (!strv_isempty(p->unit_path)) {
325                 _cleanup_free_ char *t = strv_join(p->unit_path, "\n\t");
326                 if (!t)
327                         return -ENOMEM;
328                 log_debug("Looking for unit files in (higher priority first):\n\t%s", t);
329         } else {
330                 log_debug("Ignoring unit files.");
331                 strv_free(p->unit_path);
332                 p->unit_path = NULL;
333         }
334
335         if (running_as == SYSTEMD_SYSTEM) {
336 #ifdef HAVE_SYSV_COMPAT
337                 /* /etc/init.d/ compatibility does not matter to users */
338
339                 e = getenv("SYSTEMD_SYSVINIT_PATH");
340                 if (e) {
341                         p->sysvinit_path = path_split_and_make_absolute(e);
342                         if (!p->sysvinit_path)
343                                 return -ENOMEM;
344                 } else
345                         p->sysvinit_path = NULL;
346
347                 if (strv_isempty(p->sysvinit_path)) {
348                         strv_free(p->sysvinit_path);
349
350                         p->sysvinit_path = strv_new(
351                                         SYSTEM_SYSVINIT_PATH,     /* /etc/init.d/ */
352                                         NULL);
353                         if (!p->sysvinit_path)
354                                 return -ENOMEM;
355                 }
356
357                 e = getenv("SYSTEMD_SYSVRCND_PATH");
358                 if (e) {
359                         p->sysvrcnd_path = path_split_and_make_absolute(e);
360                         if (!p->sysvrcnd_path)
361                                 return -ENOMEM;
362                 } else
363                         p->sysvrcnd_path = NULL;
364
365                 if (strv_isempty(p->sysvrcnd_path)) {
366                         strv_free(p->sysvrcnd_path);
367
368                         p->sysvrcnd_path = strv_new(
369                                         SYSTEM_SYSVRCND_PATH,     /* /etc/rcN.d/ */
370                                         NULL);
371                         if (!p->sysvrcnd_path)
372                                 return -ENOMEM;
373                 }
374
375                 if (!path_strv_canonicalize(p->sysvinit_path))
376                         return -ENOMEM;
377
378                 if (!path_strv_canonicalize(p->sysvrcnd_path))
379                         return -ENOMEM;
380
381                 strv_uniq(p->sysvinit_path);
382                 strv_uniq(p->sysvrcnd_path);
383
384                 if (!strv_isempty(p->sysvinit_path)) {
385                         _cleanup_free_ char *t = strv_join(p->sysvinit_path, "\n\t");
386                         if (!t)
387                                 return -ENOMEM;
388                         log_debug("Looking for SysV init scripts in:\n\t%s", t);
389                 } else {
390                         log_debug("Ignoring SysV init scripts.");
391                         strv_free(p->sysvinit_path);
392                         p->sysvinit_path = NULL;
393                 }
394
395                 if (!strv_isempty(p->sysvrcnd_path)) {
396                         _cleanup_free_ char *t =
397                                 strv_join(p->sysvrcnd_path, "\n\t");
398                         if (!t)
399                                 return -ENOMEM;
400
401                         log_debug("Looking for SysV rcN.d links in:\n\t%s", t);
402                 } else {
403                         log_debug("Ignoring SysV rcN.d links.");
404                         strv_free(p->sysvrcnd_path);
405                         p->sysvrcnd_path = NULL;
406                 }
407 #else
408                 log_debug("SysV init scripts and rcN.d links support disabled");
409 #endif
410         }
411
412         return 0;
413 }
414
415 void lookup_paths_free(LookupPaths *p) {
416         assert(p);
417
418         strv_free(p->unit_path);
419         p->unit_path = NULL;
420
421 #ifdef HAVE_SYSV_COMPAT
422         strv_free(p->sysvinit_path);
423         strv_free(p->sysvrcnd_path);
424         p->sysvinit_path = p->sysvrcnd_path = NULL;
425 #endif
426 }