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