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