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