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