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