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