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