chiark / gitweb /
util: when joining a namespace make sure to reset all uids to 0 after
[elogind.git] / src / shared / util.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 <string.h>
24 #include <unistd.h>
25 #include <errno.h>
26 #include <stdlib.h>
27 #include <signal.h>
28 #include <stdio.h>
29 #include <syslog.h>
30 #include <sched.h>
31 #include <sys/resource.h>
32 #include <linux/sched.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <fcntl.h>
36 #include <dirent.h>
37 #include <sys/ioctl.h>
38 #include <linux/vt.h>
39 #include <linux/tiocl.h>
40 #include <termios.h>
41 #include <stdarg.h>
42 #include <sys/inotify.h>
43 #include <sys/poll.h>
44 #include <ctype.h>
45 #include <sys/prctl.h>
46 #include <sys/utsname.h>
47 #include <pwd.h>
48 #include <netinet/ip.h>
49 #include <linux/kd.h>
50 #include <dlfcn.h>
51 #include <sys/wait.h>
52 #include <sys/time.h>
53 #include <glob.h>
54 #include <grp.h>
55 #include <sys/mman.h>
56 #include <sys/vfs.h>
57 #include <linux/magic.h>
58 #include <limits.h>
59 #include <langinfo.h>
60 #include <locale.h>
61 #include <libgen.h>
62 #undef basename
63
64 #include "macro.h"
65 #include "util.h"
66 #include "ioprio.h"
67 #include "missing.h"
68 #include "log.h"
69 #include "strv.h"
70 #include "label.h"
71 #include "path-util.h"
72 #include "exit-status.h"
73 #include "hashmap.h"
74 #include "env-util.h"
75 #include "fileio.h"
76 #include "device-nodes.h"
77 #include "utf8.h"
78 #include "gunicode.h"
79 #include "virt.h"
80 #include "def.h"
81
82 int saved_argc = 0;
83 char **saved_argv = NULL;
84
85 static volatile unsigned cached_columns = 0;
86 static volatile unsigned cached_lines = 0;
87
88 size_t page_size(void) {
89         static __thread size_t pgsz = 0;
90         long r;
91
92         if (_likely_(pgsz > 0))
93                 return pgsz;
94
95         r = sysconf(_SC_PAGESIZE);
96         assert(r > 0);
97
98         pgsz = (size_t) r;
99         return pgsz;
100 }
101
102 bool streq_ptr(const char *a, const char *b) {
103
104         /* Like streq(), but tries to make sense of NULL pointers */
105
106         if (a && b)
107                 return streq(a, b);
108
109         if (!a && !b)
110                 return true;
111
112         return false;
113 }
114
115 char* endswith(const char *s, const char *postfix) {
116         size_t sl, pl;
117
118         assert(s);
119         assert(postfix);
120
121         sl = strlen(s);
122         pl = strlen(postfix);
123
124         if (pl == 0)
125                 return (char*) s + sl;
126
127         if (sl < pl)
128                 return NULL;
129
130         if (memcmp(s + sl - pl, postfix, pl) != 0)
131                 return NULL;
132
133         return (char*) s + sl - pl;
134 }
135
136 bool first_word(const char *s, const char *word) {
137         size_t sl, wl;
138
139         assert(s);
140         assert(word);
141
142         sl = strlen(s);
143         wl = strlen(word);
144
145         if (sl < wl)
146                 return false;
147
148         if (wl == 0)
149                 return true;
150
151         if (memcmp(s, word, wl) != 0)
152                 return false;
153
154         return s[wl] == 0 ||
155                 strchr(WHITESPACE, s[wl]);
156 }
157
158 int close_nointr(int fd) {
159         int r;
160
161         assert(fd >= 0);
162         r = close(fd);
163
164         /* Just ignore EINTR; a retry loop is the wrong
165          * thing to do on Linux.
166          *
167          * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
168          * https://bugzilla.gnome.org/show_bug.cgi?id=682819
169          * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
170          * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
171          */
172         if (_unlikely_(r < 0 && errno == EINTR))
173                 return 0;
174         else if (r >= 0)
175                 return r;
176         else
177                 return -errno;
178 }
179
180 void close_nointr_nofail(int fd) {
181         PROTECT_ERRNO;
182
183         /* like close_nointr() but cannot fail, and guarantees errno
184          * is unchanged */
185
186         assert_se(close_nointr(fd) == 0);
187 }
188
189 void close_many(const int fds[], unsigned n_fd) {
190         unsigned i;
191
192         assert(fds || n_fd <= 0);
193
194         for (i = 0; i < n_fd; i++)
195                 close_nointr_nofail(fds[i]);
196 }
197
198 int unlink_noerrno(const char *path) {
199         PROTECT_ERRNO;
200         int r;
201
202         r = unlink(path);
203         if (r < 0)
204                 return -errno;
205
206         return 0;
207 }
208
209 int parse_boolean(const char *v) {
210         assert(v);
211
212         if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || strcaseeq(v, "on"))
213                 return 1;
214         else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || strcaseeq(v, "off"))
215                 return 0;
216
217         return -EINVAL;
218 }
219
220 int parse_pid(const char *s, pid_t* ret_pid) {
221         unsigned long ul = 0;
222         pid_t pid;
223         int r;
224
225         assert(s);
226         assert(ret_pid);
227
228         r = safe_atolu(s, &ul);
229         if (r < 0)
230                 return r;
231
232         pid = (pid_t) ul;
233
234         if ((unsigned long) pid != ul)
235                 return -ERANGE;
236
237         if (pid <= 0)
238                 return -ERANGE;
239
240         *ret_pid = pid;
241         return 0;
242 }
243
244 int parse_uid(const char *s, uid_t* ret_uid) {
245         unsigned long ul = 0;
246         uid_t uid;
247         int r;
248
249         assert(s);
250         assert(ret_uid);
251
252         r = safe_atolu(s, &ul);
253         if (r < 0)
254                 return r;
255
256         uid = (uid_t) ul;
257
258         if ((unsigned long) uid != ul)
259                 return -ERANGE;
260
261         *ret_uid = uid;
262         return 0;
263 }
264
265 int safe_atou(const char *s, unsigned *ret_u) {
266         char *x = NULL;
267         unsigned long l;
268
269         assert(s);
270         assert(ret_u);
271
272         errno = 0;
273         l = strtoul(s, &x, 0);
274
275         if (!x || x == s || *x || errno)
276                 return errno > 0 ? -errno : -EINVAL;
277
278         if ((unsigned long) (unsigned) l != l)
279                 return -ERANGE;
280
281         *ret_u = (unsigned) l;
282         return 0;
283 }
284
285 int safe_atoi(const char *s, int *ret_i) {
286         char *x = NULL;
287         long l;
288
289         assert(s);
290         assert(ret_i);
291
292         errno = 0;
293         l = strtol(s, &x, 0);
294
295         if (!x || x == s || *x || errno)
296                 return errno > 0 ? -errno : -EINVAL;
297
298         if ((long) (int) l != l)
299                 return -ERANGE;
300
301         *ret_i = (int) l;
302         return 0;
303 }
304
305 int safe_atollu(const char *s, long long unsigned *ret_llu) {
306         char *x = NULL;
307         unsigned long long l;
308
309         assert(s);
310         assert(ret_llu);
311
312         errno = 0;
313         l = strtoull(s, &x, 0);
314
315         if (!x || x == s || *x || errno)
316                 return errno ? -errno : -EINVAL;
317
318         *ret_llu = l;
319         return 0;
320 }
321
322 int safe_atolli(const char *s, long long int *ret_lli) {
323         char *x = NULL;
324         long long l;
325
326         assert(s);
327         assert(ret_lli);
328
329         errno = 0;
330         l = strtoll(s, &x, 0);
331
332         if (!x || x == s || *x || errno)
333                 return errno ? -errno : -EINVAL;
334
335         *ret_lli = l;
336         return 0;
337 }
338
339 int safe_atod(const char *s, double *ret_d) {
340         char *x = NULL;
341         double d = 0;
342
343         assert(s);
344         assert(ret_d);
345
346         RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
347                 errno = 0;
348                 d = strtod(s, &x);
349         }
350
351         if (!x || x == s || *x || errno)
352                 return errno ? -errno : -EINVAL;
353
354         *ret_d = (double) d;
355         return 0;
356 }
357
358 /* Split a string into words. */
359 char *split(const char *c, size_t *l, const char *separator, char **state) {
360         char *current;
361
362         current = *state ? *state : (char*) c;
363
364         if (!*current || *c == 0)
365                 return NULL;
366
367         current += strspn(current, separator);
368         *l = strcspn(current, separator);
369         *state = current+*l;
370
371         return (char*) current;
372 }
373
374 /* Split a string into words, but consider strings enclosed in '' and
375  * "" as words even if they include spaces. */
376 char *split_quoted(const char *c, size_t *l, char **state) {
377         const char *current, *e;
378         bool escaped = false;
379
380         assert(c);
381         assert(l);
382         assert(state);
383
384         current = *state ? *state : c;
385
386         current += strspn(current, WHITESPACE);
387
388         if (*current == 0)
389                 return NULL;
390
391         else if (*current == '\'') {
392                 current ++;
393
394                 for (e = current; *e; e++) {
395                         if (escaped)
396                                 escaped = false;
397                         else if (*e == '\\')
398                                 escaped = true;
399                         else if (*e == '\'')
400                                 break;
401                 }
402
403                 *l = e-current;
404                 *state = (char*) (*e == 0 ? e : e+1);
405
406         } else if (*current == '\"') {
407                 current ++;
408
409                 for (e = current; *e; e++) {
410                         if (escaped)
411                                 escaped = false;
412                         else if (*e == '\\')
413                                 escaped = true;
414                         else if (*e == '\"')
415                                 break;
416                 }
417
418                 *l = e-current;
419                 *state = (char*) (*e == 0 ? e : e+1);
420
421         } else {
422                 for (e = current; *e; e++) {
423                         if (escaped)
424                                 escaped = false;
425                         else if (*e == '\\')
426                                 escaped = true;
427                         else if (strchr(WHITESPACE, *e))
428                                 break;
429                 }
430                 *l = e-current;
431                 *state = (char*) e;
432         }
433
434         return (char*) current;
435 }
436
437 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
438         int r;
439         _cleanup_fclose_ FILE *f = NULL;
440         char line[LINE_MAX];
441         long unsigned ppid;
442         const char *p;
443
444         assert(pid >= 0);
445         assert(_ppid);
446
447         if (pid == 0) {
448                 *_ppid = getppid();
449                 return 0;
450         }
451
452         p = procfs_file_alloca(pid, "stat");
453         f = fopen(p, "re");
454         if (!f)
455                 return -errno;
456
457         if (!fgets(line, sizeof(line), f)) {
458                 r = feof(f) ? -EIO : -errno;
459                 return r;
460         }
461
462         /* Let's skip the pid and comm fields. The latter is enclosed
463          * in () but does not escape any () in its value, so let's
464          * skip over it manually */
465
466         p = strrchr(line, ')');
467         if (!p)
468                 return -EIO;
469
470         p++;
471
472         if (sscanf(p, " "
473                    "%*c "  /* state */
474                    "%lu ", /* ppid */
475                    &ppid) != 1)
476                 return -EIO;
477
478         if ((long unsigned) (pid_t) ppid != ppid)
479                 return -ERANGE;
480
481         *_ppid = (pid_t) ppid;
482
483         return 0;
484 }
485
486 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
487         _cleanup_fclose_ FILE *f = NULL;
488         char line[LINE_MAX];
489         const char *p;
490
491         assert(pid >= 0);
492         assert(st);
493
494         if (pid == 0)
495                 p = "/proc/self/stat";
496         else
497                 p = procfs_file_alloca(pid, "stat");
498
499         f = fopen(p, "re");
500         if (!f)
501                 return errno == ENOENT ? -ESRCH : -errno;
502
503         if (!fgets(line, sizeof(line), f)) {
504                 if (ferror(f))
505                         return -errno;
506
507                 return -EIO;
508         }
509
510         /* Let's skip the pid and comm fields. The latter is enclosed
511          * in () but does not escape any () in its value, so let's
512          * skip over it manually */
513
514         p = strrchr(line, ')');
515         if (!p)
516                 return -EIO;
517
518         p++;
519
520         if (sscanf(p, " "
521                    "%*c "  /* state */
522                    "%*d "  /* ppid */
523                    "%*d "  /* pgrp */
524                    "%*d "  /* session */
525                    "%*d "  /* tty_nr */
526                    "%*d "  /* tpgid */
527                    "%*u "  /* flags */
528                    "%*u "  /* minflt */
529                    "%*u "  /* cminflt */
530                    "%*u "  /* majflt */
531                    "%*u "  /* cmajflt */
532                    "%*u "  /* utime */
533                    "%*u "  /* stime */
534                    "%*d "  /* cutime */
535                    "%*d "  /* cstime */
536                    "%*d "  /* priority */
537                    "%*d "  /* nice */
538                    "%*d "  /* num_threads */
539                    "%*d "  /* itrealvalue */
540                    "%llu "  /* starttime */,
541                    st) != 1)
542                 return -EIO;
543
544         return 0;
545 }
546
547 int fchmod_umask(int fd, mode_t m) {
548         mode_t u;
549         int r;
550
551         u = umask(0777);
552         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
553         umask(u);
554
555         return r;
556 }
557
558 char *truncate_nl(char *s) {
559         assert(s);
560
561         s[strcspn(s, NEWLINE)] = 0;
562         return s;
563 }
564
565 int get_process_comm(pid_t pid, char **name) {
566         const char *p;
567         int r;
568
569         assert(name);
570         assert(pid >= 0);
571
572         if (pid == 0)
573                 p = "/proc/self/comm";
574         else
575                 p = procfs_file_alloca(pid, "comm");
576
577         r = read_one_line_file(p, name);
578         if (r == -ENOENT)
579                 return -ESRCH;
580
581         return r;
582 }
583
584 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
585         _cleanup_fclose_ FILE *f = NULL;
586         char *r = NULL, *k;
587         const char *p;
588         int c;
589
590         assert(line);
591         assert(pid >= 0);
592
593         if (pid == 0)
594                 p = "/proc/self/cmdline";
595         else
596                 p = procfs_file_alloca(pid, "cmdline");
597
598         f = fopen(p, "re");
599         if (!f)
600                 return -errno;
601
602         if (max_length == 0) {
603                 size_t len = 0, allocated = 0;
604
605                 while ((c = getc(f)) != EOF) {
606
607                         if (!GREEDY_REALLOC(r, allocated, len+2)) {
608                                 free(r);
609                                 return -ENOMEM;
610                         }
611
612                         r[len++] = isprint(c) ? c : ' ';
613                 }
614
615                 if (len > 0)
616                         r[len-1] = 0;
617
618         } else {
619                 bool space = false;
620                 size_t left;
621
622                 r = new(char, max_length);
623                 if (!r)
624                         return -ENOMEM;
625
626                 k = r;
627                 left = max_length;
628                 while ((c = getc(f)) != EOF) {
629
630                         if (isprint(c)) {
631                                 if (space) {
632                                         if (left <= 4)
633                                                 break;
634
635                                         *(k++) = ' ';
636                                         left--;
637                                         space = false;
638                                 }
639
640                                 if (left <= 4)
641                                         break;
642
643                                 *(k++) = (char) c;
644                                 left--;
645                         }  else
646                                 space = true;
647                 }
648
649                 if (left <= 4) {
650                         size_t n = MIN(left-1, 3U);
651                         memcpy(k, "...", n);
652                         k[n] = 0;
653                 } else
654                         *k = 0;
655         }
656
657         /* Kernel threads have no argv[] */
658         if (r == NULL || r[0] == 0) {
659                 _cleanup_free_ char *t = NULL;
660                 int h;
661
662                 free(r);
663
664                 if (!comm_fallback)
665                         return -ENOENT;
666
667                 h = get_process_comm(pid, &t);
668                 if (h < 0)
669                         return h;
670
671                 r = strjoin("[", t, "]", NULL);
672                 if (!r)
673                         return -ENOMEM;
674         }
675
676         *line = r;
677         return 0;
678 }
679
680 int is_kernel_thread(pid_t pid) {
681         const char *p;
682         size_t count;
683         char c;
684         bool eof;
685         FILE *f;
686
687         if (pid == 0)
688                 return 0;
689
690         assert(pid > 0);
691
692         p = procfs_file_alloca(pid, "cmdline");
693         f = fopen(p, "re");
694         if (!f)
695                 return -errno;
696
697         count = fread(&c, 1, 1, f);
698         eof = feof(f);
699         fclose(f);
700
701         /* Kernel threads have an empty cmdline */
702
703         if (count <= 0)
704                 return eof ? 1 : -errno;
705
706         return 0;
707 }
708
709 int get_process_capeff(pid_t pid, char **capeff) {
710         const char *p;
711
712         assert(capeff);
713         assert(pid >= 0);
714
715         if (pid == 0)
716                 p = "/proc/self/status";
717         else
718                 p = procfs_file_alloca(pid, "status");
719
720         return get_status_field(p, "\nCapEff:", capeff);
721 }
722
723 int get_process_exe(pid_t pid, char **name) {
724         const char *p;
725         char *d;
726         int r;
727
728         assert(pid >= 0);
729         assert(name);
730
731         if (pid == 0)
732                 p = "/proc/self/exe";
733         else
734                 p = procfs_file_alloca(pid, "exe");
735
736         r = readlink_malloc(p, name);
737         if (r < 0)
738                 return r == -ENOENT ? -ESRCH : r;
739
740         d = endswith(*name, " (deleted)");
741         if (d)
742                 *d = '\0';
743
744         return 0;
745 }
746
747 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
748         _cleanup_fclose_ FILE *f = NULL;
749         char line[LINE_MAX];
750         const char *p;
751
752         assert(field);
753         assert(uid);
754
755         if (pid == 0)
756                 return getuid();
757
758         p = procfs_file_alloca(pid, "status");
759         f = fopen(p, "re");
760         if (!f)
761                 return -errno;
762
763         FOREACH_LINE(line, f, return -errno) {
764                 char *l;
765
766                 l = strstrip(line);
767
768                 if (startswith(l, field)) {
769                         l += strlen(field);
770                         l += strspn(l, WHITESPACE);
771
772                         l[strcspn(l, WHITESPACE)] = 0;
773
774                         return parse_uid(l, uid);
775                 }
776         }
777
778         return -EIO;
779 }
780
781 int get_process_uid(pid_t pid, uid_t *uid) {
782         return get_process_id(pid, "Uid:", uid);
783 }
784
785 int get_process_gid(pid_t pid, gid_t *gid) {
786         assert_cc(sizeof(uid_t) == sizeof(gid_t));
787         return get_process_id(pid, "Gid:", gid);
788 }
789
790 char *strnappend(const char *s, const char *suffix, size_t b) {
791         size_t a;
792         char *r;
793
794         if (!s && !suffix)
795                 return strdup("");
796
797         if (!s)
798                 return strndup(suffix, b);
799
800         if (!suffix)
801                 return strdup(s);
802
803         assert(s);
804         assert(suffix);
805
806         a = strlen(s);
807         if (b > ((size_t) -1) - a)
808                 return NULL;
809
810         r = new(char, a+b+1);
811         if (!r)
812                 return NULL;
813
814         memcpy(r, s, a);
815         memcpy(r+a, suffix, b);
816         r[a+b] = 0;
817
818         return r;
819 }
820
821 char *strappend(const char *s, const char *suffix) {
822         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
823 }
824
825 int readlink_malloc(const char *p, char **r) {
826         size_t l = 100;
827
828         assert(p);
829         assert(r);
830
831         for (;;) {
832                 char *c;
833                 ssize_t n;
834
835                 if (!(c = new(char, l)))
836                         return -ENOMEM;
837
838                 if ((n = readlink(p, c, l-1)) < 0) {
839                         int ret = -errno;
840                         free(c);
841                         return ret;
842                 }
843
844                 if ((size_t) n < l-1) {
845                         c[n] = 0;
846                         *r = c;
847                         return 0;
848                 }
849
850                 free(c);
851                 l *= 2;
852         }
853 }
854
855 int readlink_and_make_absolute(const char *p, char **r) {
856         _cleanup_free_ char *target = NULL;
857         char *k;
858         int j;
859
860         assert(p);
861         assert(r);
862
863         j = readlink_malloc(p, &target);
864         if (j < 0)
865                 return j;
866
867         k = file_in_same_dir(p, target);
868         if (!k)
869                 return -ENOMEM;
870
871         *r = k;
872         return 0;
873 }
874
875 int readlink_and_canonicalize(const char *p, char **r) {
876         char *t, *s;
877         int j;
878
879         assert(p);
880         assert(r);
881
882         j = readlink_and_make_absolute(p, &t);
883         if (j < 0)
884                 return j;
885
886         s = canonicalize_file_name(t);
887         if (s) {
888                 free(t);
889                 *r = s;
890         } else
891                 *r = t;
892
893         path_kill_slashes(*r);
894
895         return 0;
896 }
897
898 int reset_all_signal_handlers(void) {
899         int sig;
900
901         for (sig = 1; sig < _NSIG; sig++) {
902                 struct sigaction sa = {
903                         .sa_handler = SIG_DFL,
904                         .sa_flags = SA_RESTART,
905                 };
906
907                 if (sig == SIGKILL || sig == SIGSTOP)
908                         continue;
909
910                 /* On Linux the first two RT signals are reserved by
911                  * glibc, and sigaction() will return EINVAL for them. */
912                 if ((sigaction(sig, &sa, NULL) < 0))
913                         if (errno != EINVAL)
914                                 return -errno;
915         }
916
917         return 0;
918 }
919
920 char *strstrip(char *s) {
921         char *e;
922
923         /* Drops trailing whitespace. Modifies the string in
924          * place. Returns pointer to first non-space character */
925
926         s += strspn(s, WHITESPACE);
927
928         for (e = strchr(s, 0); e > s; e --)
929                 if (!strchr(WHITESPACE, e[-1]))
930                         break;
931
932         *e = 0;
933
934         return s;
935 }
936
937 char *delete_chars(char *s, const char *bad) {
938         char *f, *t;
939
940         /* Drops all whitespace, regardless where in the string */
941
942         for (f = s, t = s; *f; f++) {
943                 if (strchr(bad, *f))
944                         continue;
945
946                 *(t++) = *f;
947         }
948
949         *t = 0;
950
951         return s;
952 }
953
954 bool in_charset(const char *s, const char* charset) {
955         const char *i;
956
957         assert(s);
958         assert(charset);
959
960         for (i = s; *i; i++)
961                 if (!strchr(charset, *i))
962                         return false;
963
964         return true;
965 }
966
967 char *file_in_same_dir(const char *path, const char *filename) {
968         char *e, *r;
969         size_t k;
970
971         assert(path);
972         assert(filename);
973
974         /* This removes the last component of path and appends
975          * filename, unless the latter is absolute anyway or the
976          * former isn't */
977
978         if (path_is_absolute(filename))
979                 return strdup(filename);
980
981         if (!(e = strrchr(path, '/')))
982                 return strdup(filename);
983
984         k = strlen(filename);
985         if (!(r = new(char, e-path+1+k+1)))
986                 return NULL;
987
988         memcpy(r, path, e-path+1);
989         memcpy(r+(e-path)+1, filename, k+1);
990
991         return r;
992 }
993
994 int rmdir_parents(const char *path, const char *stop) {
995         size_t l;
996         int r = 0;
997
998         assert(path);
999         assert(stop);
1000
1001         l = strlen(path);
1002
1003         /* Skip trailing slashes */
1004         while (l > 0 && path[l-1] == '/')
1005                 l--;
1006
1007         while (l > 0) {
1008                 char *t;
1009
1010                 /* Skip last component */
1011                 while (l > 0 && path[l-1] != '/')
1012                         l--;
1013
1014                 /* Skip trailing slashes */
1015                 while (l > 0 && path[l-1] == '/')
1016                         l--;
1017
1018                 if (l <= 0)
1019                         break;
1020
1021                 if (!(t = strndup(path, l)))
1022                         return -ENOMEM;
1023
1024                 if (path_startswith(stop, t)) {
1025                         free(t);
1026                         return 0;
1027                 }
1028
1029                 r = rmdir(t);
1030                 free(t);
1031
1032                 if (r < 0)
1033                         if (errno != ENOENT)
1034                                 return -errno;
1035         }
1036
1037         return 0;
1038 }
1039
1040 char hexchar(int x) {
1041         static const char table[16] = "0123456789abcdef";
1042
1043         return table[x & 15];
1044 }
1045
1046 int unhexchar(char c) {
1047
1048         if (c >= '0' && c <= '9')
1049                 return c - '0';
1050
1051         if (c >= 'a' && c <= 'f')
1052                 return c - 'a' + 10;
1053
1054         if (c >= 'A' && c <= 'F')
1055                 return c - 'A' + 10;
1056
1057         return -1;
1058 }
1059
1060 char *hexmem(const void *p, size_t l) {
1061         char *r, *z;
1062         const uint8_t *x;
1063
1064         z = r = malloc(l * 2 + 1);
1065         if (!r)
1066                 return NULL;
1067
1068         for (x = p; x < (const uint8_t*) p + l; x++) {
1069                 *(z++) = hexchar(*x >> 4);
1070                 *(z++) = hexchar(*x & 15);
1071         }
1072
1073         *z = 0;
1074         return r;
1075 }
1076
1077 void *unhexmem(const char *p, size_t l) {
1078         uint8_t *r, *z;
1079         const char *x;
1080
1081         assert(p);
1082
1083         z = r = malloc((l + 1) / 2 + 1);
1084         if (!r)
1085                 return NULL;
1086
1087         for (x = p; x < p + l; x += 2) {
1088                 int a, b;
1089
1090                 a = unhexchar(x[0]);
1091                 if (x+1 < p + l)
1092                         b = unhexchar(x[1]);
1093                 else
1094                         b = 0;
1095
1096                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1097         }
1098
1099         *z = 0;
1100         return r;
1101 }
1102
1103 char octchar(int x) {
1104         return '0' + (x & 7);
1105 }
1106
1107 int unoctchar(char c) {
1108
1109         if (c >= '0' && c <= '7')
1110                 return c - '0';
1111
1112         return -1;
1113 }
1114
1115 char decchar(int x) {
1116         return '0' + (x % 10);
1117 }
1118
1119 int undecchar(char c) {
1120
1121         if (c >= '0' && c <= '9')
1122                 return c - '0';
1123
1124         return -1;
1125 }
1126
1127 char *cescape(const char *s) {
1128         char *r, *t;
1129         const char *f;
1130
1131         assert(s);
1132
1133         /* Does C style string escaping. */
1134
1135         r = new(char, strlen(s)*4 + 1);
1136         if (!r)
1137                 return NULL;
1138
1139         for (f = s, t = r; *f; f++)
1140
1141                 switch (*f) {
1142
1143                 case '\a':
1144                         *(t++) = '\\';
1145                         *(t++) = 'a';
1146                         break;
1147                 case '\b':
1148                         *(t++) = '\\';
1149                         *(t++) = 'b';
1150                         break;
1151                 case '\f':
1152                         *(t++) = '\\';
1153                         *(t++) = 'f';
1154                         break;
1155                 case '\n':
1156                         *(t++) = '\\';
1157                         *(t++) = 'n';
1158                         break;
1159                 case '\r':
1160                         *(t++) = '\\';
1161                         *(t++) = 'r';
1162                         break;
1163                 case '\t':
1164                         *(t++) = '\\';
1165                         *(t++) = 't';
1166                         break;
1167                 case '\v':
1168                         *(t++) = '\\';
1169                         *(t++) = 'v';
1170                         break;
1171                 case '\\':
1172                         *(t++) = '\\';
1173                         *(t++) = '\\';
1174                         break;
1175                 case '"':
1176                         *(t++) = '\\';
1177                         *(t++) = '"';
1178                         break;
1179                 case '\'':
1180                         *(t++) = '\\';
1181                         *(t++) = '\'';
1182                         break;
1183
1184                 default:
1185                         /* For special chars we prefer octal over
1186                          * hexadecimal encoding, simply because glib's
1187                          * g_strescape() does the same */
1188                         if ((*f < ' ') || (*f >= 127)) {
1189                                 *(t++) = '\\';
1190                                 *(t++) = octchar((unsigned char) *f >> 6);
1191                                 *(t++) = octchar((unsigned char) *f >> 3);
1192                                 *(t++) = octchar((unsigned char) *f);
1193                         } else
1194                                 *(t++) = *f;
1195                         break;
1196                 }
1197
1198         *t = 0;
1199
1200         return r;
1201 }
1202
1203 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1204         char *r, *t;
1205         const char *f;
1206         size_t pl;
1207
1208         assert(s);
1209
1210         /* Undoes C style string escaping, and optionally prefixes it. */
1211
1212         pl = prefix ? strlen(prefix) : 0;
1213
1214         r = new(char, pl+length+1);
1215         if (!r)
1216                 return r;
1217
1218         if (prefix)
1219                 memcpy(r, prefix, pl);
1220
1221         for (f = s, t = r + pl; f < s + length; f++) {
1222
1223                 if (*f != '\\') {
1224                         *(t++) = *f;
1225                         continue;
1226                 }
1227
1228                 f++;
1229
1230                 switch (*f) {
1231
1232                 case 'a':
1233                         *(t++) = '\a';
1234                         break;
1235                 case 'b':
1236                         *(t++) = '\b';
1237                         break;
1238                 case 'f':
1239                         *(t++) = '\f';
1240                         break;
1241                 case 'n':
1242                         *(t++) = '\n';
1243                         break;
1244                 case 'r':
1245                         *(t++) = '\r';
1246                         break;
1247                 case 't':
1248                         *(t++) = '\t';
1249                         break;
1250                 case 'v':
1251                         *(t++) = '\v';
1252                         break;
1253                 case '\\':
1254                         *(t++) = '\\';
1255                         break;
1256                 case '"':
1257                         *(t++) = '"';
1258                         break;
1259                 case '\'':
1260                         *(t++) = '\'';
1261                         break;
1262
1263                 case 's':
1264                         /* This is an extension of the XDG syntax files */
1265                         *(t++) = ' ';
1266                         break;
1267
1268                 case 'x': {
1269                         /* hexadecimal encoding */
1270                         int a, b;
1271
1272                         a = unhexchar(f[1]);
1273                         b = unhexchar(f[2]);
1274
1275                         if (a < 0 || b < 0) {
1276                                 /* Invalid escape code, let's take it literal then */
1277                                 *(t++) = '\\';
1278                                 *(t++) = 'x';
1279                         } else {
1280                                 *(t++) = (char) ((a << 4) | b);
1281                                 f += 2;
1282                         }
1283
1284                         break;
1285                 }
1286
1287                 case '0':
1288                 case '1':
1289                 case '2':
1290                 case '3':
1291                 case '4':
1292                 case '5':
1293                 case '6':
1294                 case '7': {
1295                         /* octal encoding */
1296                         int a, b, c;
1297
1298                         a = unoctchar(f[0]);
1299                         b = unoctchar(f[1]);
1300                         c = unoctchar(f[2]);
1301
1302                         if (a < 0 || b < 0 || c < 0) {
1303                                 /* Invalid escape code, let's take it literal then */
1304                                 *(t++) = '\\';
1305                                 *(t++) = f[0];
1306                         } else {
1307                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1308                                 f += 2;
1309                         }
1310
1311                         break;
1312                 }
1313
1314                 case 0:
1315                         /* premature end of string.*/
1316                         *(t++) = '\\';
1317                         goto finish;
1318
1319                 default:
1320                         /* Invalid escape code, let's take it literal then */
1321                         *(t++) = '\\';
1322                         *(t++) = *f;
1323                         break;
1324                 }
1325         }
1326
1327 finish:
1328         *t = 0;
1329         return r;
1330 }
1331
1332 char *cunescape_length(const char *s, size_t length) {
1333         return cunescape_length_with_prefix(s, length, NULL);
1334 }
1335
1336 char *cunescape(const char *s) {
1337         assert(s);
1338
1339         return cunescape_length(s, strlen(s));
1340 }
1341
1342 char *xescape(const char *s, const char *bad) {
1343         char *r, *t;
1344         const char *f;
1345
1346         /* Escapes all chars in bad, in addition to \ and all special
1347          * chars, in \xFF style escaping. May be reversed with
1348          * cunescape. */
1349
1350         r = new(char, strlen(s) * 4 + 1);
1351         if (!r)
1352                 return NULL;
1353
1354         for (f = s, t = r; *f; f++) {
1355
1356                 if ((*f < ' ') || (*f >= 127) ||
1357                     (*f == '\\') || strchr(bad, *f)) {
1358                         *(t++) = '\\';
1359                         *(t++) = 'x';
1360                         *(t++) = hexchar(*f >> 4);
1361                         *(t++) = hexchar(*f);
1362                 } else
1363                         *(t++) = *f;
1364         }
1365
1366         *t = 0;
1367
1368         return r;
1369 }
1370
1371 char *ascii_strlower(char *t) {
1372         char *p;
1373
1374         assert(t);
1375
1376         for (p = t; *p; p++)
1377                 if (*p >= 'A' && *p <= 'Z')
1378                         *p = *p - 'A' + 'a';
1379
1380         return t;
1381 }
1382
1383 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1384         assert(filename);
1385
1386         return
1387                 filename[0] == '.' ||
1388                 streq(filename, "lost+found") ||
1389                 streq(filename, "aquota.user") ||
1390                 streq(filename, "aquota.group") ||
1391                 endswith(filename, ".rpmnew") ||
1392                 endswith(filename, ".rpmsave") ||
1393                 endswith(filename, ".rpmorig") ||
1394                 endswith(filename, ".dpkg-old") ||
1395                 endswith(filename, ".dpkg-new") ||
1396                 endswith(filename, ".swp");
1397 }
1398
1399 bool ignore_file(const char *filename) {
1400         assert(filename);
1401
1402         if (endswith(filename, "~"))
1403                 return false;
1404
1405         return ignore_file_allow_backup(filename);
1406 }
1407
1408 int fd_nonblock(int fd, bool nonblock) {
1409         int flags;
1410
1411         assert(fd >= 0);
1412
1413         if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1414                 return -errno;
1415
1416         if (nonblock)
1417                 flags |= O_NONBLOCK;
1418         else
1419                 flags &= ~O_NONBLOCK;
1420
1421         if (fcntl(fd, F_SETFL, flags) < 0)
1422                 return -errno;
1423
1424         return 0;
1425 }
1426
1427 int fd_cloexec(int fd, bool cloexec) {
1428         int flags;
1429
1430         assert(fd >= 0);
1431
1432         if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1433                 return -errno;
1434
1435         if (cloexec)
1436                 flags |= FD_CLOEXEC;
1437         else
1438                 flags &= ~FD_CLOEXEC;
1439
1440         if (fcntl(fd, F_SETFD, flags) < 0)
1441                 return -errno;
1442
1443         return 0;
1444 }
1445
1446 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1447         unsigned i;
1448
1449         assert(n_fdset == 0 || fdset);
1450
1451         for (i = 0; i < n_fdset; i++)
1452                 if (fdset[i] == fd)
1453                         return true;
1454
1455         return false;
1456 }
1457
1458 int close_all_fds(const int except[], unsigned n_except) {
1459         DIR *d;
1460         struct dirent *de;
1461         int r = 0;
1462
1463         assert(n_except == 0 || except);
1464
1465         d = opendir("/proc/self/fd");
1466         if (!d) {
1467                 int fd;
1468                 struct rlimit rl;
1469
1470                 /* When /proc isn't available (for example in chroots)
1471                  * the fallback is brute forcing through the fd
1472                  * table */
1473
1474                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1475                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1476
1477                         if (fd_in_set(fd, except, n_except))
1478                                 continue;
1479
1480                         if (close_nointr(fd) < 0)
1481                                 if (errno != EBADF && r == 0)
1482                                         r = -errno;
1483                 }
1484
1485                 return r;
1486         }
1487
1488         while ((de = readdir(d))) {
1489                 int fd = -1;
1490
1491                 if (ignore_file(de->d_name))
1492                         continue;
1493
1494                 if (safe_atoi(de->d_name, &fd) < 0)
1495                         /* Let's better ignore this, just in case */
1496                         continue;
1497
1498                 if (fd < 3)
1499                         continue;
1500
1501                 if (fd == dirfd(d))
1502                         continue;
1503
1504                 if (fd_in_set(fd, except, n_except))
1505                         continue;
1506
1507                 if (close_nointr(fd) < 0) {
1508                         /* Valgrind has its own FD and doesn't want to have it closed */
1509                         if (errno != EBADF && r == 0)
1510                                 r = -errno;
1511                 }
1512         }
1513
1514         closedir(d);
1515         return r;
1516 }
1517
1518 bool chars_intersect(const char *a, const char *b) {
1519         const char *p;
1520
1521         /* Returns true if any of the chars in a are in b. */
1522         for (p = a; *p; p++)
1523                 if (strchr(b, *p))
1524                         return true;
1525
1526         return false;
1527 }
1528
1529 bool fstype_is_network(const char *fstype) {
1530         static const char table[] =
1531                 "cifs\0"
1532                 "smbfs\0"
1533                 "ncpfs\0"
1534                 "ncp\0"
1535                 "nfs\0"
1536                 "nfs4\0"
1537                 "gfs\0"
1538                 "gfs2\0";
1539
1540         return nulstr_contains(table, fstype);
1541 }
1542
1543 int chvt(int vt) {
1544         _cleanup_close_ int fd;
1545
1546         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1547         if (fd < 0)
1548                 return -errno;
1549
1550         if (vt < 0) {
1551                 int tiocl[2] = {
1552                         TIOCL_GETKMSGREDIRECT,
1553                         0
1554                 };
1555
1556                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1557                         return -errno;
1558
1559                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1560         }
1561
1562         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1563                 return -errno;
1564
1565         return 0;
1566 }
1567
1568 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1569         struct termios old_termios, new_termios;
1570         char c;
1571         char line[LINE_MAX];
1572
1573         assert(f);
1574         assert(ret);
1575
1576         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1577                 new_termios = old_termios;
1578
1579                 new_termios.c_lflag &= ~ICANON;
1580                 new_termios.c_cc[VMIN] = 1;
1581                 new_termios.c_cc[VTIME] = 0;
1582
1583                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1584                         size_t k;
1585
1586                         if (t != (usec_t) -1) {
1587                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1588                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1589                                         return -ETIMEDOUT;
1590                                 }
1591                         }
1592
1593                         k = fread(&c, 1, 1, f);
1594
1595                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1596
1597                         if (k <= 0)
1598                                 return -EIO;
1599
1600                         if (need_nl)
1601                                 *need_nl = c != '\n';
1602
1603                         *ret = c;
1604                         return 0;
1605                 }
1606         }
1607
1608         if (t != (usec_t) -1)
1609                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1610                         return -ETIMEDOUT;
1611
1612         if (!fgets(line, sizeof(line), f))
1613                 return -EIO;
1614
1615         truncate_nl(line);
1616
1617         if (strlen(line) != 1)
1618                 return -EBADMSG;
1619
1620         if (need_nl)
1621                 *need_nl = false;
1622
1623         *ret = line[0];
1624         return 0;
1625 }
1626
1627 int ask(char *ret, const char *replies, const char *text, ...) {
1628
1629         assert(ret);
1630         assert(replies);
1631         assert(text);
1632
1633         for (;;) {
1634                 va_list ap;
1635                 char c;
1636                 int r;
1637                 bool need_nl = true;
1638
1639                 if (on_tty())
1640                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1641
1642                 va_start(ap, text);
1643                 vprintf(text, ap);
1644                 va_end(ap);
1645
1646                 if (on_tty())
1647                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1648
1649                 fflush(stdout);
1650
1651                 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
1652                 if (r < 0) {
1653
1654                         if (r == -EBADMSG) {
1655                                 puts("Bad input, please try again.");
1656                                 continue;
1657                         }
1658
1659                         putchar('\n');
1660                         return r;
1661                 }
1662
1663                 if (need_nl)
1664                         putchar('\n');
1665
1666                 if (strchr(replies, c)) {
1667                         *ret = c;
1668                         return 0;
1669                 }
1670
1671                 puts("Read unexpected character, please try again.");
1672         }
1673 }
1674
1675 int reset_terminal_fd(int fd, bool switch_to_text) {
1676         struct termios termios;
1677         int r = 0;
1678
1679         /* Set terminal to some sane defaults */
1680
1681         assert(fd >= 0);
1682
1683         /* We leave locked terminal attributes untouched, so that
1684          * Plymouth may set whatever it wants to set, and we don't
1685          * interfere with that. */
1686
1687         /* Disable exclusive mode, just in case */
1688         ioctl(fd, TIOCNXCL);
1689
1690         /* Switch to text mode */
1691         if (switch_to_text)
1692                 ioctl(fd, KDSETMODE, KD_TEXT);
1693
1694         /* Enable console unicode mode */
1695         ioctl(fd, KDSKBMODE, K_UNICODE);
1696
1697         if (tcgetattr(fd, &termios) < 0) {
1698                 r = -errno;
1699                 goto finish;
1700         }
1701
1702         /* We only reset the stuff that matters to the software. How
1703          * hardware is set up we don't touch assuming that somebody
1704          * else will do that for us */
1705
1706         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1707         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1708         termios.c_oflag |= ONLCR;
1709         termios.c_cflag |= CREAD;
1710         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1711
1712         termios.c_cc[VINTR]    =   03;  /* ^C */
1713         termios.c_cc[VQUIT]    =  034;  /* ^\ */
1714         termios.c_cc[VERASE]   = 0177;
1715         termios.c_cc[VKILL]    =  025;  /* ^X */
1716         termios.c_cc[VEOF]     =   04;  /* ^D */
1717         termios.c_cc[VSTART]   =  021;  /* ^Q */
1718         termios.c_cc[VSTOP]    =  023;  /* ^S */
1719         termios.c_cc[VSUSP]    =  032;  /* ^Z */
1720         termios.c_cc[VLNEXT]   =  026;  /* ^V */
1721         termios.c_cc[VWERASE]  =  027;  /* ^W */
1722         termios.c_cc[VREPRINT] =  022;  /* ^R */
1723         termios.c_cc[VEOL]     =    0;
1724         termios.c_cc[VEOL2]    =    0;
1725
1726         termios.c_cc[VTIME]  = 0;
1727         termios.c_cc[VMIN]   = 1;
1728
1729         if (tcsetattr(fd, TCSANOW, &termios) < 0)
1730                 r = -errno;
1731
1732 finish:
1733         /* Just in case, flush all crap out */
1734         tcflush(fd, TCIOFLUSH);
1735
1736         return r;
1737 }
1738
1739 int reset_terminal(const char *name) {
1740         int fd, r;
1741
1742         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1743         if (fd < 0)
1744                 return fd;
1745
1746         r = reset_terminal_fd(fd, true);
1747         close_nointr_nofail(fd);
1748
1749         return r;
1750 }
1751
1752 int open_terminal(const char *name, int mode) {
1753         int fd, r;
1754         unsigned c = 0;
1755
1756         /*
1757          * If a TTY is in the process of being closed opening it might
1758          * cause EIO. This is horribly awful, but unlikely to be
1759          * changed in the kernel. Hence we work around this problem by
1760          * retrying a couple of times.
1761          *
1762          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1763          */
1764
1765         assert(!(mode & O_CREAT));
1766
1767         for (;;) {
1768                 fd = open(name, mode, 0);
1769                 if (fd >= 0)
1770                         break;
1771
1772                 if (errno != EIO)
1773                         return -errno;
1774
1775                 /* Max 1s in total */
1776                 if (c >= 20)
1777                         return -errno;
1778
1779                 usleep(50 * USEC_PER_MSEC);
1780                 c++;
1781         }
1782
1783         if (fd < 0)
1784                 return -errno;
1785
1786         r = isatty(fd);
1787         if (r < 0) {
1788                 close_nointr_nofail(fd);
1789                 return -errno;
1790         }
1791
1792         if (!r) {
1793                 close_nointr_nofail(fd);
1794                 return -ENOTTY;
1795         }
1796
1797         return fd;
1798 }
1799
1800 int flush_fd(int fd) {
1801         struct pollfd pollfd = {
1802                 .fd = fd,
1803                 .events = POLLIN,
1804         };
1805
1806         for (;;) {
1807                 char buf[LINE_MAX];
1808                 ssize_t l;
1809                 int r;
1810
1811                 r = poll(&pollfd, 1, 0);
1812                 if (r < 0) {
1813                         if (errno == EINTR)
1814                                 continue;
1815
1816                         return -errno;
1817
1818                 } else if (r == 0)
1819                         return 0;
1820
1821                 l = read(fd, buf, sizeof(buf));
1822                 if (l < 0) {
1823
1824                         if (errno == EINTR)
1825                                 continue;
1826
1827                         if (errno == EAGAIN)
1828                                 return 0;
1829
1830                         return -errno;
1831                 } else if (l == 0)
1832                         return 0;
1833         }
1834 }
1835
1836 int acquire_terminal(
1837                 const char *name,
1838                 bool fail,
1839                 bool force,
1840                 bool ignore_tiocstty_eperm,
1841                 usec_t timeout) {
1842
1843         int fd = -1, notify = -1, r = 0, wd = -1;
1844         usec_t ts = 0;
1845
1846         assert(name);
1847
1848         /* We use inotify to be notified when the tty is closed. We
1849          * create the watch before checking if we can actually acquire
1850          * it, so that we don't lose any event.
1851          *
1852          * Note: strictly speaking this actually watches for the
1853          * device being closed, it does *not* really watch whether a
1854          * tty loses its controlling process. However, unless some
1855          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1856          * its tty otherwise this will not become a problem. As long
1857          * as the administrator makes sure not configure any service
1858          * on the same tty as an untrusted user this should not be a
1859          * problem. (Which he probably should not do anyway.) */
1860
1861         if (timeout != (usec_t) -1)
1862                 ts = now(CLOCK_MONOTONIC);
1863
1864         if (!fail && !force) {
1865                 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
1866                 if (notify < 0) {
1867                         r = -errno;
1868                         goto fail;
1869                 }
1870
1871                 wd = inotify_add_watch(notify, name, IN_CLOSE);
1872                 if (wd < 0) {
1873                         r = -errno;
1874                         goto fail;
1875                 }
1876         }
1877
1878         for (;;) {
1879                 struct sigaction sa_old, sa_new = {
1880                         .sa_handler = SIG_IGN,
1881                         .sa_flags = SA_RESTART,
1882                 };
1883
1884                 if (notify >= 0) {
1885                         r = flush_fd(notify);
1886                         if (r < 0)
1887                                 goto fail;
1888                 }
1889
1890                 /* We pass here O_NOCTTY only so that we can check the return
1891                  * value TIOCSCTTY and have a reliable way to figure out if we
1892                  * successfully became the controlling process of the tty */
1893                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1894                 if (fd < 0)
1895                         return fd;
1896
1897                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1898                  * if we already own the tty. */
1899                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1900
1901                 /* First, try to get the tty */
1902                 if (ioctl(fd, TIOCSCTTY, force) < 0)
1903                         r = -errno;
1904
1905                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1906
1907                 /* Sometimes it makes sense to ignore TIOCSCTTY
1908                  * returning EPERM, i.e. when very likely we already
1909                  * are have this controlling terminal. */
1910                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1911                         r = 0;
1912
1913                 if (r < 0 && (force || fail || r != -EPERM)) {
1914                         goto fail;
1915                 }
1916
1917                 if (r >= 0)
1918                         break;
1919
1920                 assert(!fail);
1921                 assert(!force);
1922                 assert(notify >= 0);
1923
1924                 for (;;) {
1925                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1926                         ssize_t l;
1927                         struct inotify_event *e;
1928
1929                         if (timeout != (usec_t) -1) {
1930                                 usec_t n;
1931
1932                                 n = now(CLOCK_MONOTONIC);
1933                                 if (ts + timeout < n) {
1934                                         r = -ETIMEDOUT;
1935                                         goto fail;
1936                                 }
1937
1938                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
1939                                 if (r < 0)
1940                                         goto fail;
1941
1942                                 if (r == 0) {
1943                                         r = -ETIMEDOUT;
1944                                         goto fail;
1945                                 }
1946                         }
1947
1948                         l = read(notify, inotify_buffer, sizeof(inotify_buffer));
1949                         if (l < 0) {
1950
1951                                 if (errno == EINTR || errno == EAGAIN)
1952                                         continue;
1953
1954                                 r = -errno;
1955                                 goto fail;
1956                         }
1957
1958                         e = (struct inotify_event*) inotify_buffer;
1959
1960                         while (l > 0) {
1961                                 size_t step;
1962
1963                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
1964                                         r = -EIO;
1965                                         goto fail;
1966                                 }
1967
1968                                 step = sizeof(struct inotify_event) + e->len;
1969                                 assert(step <= (size_t) l);
1970
1971                                 e = (struct inotify_event*) ((uint8_t*) e + step);
1972                                 l -= step;
1973                         }
1974
1975                         break;
1976                 }
1977
1978                 /* We close the tty fd here since if the old session
1979                  * ended our handle will be dead. It's important that
1980                  * we do this after sleeping, so that we don't enter
1981                  * an endless loop. */
1982                 close_nointr_nofail(fd);
1983         }
1984
1985         if (notify >= 0)
1986                 close_nointr_nofail(notify);
1987
1988         r = reset_terminal_fd(fd, true);
1989         if (r < 0)
1990                 log_warning("Failed to reset terminal: %s", strerror(-r));
1991
1992         return fd;
1993
1994 fail:
1995         if (fd >= 0)
1996                 close_nointr_nofail(fd);
1997
1998         if (notify >= 0)
1999                 close_nointr_nofail(notify);
2000
2001         return r;
2002 }
2003
2004 int release_terminal(void) {
2005         int r = 0;
2006         struct sigaction sa_old, sa_new = {
2007                 .sa_handler = SIG_IGN,
2008                 .sa_flags = SA_RESTART,
2009         };
2010         _cleanup_close_ int fd;
2011
2012         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2013         if (fd < 0)
2014                 return -errno;
2015
2016         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2017          * by our own TIOCNOTTY */
2018         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2019
2020         if (ioctl(fd, TIOCNOTTY) < 0)
2021                 r = -errno;
2022
2023         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2024
2025         return r;
2026 }
2027
2028 int sigaction_many(const struct sigaction *sa, ...) {
2029         va_list ap;
2030         int r = 0, sig;
2031
2032         va_start(ap, sa);
2033         while ((sig = va_arg(ap, int)) > 0)
2034                 if (sigaction(sig, sa, NULL) < 0)
2035                         r = -errno;
2036         va_end(ap);
2037
2038         return r;
2039 }
2040
2041 int ignore_signals(int sig, ...) {
2042         struct sigaction sa = {
2043                 .sa_handler = SIG_IGN,
2044                 .sa_flags = SA_RESTART,
2045         };
2046         va_list ap;
2047         int r = 0;
2048
2049
2050         if (sigaction(sig, &sa, NULL) < 0)
2051                 r = -errno;
2052
2053         va_start(ap, sig);
2054         while ((sig = va_arg(ap, int)) > 0)
2055                 if (sigaction(sig, &sa, NULL) < 0)
2056                         r = -errno;
2057         va_end(ap);
2058
2059         return r;
2060 }
2061
2062 int default_signals(int sig, ...) {
2063         struct sigaction sa = {
2064                 .sa_handler = SIG_DFL,
2065                 .sa_flags = SA_RESTART,
2066         };
2067         va_list ap;
2068         int r = 0;
2069
2070         if (sigaction(sig, &sa, NULL) < 0)
2071                 r = -errno;
2072
2073         va_start(ap, sig);
2074         while ((sig = va_arg(ap, int)) > 0)
2075                 if (sigaction(sig, &sa, NULL) < 0)
2076                         r = -errno;
2077         va_end(ap);
2078
2079         return r;
2080 }
2081
2082 int close_pipe(int p[]) {
2083         int a = 0, b = 0;
2084
2085         assert(p);
2086
2087         if (p[0] >= 0) {
2088                 a = close_nointr(p[0]);
2089                 p[0] = -1;
2090         }
2091
2092         if (p[1] >= 0) {
2093                 b = close_nointr(p[1]);
2094                 p[1] = -1;
2095         }
2096
2097         return a < 0 ? a : b;
2098 }
2099
2100 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2101         uint8_t *p;
2102         ssize_t n = 0;
2103
2104         assert(fd >= 0);
2105         assert(buf);
2106
2107         p = buf;
2108
2109         while (nbytes > 0) {
2110                 ssize_t k;
2111
2112                 if ((k = read(fd, p, nbytes)) <= 0) {
2113
2114                         if (k < 0 && errno == EINTR)
2115                                 continue;
2116
2117                         if (k < 0 && errno == EAGAIN && do_poll) {
2118                                 struct pollfd pollfd = {
2119                                         .fd = fd,
2120                                         .events = POLLIN,
2121                                 };
2122
2123                                 if (poll(&pollfd, 1, -1) < 0) {
2124                                         if (errno == EINTR)
2125                                                 continue;
2126
2127                                         return n > 0 ? n : -errno;
2128                                 }
2129
2130                                 /* We knowingly ignore the revents value here,
2131                                  * and expect that any error/EOF is reported
2132                                  * via read()/write()
2133                                  */
2134
2135                                 continue;
2136                         }
2137
2138                         return n > 0 ? n : (k < 0 ? -errno : 0);
2139                 }
2140
2141                 p += k;
2142                 nbytes -= k;
2143                 n += k;
2144         }
2145
2146         return n;
2147 }
2148
2149 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2150         const uint8_t *p;
2151         ssize_t n = 0;
2152
2153         assert(fd >= 0);
2154         assert(buf);
2155
2156         p = buf;
2157
2158         while (nbytes > 0) {
2159                 ssize_t k;
2160
2161                 k = write(fd, p, nbytes);
2162                 if (k <= 0) {
2163
2164                         if (k < 0 && errno == EINTR)
2165                                 continue;
2166
2167                         if (k < 0 && errno == EAGAIN && do_poll) {
2168                                 struct pollfd pollfd = {
2169                                         .fd = fd,
2170                                         .events = POLLOUT,
2171                                 };
2172
2173                                 if (poll(&pollfd, 1, -1) < 0) {
2174                                         if (errno == EINTR)
2175                                                 continue;
2176
2177                                         return n > 0 ? n : -errno;
2178                                 }
2179
2180                                 /* We knowingly ignore the revents value here,
2181                                  * and expect that any error/EOF is reported
2182                                  * via read()/write()
2183                                  */
2184
2185                                 continue;
2186                         }
2187
2188                         return n > 0 ? n : (k < 0 ? -errno : 0);
2189                 }
2190
2191                 p += k;
2192                 nbytes -= k;
2193                 n += k;
2194         }
2195
2196         return n;
2197 }
2198
2199 int parse_bytes(const char *t, off_t *bytes) {
2200         static const struct {
2201                 const char *suffix;
2202                 unsigned long long factor;
2203         } table[] = {
2204                 { "B", 1 },
2205                 { "K", 1024ULL },
2206                 { "M", 1024ULL*1024ULL },
2207                 { "G", 1024ULL*1024ULL*1024ULL },
2208                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2209                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2210                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2211                 { "", 1 },
2212         };
2213
2214         const char *p;
2215         unsigned long long r = 0;
2216
2217         assert(t);
2218         assert(bytes);
2219
2220         p = t;
2221         do {
2222                 long long l;
2223                 char *e;
2224                 unsigned i;
2225
2226                 errno = 0;
2227                 l = strtoll(p, &e, 10);
2228
2229                 if (errno > 0)
2230                         return -errno;
2231
2232                 if (l < 0)
2233                         return -ERANGE;
2234
2235                 if (e == p)
2236                         return -EINVAL;
2237
2238                 e += strspn(e, WHITESPACE);
2239
2240                 for (i = 0; i < ELEMENTSOF(table); i++)
2241                         if (startswith(e, table[i].suffix)) {
2242                                 unsigned long long tmp;
2243                                 if ((unsigned long long) l > ULLONG_MAX / table[i].factor)
2244                                         return -ERANGE;
2245                                 tmp = l * table[i].factor;
2246                                 if (tmp > ULLONG_MAX - r)
2247                                         return -ERANGE;
2248
2249                                 r += tmp;
2250                                 if ((unsigned long long) (off_t) r != r)
2251                                         return -ERANGE;
2252
2253                                 p = e + strlen(table[i].suffix);
2254                                 break;
2255                         }
2256
2257                 if (i >= ELEMENTSOF(table))
2258                         return -EINVAL;
2259
2260         } while (*p);
2261
2262         *bytes = r;
2263
2264         return 0;
2265 }
2266
2267 int make_stdio(int fd) {
2268         int r, s, t;
2269
2270         assert(fd >= 0);
2271
2272         r = dup3(fd, STDIN_FILENO, 0);
2273         s = dup3(fd, STDOUT_FILENO, 0);
2274         t = dup3(fd, STDERR_FILENO, 0);
2275
2276         if (fd >= 3)
2277                 close_nointr_nofail(fd);
2278
2279         if (r < 0 || s < 0 || t < 0)
2280                 return -errno;
2281
2282         /* We rely here that the new fd has O_CLOEXEC not set */
2283
2284         return 0;
2285 }
2286
2287 int make_null_stdio(void) {
2288         int null_fd;
2289
2290         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2291         if (null_fd < 0)
2292                 return -errno;
2293
2294         return make_stdio(null_fd);
2295 }
2296
2297 bool is_device_path(const char *path) {
2298
2299         /* Returns true on paths that refer to a device, either in
2300          * sysfs or in /dev */
2301
2302         return
2303                 path_startswith(path, "/dev/") ||
2304                 path_startswith(path, "/sys/");
2305 }
2306
2307 int dir_is_empty(const char *path) {
2308         _cleanup_closedir_ DIR *d;
2309         int r;
2310
2311         d = opendir(path);
2312         if (!d)
2313                 return -errno;
2314
2315         for (;;) {
2316                 struct dirent *de;
2317                 union dirent_storage buf;
2318
2319                 r = readdir_r(d, &buf.de, &de);
2320                 if (r > 0)
2321                         return -r;
2322
2323                 if (!de)
2324                         return 1;
2325
2326                 if (!ignore_file(de->d_name))
2327                         return 0;
2328         }
2329 }
2330
2331 char* dirname_malloc(const char *path) {
2332         char *d, *dir, *dir2;
2333
2334         d = strdup(path);
2335         if (!d)
2336                 return NULL;
2337         dir = dirname(d);
2338         assert(dir);
2339
2340         if (dir != d) {
2341                 dir2 = strdup(dir);
2342                 free(d);
2343                 return dir2;
2344         }
2345
2346         return dir;
2347 }
2348
2349 unsigned long long random_ull(void) {
2350         _cleanup_close_ int fd;
2351         uint64_t ull;
2352         ssize_t r;
2353
2354         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2355         if (fd < 0)
2356                 goto fallback;
2357
2358         r = loop_read(fd, &ull, sizeof(ull), true);
2359         if (r != sizeof(ull))
2360                 goto fallback;
2361
2362         return ull;
2363
2364 fallback:
2365         return random() * RAND_MAX + random();
2366 }
2367
2368 unsigned random_u(void) {
2369         _cleanup_close_ int fd;
2370         unsigned u;
2371         ssize_t r;
2372
2373         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2374         if (fd < 0)
2375                 goto fallback;
2376
2377         r = loop_read(fd, &u, sizeof(u), true);
2378         if (r != sizeof(u))
2379                 goto fallback;
2380
2381         return u;
2382
2383 fallback:
2384         return random() * RAND_MAX + random();
2385 }
2386
2387 void rename_process(const char name[8]) {
2388         assert(name);
2389
2390         /* This is a like a poor man's setproctitle(). It changes the
2391          * comm field, argv[0], and also the glibc's internally used
2392          * name of the process. For the first one a limit of 16 chars
2393          * applies, to the second one usually one of 10 (i.e. length
2394          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2395          * "systemd"). If you pass a longer string it will be
2396          * truncated */
2397
2398         prctl(PR_SET_NAME, name);
2399
2400         if (program_invocation_name)
2401                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2402
2403         if (saved_argc > 0) {
2404                 int i;
2405
2406                 if (saved_argv[0])
2407                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2408
2409                 for (i = 1; i < saved_argc; i++) {
2410                         if (!saved_argv[i])
2411                                 break;
2412
2413                         memset(saved_argv[i], 0, strlen(saved_argv[i]));
2414                 }
2415         }
2416 }
2417
2418 void sigset_add_many(sigset_t *ss, ...) {
2419         va_list ap;
2420         int sig;
2421
2422         assert(ss);
2423
2424         va_start(ap, ss);
2425         while ((sig = va_arg(ap, int)) > 0)
2426                 assert_se(sigaddset(ss, sig) == 0);
2427         va_end(ap);
2428 }
2429
2430 char* gethostname_malloc(void) {
2431         struct utsname u;
2432
2433         assert_se(uname(&u) >= 0);
2434
2435         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2436                 return strdup(u.nodename);
2437
2438         return strdup(u.sysname);
2439 }
2440
2441 bool hostname_is_set(void) {
2442         struct utsname u;
2443
2444         assert_se(uname(&u) >= 0);
2445
2446         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2447 }
2448
2449 static char *lookup_uid(uid_t uid) {
2450         long bufsize;
2451         char *name;
2452         _cleanup_free_ char *buf = NULL;
2453         struct passwd pwbuf, *pw = NULL;
2454
2455         /* Shortcut things to avoid NSS lookups */
2456         if (uid == 0)
2457                 return strdup("root");
2458
2459         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2460         if (bufsize <= 0)
2461                 bufsize = 4096;
2462
2463         buf = malloc(bufsize);
2464         if (!buf)
2465                 return NULL;
2466
2467         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2468                 return strdup(pw->pw_name);
2469
2470         if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
2471                 return NULL;
2472
2473         return name;
2474 }
2475
2476 char* getlogname_malloc(void) {
2477         uid_t uid;
2478         struct stat st;
2479
2480         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2481                 uid = st.st_uid;
2482         else
2483                 uid = getuid();
2484
2485         return lookup_uid(uid);
2486 }
2487
2488 char *getusername_malloc(void) {
2489         const char *e;
2490
2491         e = getenv("USER");
2492         if (e)
2493                 return strdup(e);
2494
2495         return lookup_uid(getuid());
2496 }
2497
2498 int getttyname_malloc(int fd, char **r) {
2499         char path[PATH_MAX], *c;
2500         int k;
2501
2502         assert(r);
2503
2504         k = ttyname_r(fd, path, sizeof(path));
2505         if (k > 0)
2506                 return -k;
2507
2508         char_array_0(path);
2509
2510         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2511         if (!c)
2512                 return -ENOMEM;
2513
2514         *r = c;
2515         return 0;
2516 }
2517
2518 int getttyname_harder(int fd, char **r) {
2519         int k;
2520         char *s;
2521
2522         k = getttyname_malloc(fd, &s);
2523         if (k < 0)
2524                 return k;
2525
2526         if (streq(s, "tty")) {
2527                 free(s);
2528                 return get_ctty(0, NULL, r);
2529         }
2530
2531         *r = s;
2532         return 0;
2533 }
2534
2535 int get_ctty_devnr(pid_t pid, dev_t *d) {
2536         _cleanup_fclose_ FILE *f = NULL;
2537         char line[LINE_MAX], *p;
2538         unsigned long ttynr;
2539         const char *fn;
2540
2541         assert(pid >= 0);
2542
2543         if (pid == 0)
2544                 fn = "/proc/self/stat";
2545         else
2546                 fn = procfs_file_alloca(pid, "stat");
2547
2548         f = fopen(fn, "re");
2549         if (!f)
2550                 return -errno;
2551
2552         if (!fgets(line, sizeof(line), f))
2553                 return feof(f) ? -EIO : -errno;
2554
2555         p = strrchr(line, ')');
2556         if (!p)
2557                 return -EIO;
2558
2559         p++;
2560
2561         if (sscanf(p, " "
2562                    "%*c "  /* state */
2563                    "%*d "  /* ppid */
2564                    "%*d "  /* pgrp */
2565                    "%*d "  /* session */
2566                    "%lu ", /* ttynr */
2567                    &ttynr) != 1)
2568                 return -EIO;
2569
2570         if (major(ttynr) == 0 && minor(ttynr) == 0)
2571                 return -ENOENT;
2572
2573         if (d)
2574                 *d = (dev_t) ttynr;
2575
2576         return 0;
2577 }
2578
2579 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2580         int k;
2581         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *s, *b, *p;
2582         dev_t devnr;
2583
2584         assert(r);
2585
2586         k = get_ctty_devnr(pid, &devnr);
2587         if (k < 0)
2588                 return k;
2589
2590         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2591
2592         k = readlink_malloc(fn, &s);
2593         if (k < 0) {
2594
2595                 if (k != -ENOENT)
2596                         return k;
2597
2598                 /* This is an ugly hack */
2599                 if (major(devnr) == 136) {
2600                         if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)
2601                                 return -ENOMEM;
2602
2603                         *r = b;
2604                         if (_devnr)
2605                                 *_devnr = devnr;
2606
2607                         return 0;
2608                 }
2609
2610                 /* Probably something like the ptys which have no
2611                  * symlink in /dev/char. Let's return something
2612                  * vaguely useful. */
2613
2614                 b = strdup(fn + 5);
2615                 if (!b)
2616                         return -ENOMEM;
2617
2618                 *r = b;
2619                 if (_devnr)
2620                         *_devnr = devnr;
2621
2622                 return 0;
2623         }
2624
2625         if (startswith(s, "/dev/"))
2626                 p = s + 5;
2627         else if (startswith(s, "../"))
2628                 p = s + 3;
2629         else
2630                 p = s;
2631
2632         b = strdup(p);
2633         free(s);
2634
2635         if (!b)
2636                 return -ENOMEM;
2637
2638         *r = b;
2639         if (_devnr)
2640                 *_devnr = devnr;
2641
2642         return 0;
2643 }
2644
2645 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2646         DIR *d;
2647         int ret = 0;
2648
2649         assert(fd >= 0);
2650
2651         /* This returns the first error we run into, but nevertheless
2652          * tries to go on. This closes the passed fd. */
2653
2654         d = fdopendir(fd);
2655         if (!d) {
2656                 close_nointr_nofail(fd);
2657
2658                 return errno == ENOENT ? 0 : -errno;
2659         }
2660
2661         for (;;) {
2662                 struct dirent *de;
2663                 union dirent_storage buf;
2664                 bool is_dir, keep_around;
2665                 struct stat st;
2666                 int r;
2667
2668                 r = readdir_r(d, &buf.de, &de);
2669                 if (r != 0 && ret == 0) {
2670                         ret = -r;
2671                         break;
2672                 }
2673
2674                 if (!de)
2675                         break;
2676
2677                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2678                         continue;
2679
2680                 if (de->d_type == DT_UNKNOWN ||
2681                     honour_sticky ||
2682                     (de->d_type == DT_DIR && root_dev)) {
2683                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2684                                 if (ret == 0 && errno != ENOENT)
2685                                         ret = -errno;
2686                                 continue;
2687                         }
2688
2689                         is_dir = S_ISDIR(st.st_mode);
2690                         keep_around =
2691                                 honour_sticky &&
2692                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2693                                 (st.st_mode & S_ISVTX);
2694                 } else {
2695                         is_dir = de->d_type == DT_DIR;
2696                         keep_around = false;
2697                 }
2698
2699                 if (is_dir) {
2700                         int subdir_fd;
2701
2702                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2703                         if (root_dev && st.st_dev != root_dev->st_dev)
2704                                 continue;
2705
2706                         subdir_fd = openat(fd, de->d_name,
2707                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2708                         if (subdir_fd < 0) {
2709                                 if (ret == 0 && errno != ENOENT)
2710                                         ret = -errno;
2711                                 continue;
2712                         }
2713
2714                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2715                         if (r < 0 && ret == 0)
2716                                 ret = r;
2717
2718                         if (!keep_around)
2719                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2720                                         if (ret == 0 && errno != ENOENT)
2721                                                 ret = -errno;
2722                                 }
2723
2724                 } else if (!only_dirs && !keep_around) {
2725
2726                         if (unlinkat(fd, de->d_name, 0) < 0) {
2727                                 if (ret == 0 && errno != ENOENT)
2728                                         ret = -errno;
2729                         }
2730                 }
2731         }
2732
2733         closedir(d);
2734
2735         return ret;
2736 }
2737
2738 _pure_ static int is_temporary_fs(struct statfs *s) {
2739         assert(s);
2740         return
2741                 F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2742                 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2743 }
2744
2745 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2746         struct statfs s;
2747
2748         assert(fd >= 0);
2749
2750         if (fstatfs(fd, &s) < 0) {
2751                 close_nointr_nofail(fd);
2752                 return -errno;
2753         }
2754
2755         /* We refuse to clean disk file systems with this call. This
2756          * is extra paranoia just to be sure we never ever remove
2757          * non-state data */
2758         if (!is_temporary_fs(&s)) {
2759                 log_error("Attempted to remove disk file system, and we can't allow that.");
2760                 close_nointr_nofail(fd);
2761                 return -EPERM;
2762         }
2763
2764         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2765 }
2766
2767 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2768         int fd, r;
2769         struct statfs s;
2770
2771         assert(path);
2772
2773         /* We refuse to clean the root file system with this
2774          * call. This is extra paranoia to never cause a really
2775          * seriously broken system. */
2776         if (path_equal(path, "/")) {
2777                 log_error("Attempted to remove entire root file system, and we can't allow that.");
2778                 return -EPERM;
2779         }
2780
2781         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2782         if (fd < 0) {
2783
2784                 if (errno != ENOTDIR)
2785                         return -errno;
2786
2787                 if (!dangerous) {
2788                         if (statfs(path, &s) < 0)
2789                                 return -errno;
2790
2791                         if (!is_temporary_fs(&s)) {
2792                                 log_error("Attempted to remove disk file system, and we can't allow that.");
2793                                 return -EPERM;
2794                         }
2795                 }
2796
2797                 if (delete_root && !only_dirs)
2798                         if (unlink(path) < 0 && errno != ENOENT)
2799                                 return -errno;
2800
2801                 return 0;
2802         }
2803
2804         if (!dangerous) {
2805                 if (fstatfs(fd, &s) < 0) {
2806                         close_nointr_nofail(fd);
2807                         return -errno;
2808                 }
2809
2810                 if (!is_temporary_fs(&s)) {
2811                         log_error("Attempted to remove disk file system, and we can't allow that.");
2812                         close_nointr_nofail(fd);
2813                         return -EPERM;
2814                 }
2815         }
2816
2817         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2818         if (delete_root) {
2819
2820                 if (honour_sticky && file_is_priv_sticky(path) > 0)
2821                         return r;
2822
2823                 if (rmdir(path) < 0 && errno != ENOENT) {
2824                         if (r == 0)
2825                                 r = -errno;
2826                 }
2827         }
2828
2829         return r;
2830 }
2831
2832 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2833         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2834 }
2835
2836 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2837         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2838 }
2839
2840 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2841         assert(path);
2842
2843         /* Under the assumption that we are running privileged we
2844          * first change the access mode and only then hand out
2845          * ownership to avoid a window where access is too open. */
2846
2847         if (mode != (mode_t) -1)
2848                 if (chmod(path, mode) < 0)
2849                         return -errno;
2850
2851         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2852                 if (chown(path, uid, gid) < 0)
2853                         return -errno;
2854
2855         return 0;
2856 }
2857
2858 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2859         assert(fd >= 0);
2860
2861         /* Under the assumption that we are running privileged we
2862          * first change the access mode and only then hand out
2863          * ownership to avoid a window where access is too open. */
2864
2865         if (mode != (mode_t) -1)
2866                 if (fchmod(fd, mode) < 0)
2867                         return -errno;
2868
2869         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2870                 if (fchown(fd, uid, gid) < 0)
2871                         return -errno;
2872
2873         return 0;
2874 }
2875
2876 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2877         cpu_set_t *r;
2878         unsigned n = 1024;
2879
2880         /* Allocates the cpuset in the right size */
2881
2882         for (;;) {
2883                 if (!(r = CPU_ALLOC(n)))
2884                         return NULL;
2885
2886                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2887                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2888
2889                         if (ncpus)
2890                                 *ncpus = n;
2891
2892                         return r;
2893                 }
2894
2895                 CPU_FREE(r);
2896
2897                 if (errno != EINVAL)
2898                         return NULL;
2899
2900                 n *= 2;
2901         }
2902 }
2903
2904 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2905         static const char status_indent[] = "         "; /* "[" STATUS "] " */
2906         _cleanup_free_ char *s = NULL;
2907         _cleanup_close_ int fd = -1;
2908         struct iovec iovec[6] = {};
2909         int n = 0;
2910         static bool prev_ephemeral;
2911
2912         assert(format);
2913
2914         /* This is independent of logging, as status messages are
2915          * optional and go exclusively to the console. */
2916
2917         if (vasprintf(&s, format, ap) < 0)
2918                 return log_oom();
2919
2920         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2921         if (fd < 0)
2922                 return fd;
2923
2924         if (ellipse) {
2925                 char *e;
2926                 size_t emax, sl;
2927                 int c;
2928
2929                 c = fd_columns(fd);
2930                 if (c <= 0)
2931                         c = 80;
2932
2933                 sl = status ? sizeof(status_indent)-1 : 0;
2934
2935                 emax = c - sl - 1;
2936                 if (emax < 3)
2937                         emax = 3;
2938
2939                 e = ellipsize(s, emax, 75);
2940                 if (e) {
2941                         free(s);
2942                         s = e;
2943                 }
2944         }
2945
2946         if (prev_ephemeral)
2947                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2948         prev_ephemeral = ephemeral;
2949
2950         if (status) {
2951                 if (!isempty(status)) {
2952                         IOVEC_SET_STRING(iovec[n++], "[");
2953                         IOVEC_SET_STRING(iovec[n++], status);
2954                         IOVEC_SET_STRING(iovec[n++], "] ");
2955                 } else
2956                         IOVEC_SET_STRING(iovec[n++], status_indent);
2957         }
2958
2959         IOVEC_SET_STRING(iovec[n++], s);
2960         if (!ephemeral)
2961                 IOVEC_SET_STRING(iovec[n++], "\n");
2962
2963         if (writev(fd, iovec, n) < 0)
2964                 return -errno;
2965
2966         return 0;
2967 }
2968
2969 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
2970         va_list ap;
2971         int r;
2972
2973         assert(format);
2974
2975         va_start(ap, format);
2976         r = status_vprintf(status, ellipse, ephemeral, format, ap);
2977         va_end(ap);
2978
2979         return r;
2980 }
2981
2982 int status_welcome(void) {
2983         _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
2984         int r;
2985
2986         r = parse_env_file("/etc/os-release", NEWLINE,
2987                            "PRETTY_NAME", &pretty_name,
2988                            "ANSI_COLOR", &ansi_color,
2989                            NULL);
2990
2991         if (r < 0 && r != -ENOENT)
2992                 log_warning("Failed to read /etc/os-release: %s", strerror(-r));
2993
2994         return status_printf(NULL, false, false,
2995                              "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
2996                              isempty(ansi_color) ? "1" : ansi_color,
2997                              isempty(pretty_name) ? "Linux" : pretty_name);
2998 }
2999
3000 char *replace_env(const char *format, char **env) {
3001         enum {
3002                 WORD,
3003                 CURLY,
3004                 VARIABLE
3005         } state = WORD;
3006
3007         const char *e, *word = format;
3008         char *r = NULL, *k;
3009
3010         assert(format);
3011
3012         for (e = format; *e; e ++) {
3013
3014                 switch (state) {
3015
3016                 case WORD:
3017                         if (*e == '$')
3018                                 state = CURLY;
3019                         break;
3020
3021                 case CURLY:
3022                         if (*e == '{') {
3023                                 if (!(k = strnappend(r, word, e-word-1)))
3024                                         goto fail;
3025
3026                                 free(r);
3027                                 r = k;
3028
3029                                 word = e-1;
3030                                 state = VARIABLE;
3031
3032                         } else if (*e == '$') {
3033                                 if (!(k = strnappend(r, word, e-word)))
3034                                         goto fail;
3035
3036                                 free(r);
3037                                 r = k;
3038
3039                                 word = e+1;
3040                                 state = WORD;
3041                         } else
3042                                 state = WORD;
3043                         break;
3044
3045                 case VARIABLE:
3046                         if (*e == '}') {
3047                                 const char *t;
3048
3049                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3050
3051                                 k = strappend(r, t);
3052                                 if (!k)
3053                                         goto fail;
3054
3055                                 free(r);
3056                                 r = k;
3057
3058                                 word = e+1;
3059                                 state = WORD;
3060                         }
3061                         break;
3062                 }
3063         }
3064
3065         if (!(k = strnappend(r, word, e-word)))
3066                 goto fail;
3067
3068         free(r);
3069         return k;
3070
3071 fail:
3072         free(r);
3073         return NULL;
3074 }
3075
3076 char **replace_env_argv(char **argv, char **env) {
3077         char **r, **i;
3078         unsigned k = 0, l = 0;
3079
3080         l = strv_length(argv);
3081
3082         if (!(r = new(char*, l+1)))
3083                 return NULL;
3084
3085         STRV_FOREACH(i, argv) {
3086
3087                 /* If $FOO appears as single word, replace it by the split up variable */
3088                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3089                         char *e;
3090                         char **w, **m;
3091                         unsigned q;
3092
3093                         e = strv_env_get(env, *i+1);
3094                         if (e) {
3095
3096                                 if (!(m = strv_split_quoted(e))) {
3097                                         r[k] = NULL;
3098                                         strv_free(r);
3099                                         return NULL;
3100                                 }
3101                         } else
3102                                 m = NULL;
3103
3104                         q = strv_length(m);
3105                         l = l + q - 1;
3106
3107                         if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3108                                 r[k] = NULL;
3109                                 strv_free(r);
3110                                 strv_free(m);
3111                                 return NULL;
3112                         }
3113
3114                         r = w;
3115                         if (m) {
3116                                 memcpy(r + k, m, q * sizeof(char*));
3117                                 free(m);
3118                         }
3119
3120                         k += q;
3121                         continue;
3122                 }
3123
3124                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3125                 if (!(r[k++] = replace_env(*i, env))) {
3126                         strv_free(r);
3127                         return NULL;
3128                 }
3129         }
3130
3131         r[k] = NULL;
3132         return r;
3133 }
3134
3135 int fd_columns(int fd) {
3136         struct winsize ws = {};
3137
3138         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3139                 return -errno;
3140
3141         if (ws.ws_col <= 0)
3142                 return -EIO;
3143
3144         return ws.ws_col;
3145 }
3146
3147 unsigned columns(void) {
3148         const char *e;
3149         int c;
3150
3151         if (_likely_(cached_columns > 0))
3152                 return cached_columns;
3153
3154         c = 0;
3155         e = getenv("COLUMNS");
3156         if (e)
3157                 safe_atoi(e, &c);
3158
3159         if (c <= 0)
3160                 c = fd_columns(STDOUT_FILENO);
3161
3162         if (c <= 0)
3163                 c = 80;
3164
3165         cached_columns = c;
3166         return c;
3167 }
3168
3169 int fd_lines(int fd) {
3170         struct winsize ws = {};
3171
3172         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3173                 return -errno;
3174
3175         if (ws.ws_row <= 0)
3176                 return -EIO;
3177
3178         return ws.ws_row;
3179 }
3180
3181 unsigned lines(void) {
3182         const char *e;
3183         unsigned l;
3184
3185         if (_likely_(cached_lines > 0))
3186                 return cached_lines;
3187
3188         l = 0;
3189         e = getenv("LINES");
3190         if (e)
3191                 safe_atou(e, &l);
3192
3193         if (l <= 0)
3194                 l = fd_lines(STDOUT_FILENO);
3195
3196         if (l <= 0)
3197                 l = 24;
3198
3199         cached_lines = l;
3200         return cached_lines;
3201 }
3202
3203 /* intended to be used as a SIGWINCH sighandler */
3204 void columns_lines_cache_reset(int signum) {
3205         cached_columns = 0;
3206         cached_lines = 0;
3207 }
3208
3209 bool on_tty(void) {
3210         static int cached_on_tty = -1;
3211
3212         if (_unlikely_(cached_on_tty < 0))
3213                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3214
3215         return cached_on_tty;
3216 }
3217
3218 int running_in_chroot(void) {
3219         struct stat a = {}, b = {};
3220
3221         /* Only works as root */
3222         if (stat("/proc/1/root", &a) < 0)
3223                 return -errno;
3224
3225         if (stat("/", &b) < 0)
3226                 return -errno;
3227
3228         return
3229                 a.st_dev != b.st_dev ||
3230                 a.st_ino != b.st_ino;
3231 }
3232
3233 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3234         size_t x;
3235         char *r;
3236
3237         assert(s);
3238         assert(percent <= 100);
3239         assert(new_length >= 3);
3240
3241         if (old_length <= 3 || old_length <= new_length)
3242                 return strndup(s, old_length);
3243
3244         r = new0(char, new_length+1);
3245         if (!r)
3246                 return NULL;
3247
3248         x = (new_length * percent) / 100;
3249
3250         if (x > new_length - 3)
3251                 x = new_length - 3;
3252
3253         memcpy(r, s, x);
3254         r[x] = '.';
3255         r[x+1] = '.';
3256         r[x+2] = '.';
3257         memcpy(r + x + 3,
3258                s + old_length - (new_length - x - 3),
3259                new_length - x - 3);
3260
3261         return r;
3262 }
3263
3264 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3265         size_t x;
3266         char *e;
3267         const char *i, *j;
3268         unsigned k, len, len2;
3269
3270         assert(s);
3271         assert(percent <= 100);
3272         assert(new_length >= 3);
3273
3274         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3275         if (ascii_is_valid(s))
3276                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3277
3278         if (old_length <= 3 || old_length <= new_length)
3279                 return strndup(s, old_length);
3280
3281         x = (new_length * percent) / 100;
3282
3283         if (x > new_length - 3)
3284                 x = new_length - 3;
3285
3286         k = 0;
3287         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3288                 int c;
3289
3290                 c = utf8_encoded_to_unichar(i);
3291                 if (c < 0)
3292                         return NULL;
3293                 k += unichar_iswide(c) ? 2 : 1;
3294         }
3295
3296         if (k > x) /* last character was wide and went over quota */
3297                 x ++;
3298
3299         for (j = s + old_length; k < new_length && j > i; ) {
3300                 int c;
3301
3302                 j = utf8_prev_char(j);
3303                 c = utf8_encoded_to_unichar(j);
3304                 if (c < 0)
3305                         return NULL;
3306                 k += unichar_iswide(c) ? 2 : 1;
3307         }
3308         assert(i <= j);
3309
3310         /* we don't actually need to ellipsize */
3311         if (i == j)
3312                 return memdup(s, old_length + 1);
3313
3314         /* make space for ellipsis */
3315         j = utf8_next_char(j);
3316
3317         len = i - s;
3318         len2 = s + old_length - j;
3319         e = new(char, len + 3 + len2 + 1);
3320         if (!e)
3321                 return NULL;
3322
3323         /*
3324         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3325                old_length, new_length, x, len, len2, k);
3326         */
3327
3328         memcpy(e, s, len);
3329         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3330         e[len + 1] = 0x80;
3331         e[len + 2] = 0xa6;
3332
3333         memcpy(e + len + 3, j, len2 + 1);
3334
3335         return e;
3336 }
3337
3338 char *ellipsize(const char *s, size_t length, unsigned percent) {
3339         return ellipsize_mem(s, strlen(s), length, percent);
3340 }
3341
3342 int touch(const char *path) {
3343         int fd;
3344
3345         assert(path);
3346
3347         /* This just opens the file for writing, ensuring it
3348          * exists. It doesn't call utimensat() the way /usr/bin/touch
3349          * does it. */
3350
3351         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
3352         if (fd < 0)
3353                 return -errno;
3354
3355         close_nointr_nofail(fd);
3356         return 0;
3357 }
3358
3359 char *unquote(const char *s, const char* quotes) {
3360         size_t l;
3361         assert(s);
3362
3363         /* This is rather stupid, simply removes the heading and
3364          * trailing quotes if there is one. Doesn't care about
3365          * escaping or anything. We should make this smarter one
3366          * day...*/
3367
3368         l = strlen(s);
3369         if (l < 2)
3370                 return strdup(s);
3371
3372         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3373                 return strndup(s+1, l-2);
3374
3375         return strdup(s);
3376 }
3377
3378 char *normalize_env_assignment(const char *s) {
3379         _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3380         char *eq, *r;
3381
3382         eq = strchr(s, '=');
3383         if (!eq) {
3384                 char *t;
3385
3386                 r = strdup(s);
3387                 if (!r)
3388                         return NULL;
3389
3390                 t = strstrip(r);
3391                 if (t == r)
3392                         return r;
3393
3394                 memmove(r, t, strlen(t) + 1);
3395                 return r;
3396         }
3397
3398         name = strndup(s, eq - s);
3399         if (!name)
3400                 return NULL;
3401
3402         p = strdup(eq + 1);
3403         if (!p)
3404                 return NULL;
3405
3406         value = unquote(strstrip(p), QUOTES);
3407         if (!value)
3408                 return NULL;
3409
3410         if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3411                 r = NULL;
3412
3413         return r;
3414 }
3415
3416 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3417         siginfo_t dummy;
3418
3419         assert(pid >= 1);
3420
3421         if (!status)
3422                 status = &dummy;
3423
3424         for (;;) {
3425                 zero(*status);
3426
3427                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3428
3429                         if (errno == EINTR)
3430                                 continue;
3431
3432                         return -errno;
3433                 }
3434
3435                 return 0;
3436         }
3437 }
3438
3439 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3440         int r;
3441         siginfo_t status;
3442
3443         assert(name);
3444         assert(pid > 1);
3445
3446         r = wait_for_terminate(pid, &status);
3447         if (r < 0) {
3448                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3449                 return r;
3450         }
3451
3452         if (status.si_code == CLD_EXITED) {
3453                 if (status.si_status != 0) {
3454                         log_warning("%s failed with error code %i.", name, status.si_status);
3455                         return status.si_status;
3456                 }
3457
3458                 log_debug("%s succeeded.", name);
3459                 return 0;
3460
3461         } else if (status.si_code == CLD_KILLED ||
3462                    status.si_code == CLD_DUMPED) {
3463
3464                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3465                 return -EPROTO;
3466         }
3467
3468         log_warning("%s failed due to unknown reason.", name);
3469         return -EPROTO;
3470 }
3471
3472 _noreturn_ void freeze(void) {
3473
3474         /* Make sure nobody waits for us on a socket anymore */
3475         close_all_fds(NULL, 0);
3476
3477         sync();
3478
3479         for (;;)
3480                 pause();
3481 }
3482
3483 bool null_or_empty(struct stat *st) {
3484         assert(st);
3485
3486         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3487                 return true;
3488
3489         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3490                 return true;
3491
3492         return false;
3493 }
3494
3495 int null_or_empty_path(const char *fn) {
3496         struct stat st;
3497
3498         assert(fn);
3499
3500         if (stat(fn, &st) < 0)
3501                 return -errno;
3502
3503         return null_or_empty(&st);
3504 }
3505
3506 DIR *xopendirat(int fd, const char *name, int flags) {
3507         int nfd;
3508         DIR *d;
3509
3510         assert(!(flags & O_CREAT));
3511
3512         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3513         if (nfd < 0)
3514                 return NULL;
3515
3516         d = fdopendir(nfd);
3517         if (!d) {
3518                 close_nointr_nofail(nfd);
3519                 return NULL;
3520         }
3521
3522         return d;
3523 }
3524
3525 int signal_from_string_try_harder(const char *s) {
3526         int signo;
3527         assert(s);
3528
3529         signo = signal_from_string(s);
3530         if (signo <= 0)
3531                 if (startswith(s, "SIG"))
3532                         return signal_from_string(s+3);
3533
3534         return signo;
3535 }
3536
3537 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3538         _cleanup_free_ char *t = NULL, *u = NULL;
3539         char *dn;
3540         size_t enc_len;
3541
3542         u = unquote(tagvalue, "\"\'");
3543         if (u == NULL)
3544                 return NULL;
3545
3546         enc_len = strlen(u) * 4 + 1;
3547         t = new(char, enc_len);
3548         if (t == NULL)
3549                 return NULL;
3550
3551         if (encode_devnode_name(u, t, enc_len) < 0)
3552                 return NULL;
3553
3554         if (asprintf(&dn, "/dev/disk/by-%s/%s", by, t) < 0)
3555                 return NULL;
3556
3557         return dn;
3558 }
3559
3560 char *fstab_node_to_udev_node(const char *p) {
3561         assert(p);
3562
3563         if (startswith(p, "LABEL="))
3564                 return tag_to_udev_node(p+6, "label");
3565
3566         if (startswith(p, "UUID="))
3567                 return tag_to_udev_node(p+5, "uuid");
3568
3569         if (startswith(p, "PARTUUID="))
3570                 return tag_to_udev_node(p+9, "partuuid");
3571
3572         if (startswith(p, "PARTLABEL="))
3573                 return tag_to_udev_node(p+10, "partlabel");
3574
3575         return strdup(p);
3576 }
3577
3578 bool tty_is_vc(const char *tty) {
3579         assert(tty);
3580
3581         if (startswith(tty, "/dev/"))
3582                 tty += 5;
3583
3584         return vtnr_from_tty(tty) >= 0;
3585 }
3586
3587 bool tty_is_console(const char *tty) {
3588         assert(tty);
3589
3590         if (startswith(tty, "/dev/"))
3591                 tty += 5;
3592
3593         return streq(tty, "console");
3594 }
3595
3596 int vtnr_from_tty(const char *tty) {
3597         int i, r;
3598
3599         assert(tty);
3600
3601         if (startswith(tty, "/dev/"))
3602                 tty += 5;
3603
3604         if (!startswith(tty, "tty") )
3605                 return -EINVAL;
3606
3607         if (tty[3] < '0' || tty[3] > '9')
3608                 return -EINVAL;
3609
3610         r = safe_atoi(tty+3, &i);
3611         if (r < 0)
3612                 return r;
3613
3614         if (i < 0 || i > 63)
3615                 return -EINVAL;
3616
3617         return i;
3618 }
3619
3620 char *resolve_dev_console(char **active) {
3621         char *tty;
3622
3623         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3624          * (i.e. not read-only-mounted which is a sign for container setups) */
3625
3626         if (path_is_read_only_fs("/sys") > 0)
3627                 return NULL;
3628
3629         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3630                 return NULL;
3631
3632         /* If multiple log outputs are configured the last one is what
3633          * /dev/console points to */
3634         tty = strrchr(*active, ' ');
3635         if (tty)
3636                 tty++;
3637         else
3638                 tty = *active;
3639
3640         if (streq(tty, "tty0")) {
3641                 char *tmp;
3642
3643                 /* Get the active VC (e.g. tty1) */
3644                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3645                         free(*active);
3646                         tty = *active = tmp;
3647                 }
3648         }
3649
3650         return tty;
3651 }
3652
3653 bool tty_is_vc_resolve(const char *tty) {
3654         _cleanup_free_ char *active = NULL;
3655
3656         assert(tty);
3657
3658         if (startswith(tty, "/dev/"))
3659                 tty += 5;
3660
3661         if (streq(tty, "console")) {
3662                 tty = resolve_dev_console(&active);
3663                 if (!tty)
3664                         return false;
3665         }
3666
3667         return tty_is_vc(tty);
3668 }
3669
3670 const char *default_term_for_tty(const char *tty) {
3671         assert(tty);
3672
3673         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3674 }
3675
3676 bool dirent_is_file(const struct dirent *de) {
3677         assert(de);
3678
3679         if (ignore_file(de->d_name))
3680                 return false;
3681
3682         if (de->d_type != DT_REG &&
3683             de->d_type != DT_LNK &&
3684             de->d_type != DT_UNKNOWN)
3685                 return false;
3686
3687         return true;
3688 }
3689
3690 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3691         assert(de);
3692
3693         if (de->d_type != DT_REG &&
3694             de->d_type != DT_LNK &&
3695             de->d_type != DT_UNKNOWN)
3696                 return false;
3697
3698         if (ignore_file_allow_backup(de->d_name))
3699                 return false;
3700
3701         return endswith(de->d_name, suffix);
3702 }
3703
3704 void execute_directory(const char *directory, DIR *d, char *argv[]) {
3705         DIR *_d = NULL;
3706         struct dirent *de;
3707         Hashmap *pids = NULL;
3708
3709         assert(directory);
3710
3711         /* Executes all binaries in a directory in parallel and
3712          * waits for them to finish. */
3713
3714         if (!d) {
3715                 if (!(_d = opendir(directory))) {
3716
3717                         if (errno == ENOENT)
3718                                 return;
3719
3720                         log_error("Failed to enumerate directory %s: %m", directory);
3721                         return;
3722                 }
3723
3724                 d = _d;
3725         }
3726
3727         if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
3728                 log_error("Failed to allocate set.");
3729                 goto finish;
3730         }
3731
3732         while ((de = readdir(d))) {
3733                 char *path;
3734                 pid_t pid;
3735                 int k;
3736
3737                 if (!dirent_is_file(de))
3738                         continue;
3739
3740                 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
3741                         log_oom();
3742                         continue;
3743                 }
3744
3745                 if ((pid = fork()) < 0) {
3746                         log_error("Failed to fork: %m");
3747                         free(path);
3748                         continue;
3749                 }
3750
3751                 if (pid == 0) {
3752                         char *_argv[2];
3753                         /* Child */
3754
3755                         if (!argv) {
3756                                 _argv[0] = path;
3757                                 _argv[1] = NULL;
3758                                 argv = _argv;
3759                         } else
3760                                 argv[0] = path;
3761
3762                         execv(path, argv);
3763
3764                         log_error("Failed to execute %s: %m", path);
3765                         _exit(EXIT_FAILURE);
3766                 }
3767
3768                 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
3769
3770                 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
3771                         log_error("Failed to add PID to set: %s", strerror(-k));
3772                         free(path);
3773                 }
3774         }
3775
3776         while (!hashmap_isempty(pids)) {
3777                 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
3778                 siginfo_t si = {};
3779                 char *path;
3780
3781                 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
3782
3783                         if (errno == EINTR)
3784                                 continue;
3785
3786                         log_error("waitid() failed: %m");
3787                         goto finish;
3788                 }
3789
3790                 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
3791                         if (!is_clean_exit(si.si_code, si.si_status, NULL)) {
3792                                 if (si.si_code == CLD_EXITED)
3793                                         log_error("%s exited with exit status %i.", path, si.si_status);
3794                                 else
3795                                         log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
3796                         } else
3797                                 log_debug("%s exited successfully.", path);
3798
3799                         free(path);
3800                 }
3801         }
3802
3803 finish:
3804         if (_d)
3805                 closedir(_d);
3806
3807         if (pids)
3808                 hashmap_free_free(pids);
3809 }
3810
3811 int kill_and_sigcont(pid_t pid, int sig) {
3812         int r;
3813
3814         r = kill(pid, sig) < 0 ? -errno : 0;
3815
3816         if (r >= 0)
3817                 kill(pid, SIGCONT);
3818
3819         return r;
3820 }
3821
3822 bool nulstr_contains(const char*nulstr, const char *needle) {
3823         const char *i;
3824
3825         if (!nulstr)
3826                 return false;
3827
3828         NULSTR_FOREACH(i, nulstr)
3829                 if (streq(i, needle))
3830                         return true;
3831
3832         return false;
3833 }
3834
3835 bool plymouth_running(void) {
3836         return access("/run/plymouth/pid", F_OK) >= 0;
3837 }
3838
3839 char* strshorten(char *s, size_t l) {
3840         assert(s);
3841
3842         if (l < strlen(s))
3843                 s[l] = 0;
3844
3845         return s;
3846 }
3847
3848 static bool hostname_valid_char(char c) {
3849         return
3850                 (c >= 'a' && c <= 'z') ||
3851                 (c >= 'A' && c <= 'Z') ||
3852                 (c >= '0' && c <= '9') ||
3853                 c == '-' ||
3854                 c == '_' ||
3855                 c == '.';
3856 }
3857
3858 bool hostname_is_valid(const char *s) {
3859         const char *p;
3860         bool dot;
3861
3862         if (isempty(s))
3863                 return false;
3864
3865         for (p = s, dot = true; *p; p++) {
3866                 if (*p == '.') {
3867                         if (dot)
3868                                 return false;
3869
3870                         dot = true;
3871                 } else {
3872                         if (!hostname_valid_char(*p))
3873                                 return false;
3874
3875                         dot = false;
3876                 }
3877         }
3878
3879         if (dot)
3880                 return false;
3881
3882         if (p-s > HOST_NAME_MAX)
3883                 return false;
3884
3885         return true;
3886 }
3887
3888 char* hostname_cleanup(char *s, bool lowercase) {
3889         char *p, *d;
3890         bool dot;
3891
3892         for (p = s, d = s, dot = true; *p; p++) {
3893                 if (*p == '.') {
3894                         if (dot)
3895                                 continue;
3896
3897                         *(d++) = '.';
3898                         dot = true;
3899                 } else if (hostname_valid_char(*p)) {
3900                         *(d++) = lowercase ? tolower(*p) : *p;
3901                         dot = false;
3902                 }
3903
3904         }
3905
3906         if (dot && d > s)
3907                 d[-1] = 0;
3908         else
3909                 *d = 0;
3910
3911         strshorten(s, HOST_NAME_MAX);
3912
3913         return s;
3914 }
3915
3916 int pipe_eof(int fd) {
3917         int r;
3918         struct pollfd pollfd = {
3919                 .fd = fd,
3920                 .events = POLLIN|POLLHUP,
3921         };
3922
3923         r = poll(&pollfd, 1, 0);
3924         if (r < 0)
3925                 return -errno;
3926
3927         if (r == 0)
3928                 return 0;
3929
3930         return pollfd.revents & POLLHUP;
3931 }
3932
3933 int fd_wait_for_event(int fd, int event, usec_t t) {
3934         int r;
3935         struct pollfd pollfd = {
3936                 .fd = fd,
3937                 .events = event,
3938         };
3939
3940         r = poll(&pollfd, 1, t == (usec_t) -1 ? -1 : (int) (t / USEC_PER_MSEC));
3941         if (r < 0)
3942                 return -errno;
3943
3944         if (r == 0)
3945                 return 0;
3946
3947         return pollfd.revents;
3948 }
3949
3950 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
3951         FILE *f;
3952         char *t;
3953         const char *fn;
3954         size_t k;
3955         int fd;
3956
3957         assert(path);
3958         assert(_f);
3959         assert(_temp_path);
3960
3961         t = new(char, strlen(path) + 1 + 6 + 1);
3962         if (!t)
3963                 return -ENOMEM;
3964
3965         fn = basename(path);
3966         k = fn - path;
3967         memcpy(t, path, k);
3968         t[k]&nb