chiark / gitweb /
util: replace close_pipe() with new safe_close_pair()
[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 void safe_close_pair(int p[]) {
2041         assert(p);
2042
2043         if (p[0] == p[1]) {
2044                 /* Special case pairs which use the same fd in both
2045                  * directions... */
2046                 p[0] = p[1] = safe_close(p[0]);
2047                 return;
2048         }
2049
2050         p[0] = safe_close(p[0]);
2051         p[1] = safe_close(p[1]);
2052 }
2053
2054 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2055         uint8_t *p = buf;
2056         ssize_t n = 0;
2057
2058         assert(fd >= 0);
2059         assert(buf);
2060
2061         while (nbytes > 0) {
2062                 ssize_t k;
2063
2064                 k = read(fd, p, nbytes);
2065                 if (k < 0 && errno == EINTR)
2066                         continue;
2067
2068                 if (k < 0 && errno == EAGAIN && do_poll) {
2069
2070                         /* We knowingly ignore any return value here,
2071                          * and expect that any error/EOF is reported
2072                          * via read() */
2073
2074                         fd_wait_for_event(fd, POLLIN, (usec_t) -1);
2075                         continue;
2076                 }
2077
2078                 if (k <= 0)
2079                         return n > 0 ? n : (k < 0 ? -errno : 0);
2080
2081                 p += k;
2082                 nbytes -= k;
2083                 n += k;
2084         }
2085
2086         return n;
2087 }
2088
2089 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2090         const uint8_t *p = buf;
2091         ssize_t n = 0;
2092
2093         assert(fd >= 0);
2094         assert(buf);
2095
2096         while (nbytes > 0) {
2097                 ssize_t k;
2098
2099                 k = write(fd, p, nbytes);
2100                 if (k < 0 && errno == EINTR)
2101                         continue;
2102
2103                 if (k < 0 && errno == EAGAIN && do_poll) {
2104
2105                         /* We knowingly ignore any return value here,
2106                          * and expect that any error/EOF is reported
2107                          * via write() */
2108
2109                         fd_wait_for_event(fd, POLLOUT, (usec_t) -1);
2110                         continue;
2111                 }
2112
2113                 if (k <= 0)
2114                         return n > 0 ? n : (k < 0 ? -errno : 0);
2115
2116                 p += k;
2117                 nbytes -= k;
2118                 n += k;
2119         }
2120
2121         return n;
2122 }
2123
2124 int parse_size(const char *t, off_t base, off_t *size) {
2125
2126         /* Soo, sometimes we want to parse IEC binary suffxies, and
2127          * sometimes SI decimal suffixes. This function can parse
2128          * both. Which one is the right way depends on the
2129          * context. Wikipedia suggests that SI is customary for
2130          * hardrware metrics and network speeds, while IEC is
2131          * customary for most data sizes used by software and volatile
2132          * (RAM) memory. Hence be careful which one you pick!
2133          *
2134          * In either case we use just K, M, G as suffix, and not Ki,
2135          * Mi, Gi or so (as IEC would suggest). That's because that's
2136          * frickin' ugly. But this means you really need to make sure
2137          * to document which base you are parsing when you use this
2138          * call. */
2139
2140         struct table {
2141                 const char *suffix;
2142                 unsigned long long factor;
2143         };
2144
2145         static const struct table iec[] = {
2146                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2147                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2148                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2149                 { "G", 1024ULL*1024ULL*1024ULL },
2150                 { "M", 1024ULL*1024ULL },
2151                 { "K", 1024ULL },
2152                 { "B", 1 },
2153                 { "", 1 },
2154         };
2155
2156         static const struct table si[] = {
2157                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2158                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2159                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2160                 { "G", 1000ULL*1000ULL*1000ULL },
2161                 { "M", 1000ULL*1000ULL },
2162                 { "K", 1000ULL },
2163                 { "B", 1 },
2164                 { "", 1 },
2165         };
2166
2167         const struct table *table;
2168         const char *p;
2169         unsigned long long r = 0;
2170         unsigned n_entries, start_pos = 0;
2171
2172         assert(t);
2173         assert(base == 1000 || base == 1024);
2174         assert(size);
2175
2176         if (base == 1000) {
2177                 table = si;
2178                 n_entries = ELEMENTSOF(si);
2179         } else {
2180                 table = iec;
2181                 n_entries = ELEMENTSOF(iec);
2182         }
2183
2184         p = t;
2185         do {
2186                 long long l;
2187                 unsigned long long l2;
2188                 double frac = 0;
2189                 char *e;
2190                 unsigned i;
2191
2192                 errno = 0;
2193                 l = strtoll(p, &e, 10);
2194
2195                 if (errno > 0)
2196                         return -errno;
2197
2198                 if (l < 0)
2199                         return -ERANGE;
2200
2201                 if (e == p)
2202                         return -EINVAL;
2203
2204                 if (*e == '.') {
2205                         e++;
2206                         if (*e >= '0' && *e <= '9') {
2207                                 char *e2;
2208
2209                                 /* strotoull itself would accept space/+/- */
2210                                 l2 = strtoull(e, &e2, 10);
2211
2212                                 if (errno == ERANGE)
2213                                         return -errno;
2214
2215                                 /* Ignore failure. E.g. 10.M is valid */
2216                                 frac = l2;
2217                                 for (; e < e2; e++)
2218                                         frac /= 10;
2219                         }
2220                 }
2221
2222                 e += strspn(e, WHITESPACE);
2223
2224                 for (i = start_pos; i < n_entries; i++)
2225                         if (startswith(e, table[i].suffix)) {
2226                                 unsigned long long tmp;
2227                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2228                                         return -ERANGE;
2229                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2230                                 if (tmp > ULLONG_MAX - r)
2231                                         return -ERANGE;
2232
2233                                 r += tmp;
2234                                 if ((unsigned long long) (off_t) r != r)
2235                                         return -ERANGE;
2236
2237                                 p = e + strlen(table[i].suffix);
2238
2239                                 start_pos = i + 1;
2240                                 break;
2241                         }
2242
2243                 if (i >= n_entries)
2244                         return -EINVAL;
2245
2246         } while (*p);
2247
2248         *size = r;
2249
2250         return 0;
2251 }
2252
2253 int make_stdio(int fd) {
2254         int r, s, t;
2255
2256         assert(fd >= 0);
2257
2258         r = dup3(fd, STDIN_FILENO, 0);
2259         s = dup3(fd, STDOUT_FILENO, 0);
2260         t = dup3(fd, STDERR_FILENO, 0);
2261
2262         if (fd >= 3)
2263                 safe_close(fd);
2264
2265         if (r < 0 || s < 0 || t < 0)
2266                 return -errno;
2267
2268         /* We rely here that the new fd has O_CLOEXEC not set */
2269
2270         return 0;
2271 }
2272
2273 int make_null_stdio(void) {
2274         int null_fd;
2275
2276         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2277         if (null_fd < 0)
2278                 return -errno;
2279
2280         return make_stdio(null_fd);
2281 }
2282
2283 bool is_device_path(const char *path) {
2284
2285         /* Returns true on paths that refer to a device, either in
2286          * sysfs or in /dev */
2287
2288         return
2289                 path_startswith(path, "/dev/") ||
2290                 path_startswith(path, "/sys/");
2291 }
2292
2293 int dir_is_empty(const char *path) {
2294         _cleanup_closedir_ DIR *d;
2295
2296         d = opendir(path);
2297         if (!d)
2298                 return -errno;
2299
2300         for (;;) {
2301                 struct dirent *de;
2302
2303                 errno = 0;
2304                 de = readdir(d);
2305                 if (!de && errno != 0)
2306                         return -errno;
2307
2308                 if (!de)
2309                         return 1;
2310
2311                 if (!ignore_file(de->d_name))
2312                         return 0;
2313         }
2314 }
2315
2316 char* dirname_malloc(const char *path) {
2317         char *d, *dir, *dir2;
2318
2319         d = strdup(path);
2320         if (!d)
2321                 return NULL;
2322         dir = dirname(d);
2323         assert(dir);
2324
2325         if (dir != d) {
2326                 dir2 = strdup(dir);
2327                 free(d);
2328                 return dir2;
2329         }
2330
2331         return dir;
2332 }
2333
2334 int dev_urandom(void *p, size_t n) {
2335         _cleanup_close_ int fd;
2336         ssize_t k;
2337
2338         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2339         if (fd < 0)
2340                 return errno == ENOENT ? -ENOSYS : -errno;
2341
2342         k = loop_read(fd, p, n, true);
2343         if (k < 0)
2344                 return (int) k;
2345         if ((size_t) k != n)
2346                 return -EIO;
2347
2348         return 0;
2349 }
2350
2351 void random_bytes(void *p, size_t n) {
2352         static bool srand_called = false;
2353         uint8_t *q;
2354         int r;
2355
2356         r = dev_urandom(p, n);
2357         if (r >= 0)
2358                 return;
2359
2360         /* If some idiot made /dev/urandom unavailable to us, he'll
2361          * get a PRNG instead. */
2362
2363         if (!srand_called) {
2364                 unsigned x = 0;
2365
2366 #ifdef HAVE_SYS_AUXV_H
2367                 /* The kernel provides us with a bit of entropy in
2368                  * auxv, so let's try to make use of that to seed the
2369                  * pseudo-random generator. It's better than
2370                  * nothing... */
2371
2372                 void *auxv;
2373
2374                 auxv = (void*) getauxval(AT_RANDOM);
2375                 if (auxv)
2376                         x ^= *(unsigned*) auxv;
2377 #endif
2378
2379                 x ^= (unsigned) now(CLOCK_REALTIME);
2380                 x ^= (unsigned) gettid();
2381
2382                 srand(x);
2383                 srand_called = true;
2384         }
2385
2386         for (q = p; q < (uint8_t*) p + n; q ++)
2387                 *q = rand();
2388 }
2389
2390 void rename_process(const char name[8]) {
2391         assert(name);
2392
2393         /* This is a like a poor man's setproctitle(). It changes the
2394          * comm field, argv[0], and also the glibc's internally used
2395          * name of the process. For the first one a limit of 16 chars
2396          * applies, to the second one usually one of 10 (i.e. length
2397          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2398          * "systemd"). If you pass a longer string it will be
2399          * truncated */
2400
2401         prctl(PR_SET_NAME, name);
2402
2403         if (program_invocation_name)
2404                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2405
2406         if (saved_argc > 0) {
2407                 int i;
2408
2409                 if (saved_argv[0])
2410                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2411
2412                 for (i = 1; i < saved_argc; i++) {
2413                         if (!saved_argv[i])
2414                                 break;
2415
2416                         memzero(saved_argv[i], strlen(saved_argv[i]));
2417                 }
2418         }
2419 }
2420
2421 void sigset_add_many(sigset_t *ss, ...) {
2422         va_list ap;
2423         int sig;
2424
2425         assert(ss);
2426
2427         va_start(ap, ss);
2428         while ((sig = va_arg(ap, int)) > 0)
2429                 assert_se(sigaddset(ss, sig) == 0);
2430         va_end(ap);
2431 }
2432
2433 char* gethostname_malloc(void) {
2434         struct utsname u;
2435
2436         assert_se(uname(&u) >= 0);
2437
2438         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2439                 return strdup(u.nodename);
2440
2441         return strdup(u.sysname);
2442 }
2443
2444 bool hostname_is_set(void) {
2445         struct utsname u;
2446
2447         assert_se(uname(&u) >= 0);
2448
2449         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2450 }
2451
2452 static char *lookup_uid(uid_t uid) {
2453         long bufsize;
2454         char *name;
2455         _cleanup_free_ char *buf = NULL;
2456         struct passwd pwbuf, *pw = NULL;
2457
2458         /* Shortcut things to avoid NSS lookups */
2459         if (uid == 0)
2460                 return strdup("root");
2461
2462         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2463         if (bufsize <= 0)
2464                 bufsize = 4096;
2465
2466         buf = malloc(bufsize);
2467         if (!buf)
2468                 return NULL;
2469
2470         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2471                 return strdup(pw->pw_name);
2472
2473         if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
2474                 return NULL;
2475
2476         return name;
2477 }
2478
2479 char* getlogname_malloc(void) {
2480         uid_t uid;
2481         struct stat st;
2482
2483         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2484                 uid = st.st_uid;
2485         else
2486                 uid = getuid();
2487
2488         return lookup_uid(uid);
2489 }
2490
2491 char *getusername_malloc(void) {
2492         const char *e;
2493
2494         e = getenv("USER");
2495         if (e)
2496                 return strdup(e);
2497
2498         return lookup_uid(getuid());
2499 }
2500
2501 int getttyname_malloc(int fd, char **r) {
2502         char path[PATH_MAX], *c;
2503         int k;
2504
2505         assert(r);
2506
2507         k = ttyname_r(fd, path, sizeof(path));
2508         if (k > 0)
2509                 return -k;
2510
2511         char_array_0(path);
2512
2513         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2514         if (!c)
2515                 return -ENOMEM;
2516
2517         *r = c;
2518         return 0;
2519 }
2520
2521 int getttyname_harder(int fd, char **r) {
2522         int k;
2523         char *s;
2524
2525         k = getttyname_malloc(fd, &s);
2526         if (k < 0)
2527                 return k;
2528
2529         if (streq(s, "tty")) {
2530                 free(s);
2531                 return get_ctty(0, NULL, r);
2532         }
2533
2534         *r = s;
2535         return 0;
2536 }
2537
2538 int get_ctty_devnr(pid_t pid, dev_t *d) {
2539         int r;
2540         _cleanup_free_ char *line = NULL;
2541         const char *p;
2542         unsigned long ttynr;
2543
2544         assert(pid >= 0);
2545
2546         p = procfs_file_alloca(pid, "stat");
2547         r = read_one_line_file(p, &line);
2548         if (r < 0)
2549                 return r;
2550
2551         p = strrchr(line, ')');
2552         if (!p)
2553                 return -EIO;
2554
2555         p++;
2556
2557         if (sscanf(p, " "
2558                    "%*c "  /* state */
2559                    "%*d "  /* ppid */
2560                    "%*d "  /* pgrp */
2561                    "%*d "  /* session */
2562                    "%lu ", /* ttynr */
2563                    &ttynr) != 1)
2564                 return -EIO;
2565
2566         if (major(ttynr) == 0 && minor(ttynr) == 0)
2567                 return -ENOENT;
2568
2569         if (d)
2570                 *d = (dev_t) ttynr;
2571
2572         return 0;
2573 }
2574
2575 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2576         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2577         _cleanup_free_ char *s = NULL;
2578         const char *p;
2579         dev_t devnr;
2580         int k;
2581
2582         assert(r);
2583
2584         k = get_ctty_devnr(pid, &devnr);
2585         if (k < 0)
2586                 return k;
2587
2588         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2589
2590         k = readlink_malloc(fn, &s);
2591         if (k < 0) {
2592
2593                 if (k != -ENOENT)
2594                         return k;
2595
2596                 /* This is an ugly hack */
2597                 if (major(devnr) == 136) {
2598                         asprintf(&b, "pts/%lu", (unsigned long) minor(devnr));
2599                         goto finish;
2600                 }
2601
2602                 /* Probably something like the ptys which have no
2603                  * symlink in /dev/char. Let's return something
2604                  * vaguely useful. */
2605
2606                 b = strdup(fn + 5);
2607                 goto finish;
2608         }
2609
2610         if (startswith(s, "/dev/"))
2611                 p = s + 5;
2612         else if (startswith(s, "../"))
2613                 p = s + 3;
2614         else
2615                 p = s;
2616
2617         b = strdup(p);
2618
2619 finish:
2620         if (!b)
2621                 return -ENOMEM;
2622
2623         *r = b;
2624         if (_devnr)
2625                 *_devnr = devnr;
2626
2627         return 0;
2628 }
2629
2630 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2631         DIR *d;
2632         int ret = 0;
2633
2634         assert(fd >= 0);
2635
2636         /* This returns the first error we run into, but nevertheless
2637          * tries to go on. This closes the passed fd. */
2638
2639         d = fdopendir(fd);
2640         if (!d) {
2641                 safe_close(fd);
2642
2643                 return errno == ENOENT ? 0 : -errno;
2644         }
2645
2646         for (;;) {
2647                 struct dirent *de;
2648                 bool is_dir, keep_around;
2649                 struct stat st;
2650                 int r;
2651
2652                 errno = 0;
2653                 de = readdir(d);
2654                 if (!de && errno != 0) {
2655                         if (ret == 0)
2656                                 ret = -errno;
2657                         break;
2658                 }
2659
2660                 if (!de)
2661                         break;
2662
2663                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2664                         continue;
2665
2666                 if (de->d_type == DT_UNKNOWN ||
2667                     honour_sticky ||
2668                     (de->d_type == DT_DIR && root_dev)) {
2669                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2670                                 if (ret == 0 && errno != ENOENT)
2671                                         ret = -errno;
2672                                 continue;
2673                         }
2674
2675                         is_dir = S_ISDIR(st.st_mode);
2676                         keep_around =
2677                                 honour_sticky &&
2678                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2679                                 (st.st_mode & S_ISVTX);
2680                 } else {
2681                         is_dir = de->d_type == DT_DIR;
2682                         keep_around = false;
2683                 }
2684
2685                 if (is_dir) {
2686                         int subdir_fd;
2687
2688                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2689                         if (root_dev && st.st_dev != root_dev->st_dev)
2690                                 continue;
2691
2692                         subdir_fd = openat(fd, de->d_name,
2693                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2694                         if (subdir_fd < 0) {
2695                                 if (ret == 0 && errno != ENOENT)
2696                                         ret = -errno;
2697                                 continue;
2698                         }
2699
2700                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2701                         if (r < 0 && ret == 0)
2702                                 ret = r;
2703
2704                         if (!keep_around)
2705                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2706                                         if (ret == 0 && errno != ENOENT)
2707                                                 ret = -errno;
2708                                 }
2709
2710                 } else if (!only_dirs && !keep_around) {
2711
2712                         if (unlinkat(fd, de->d_name, 0) < 0) {
2713                                 if (ret == 0 && errno != ENOENT)
2714                                         ret = -errno;
2715                         }
2716                 }
2717         }
2718
2719         closedir(d);
2720
2721         return ret;
2722 }
2723
2724 _pure_ static int is_temporary_fs(struct statfs *s) {
2725         assert(s);
2726
2727         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2728                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2729 }
2730
2731 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2732         struct statfs s;
2733
2734         assert(fd >= 0);
2735
2736         if (fstatfs(fd, &s) < 0) {
2737                 safe_close(fd);
2738                 return -errno;
2739         }
2740
2741         /* We refuse to clean disk file systems with this call. This
2742          * is extra paranoia just to be sure we never ever remove
2743          * non-state data */
2744         if (!is_temporary_fs(&s)) {
2745                 log_error("Attempted to remove disk file system, and we can't allow that.");
2746                 safe_close(fd);
2747                 return -EPERM;
2748         }
2749
2750         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2751 }
2752
2753 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2754         int fd, r;
2755         struct statfs s;
2756
2757         assert(path);
2758
2759         /* We refuse to clean the root file system with this
2760          * call. This is extra paranoia to never cause a really
2761          * seriously broken system. */
2762         if (path_equal(path, "/")) {
2763                 log_error("Attempted to remove entire root file system, and we can't allow that.");
2764                 return -EPERM;
2765         }
2766
2767         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2768         if (fd < 0) {
2769
2770                 if (errno != ENOTDIR)
2771                         return -errno;
2772
2773                 if (!dangerous) {
2774                         if (statfs(path, &s) < 0)
2775                                 return -errno;
2776
2777                         if (!is_temporary_fs(&s)) {
2778                                 log_error("Attempted to remove disk file system, and we can't allow that.");
2779                                 return -EPERM;
2780                         }
2781                 }
2782
2783                 if (delete_root && !only_dirs)
2784                         if (unlink(path) < 0 && errno != ENOENT)
2785                                 return -errno;
2786
2787                 return 0;
2788         }
2789
2790         if (!dangerous) {
2791                 if (fstatfs(fd, &s) < 0) {
2792                         safe_close(fd);
2793                         return -errno;
2794                 }
2795
2796                 if (!is_temporary_fs(&s)) {
2797                         log_error("Attempted to remove disk file system, and we can't allow that.");
2798                         safe_close(fd);
2799                         return -EPERM;
2800                 }
2801         }
2802
2803         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2804         if (delete_root) {
2805
2806                 if (honour_sticky && file_is_priv_sticky(path) > 0)
2807                         return r;
2808
2809                 if (rmdir(path) < 0 && errno != ENOENT) {
2810                         if (r == 0)
2811                                 r = -errno;
2812                 }
2813         }
2814
2815         return r;
2816 }
2817
2818 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2819         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2820 }
2821
2822 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2823         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2824 }
2825
2826 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2827         assert(path);
2828
2829         /* Under the assumption that we are running privileged we
2830          * first change the access mode and only then hand out
2831          * ownership to avoid a window where access is too open. */
2832
2833         if (mode != (mode_t) -1)
2834                 if (chmod(path, mode) < 0)
2835                         return -errno;
2836
2837         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2838                 if (chown(path, uid, gid) < 0)
2839                         return -errno;
2840
2841         return 0;
2842 }
2843
2844 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2845         assert(fd >= 0);
2846
2847         /* Under the assumption that we are running privileged we
2848          * first change the access mode and only then hand out
2849          * ownership to avoid a window where access is too open. */
2850
2851         if (mode != (mode_t) -1)
2852                 if (fchmod(fd, mode) < 0)
2853                         return -errno;
2854
2855         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2856                 if (fchown(fd, uid, gid) < 0)
2857                         return -errno;
2858
2859         return 0;
2860 }
2861
2862 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2863         cpu_set_t *r;
2864         unsigned n = 1024;
2865
2866         /* Allocates the cpuset in the right size */
2867
2868         for (;;) {
2869                 if (!(r = CPU_ALLOC(n)))
2870                         return NULL;
2871
2872                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2873                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2874
2875                         if (ncpus)
2876                                 *ncpus = n;
2877
2878                         return r;
2879                 }
2880
2881                 CPU_FREE(r);
2882
2883                 if (errno != EINVAL)
2884                         return NULL;
2885
2886                 n *= 2;
2887         }
2888 }
2889
2890 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2891         static const char status_indent[] = "         "; /* "[" STATUS "] " */
2892         _cleanup_free_ char *s = NULL;
2893         _cleanup_close_ int fd = -1;
2894         struct iovec iovec[6] = {};
2895         int n = 0;
2896         static bool prev_ephemeral;
2897
2898         assert(format);
2899
2900         /* This is independent of logging, as status messages are
2901          * optional and go exclusively to the console. */
2902
2903         if (vasprintf(&s, format, ap) < 0)
2904                 return log_oom();
2905
2906         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2907         if (fd < 0)
2908                 return fd;
2909
2910         if (ellipse) {
2911                 char *e;
2912                 size_t emax, sl;
2913                 int c;
2914
2915                 c = fd_columns(fd);
2916                 if (c <= 0)
2917                         c = 80;
2918
2919                 sl = status ? sizeof(status_indent)-1 : 0;
2920
2921                 emax = c - sl - 1;
2922                 if (emax < 3)
2923                         emax = 3;
2924
2925                 e = ellipsize(s, emax, 75);
2926                 if (e) {
2927                         free(s);
2928                         s = e;
2929                 }
2930         }
2931
2932         if (prev_ephemeral)
2933                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2934         prev_ephemeral = ephemeral;
2935
2936         if (status) {
2937                 if (!isempty(status)) {
2938                         IOVEC_SET_STRING(iovec[n++], "[");
2939                         IOVEC_SET_STRING(iovec[n++], status);
2940                         IOVEC_SET_STRING(iovec[n++], "] ");
2941                 } else
2942                         IOVEC_SET_STRING(iovec[n++], status_indent);
2943         }
2944
2945         IOVEC_SET_STRING(iovec[n++], s);
2946         if (!ephemeral)
2947                 IOVEC_SET_STRING(iovec[n++], "\n");
2948
2949         if (writev(fd, iovec, n) < 0)
2950                 return -errno;
2951
2952         return 0;
2953 }
2954
2955 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
2956         va_list ap;
2957         int r;
2958
2959         assert(format);
2960
2961         va_start(ap, format);
2962         r = status_vprintf(status, ellipse, ephemeral, format, ap);
2963         va_end(ap);
2964
2965         return r;
2966 }
2967
2968 char *replace_env(const char *format, char **env) {
2969         enum {
2970                 WORD,
2971                 CURLY,
2972                 VARIABLE
2973         } state = WORD;
2974
2975         const char *e, *word = format;
2976         char *r = NULL, *k;
2977
2978         assert(format);
2979
2980         for (e = format; *e; e ++) {
2981
2982                 switch (state) {
2983
2984                 case WORD:
2985                         if (*e == '$')
2986                                 state = CURLY;
2987                         break;
2988
2989                 case CURLY:
2990                         if (*e == '{') {
2991                                 if (!(k = strnappend(r, word, e-word-1)))
2992                                         goto fail;
2993
2994                                 free(r);
2995                                 r = k;
2996
2997                                 word = e-1;
2998                                 state = VARIABLE;
2999
3000                         } else if (*e == '$') {
3001                                 if (!(k = strnappend(r, word, e-word)))
3002                                         goto fail;
3003
3004                                 free(r);
3005                                 r = k;
3006
3007                                 word = e+1;
3008                                 state = WORD;
3009                         } else
3010                                 state = WORD;
3011                         break;
3012
3013                 case VARIABLE:
3014                         if (*e == '}') {
3015                                 const char *t;
3016
3017                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3018
3019                                 k = strappend(r, t);
3020                                 if (!k)
3021                                         goto fail;
3022
3023                                 free(r);
3024                                 r = k;
3025
3026                                 word = e+1;
3027                                 state = WORD;
3028                         }
3029                         break;
3030                 }
3031         }
3032
3033         if (!(k = strnappend(r, word, e-word)))
3034                 goto fail;
3035
3036         free(r);
3037         return k;
3038
3039 fail:
3040         free(r);
3041         return NULL;
3042 }
3043
3044 char **replace_env_argv(char **argv, char **env) {
3045         char **r, **i;
3046         unsigned k = 0, l = 0;
3047
3048         l = strv_length(argv);
3049
3050         if (!(r = new(char*, l+1)))
3051                 return NULL;
3052
3053         STRV_FOREACH(i, argv) {
3054
3055                 /* If $FOO appears as single word, replace it by the split up variable */
3056                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3057                         char *e;
3058                         char **w, **m;
3059                         unsigned q;
3060
3061                         e = strv_env_get(env, *i+1);
3062                         if (e) {
3063
3064                                 if (!(m = strv_split_quoted(e))) {
3065                                         r[k] = NULL;
3066                                         strv_free(r);
3067                                         return NULL;
3068                                 }
3069                         } else
3070                                 m = NULL;
3071
3072                         q = strv_length(m);
3073                         l = l + q - 1;
3074
3075                         if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3076                                 r[k] = NULL;
3077                                 strv_free(r);
3078                                 strv_free(m);
3079                                 return NULL;
3080                         }
3081
3082                         r = w;
3083                         if (m) {
3084                                 memcpy(r + k, m, q * sizeof(char*));
3085                                 free(m);
3086                         }
3087
3088                         k += q;
3089                         continue;
3090                 }
3091
3092                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3093                 if (!(r[k++] = replace_env(*i, env))) {
3094                         strv_free(r);
3095                         return NULL;
3096                 }
3097         }
3098
3099         r[k] = NULL;
3100         return r;
3101 }
3102
3103 int fd_columns(int fd) {
3104         struct winsize ws = {};
3105
3106         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3107                 return -errno;
3108
3109         if (ws.ws_col <= 0)
3110                 return -EIO;
3111
3112         return ws.ws_col;
3113 }
3114
3115 unsigned columns(void) {
3116         const char *e;
3117         int c;
3118
3119         if (_likely_(cached_columns > 0))
3120                 return cached_columns;
3121
3122         c = 0;
3123         e = getenv("COLUMNS");
3124         if (e)
3125                 safe_atoi(e, &c);
3126
3127         if (c <= 0)
3128                 c = fd_columns(STDOUT_FILENO);
3129
3130         if (c <= 0)
3131                 c = 80;
3132
3133         cached_columns = c;
3134         return c;
3135 }
3136
3137 int fd_lines(int fd) {
3138         struct winsize ws = {};
3139
3140         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3141                 return -errno;
3142
3143         if (ws.ws_row <= 0)
3144                 return -EIO;
3145
3146         return ws.ws_row;
3147 }
3148
3149 unsigned lines(void) {
3150         const char *e;
3151         unsigned l;
3152
3153         if (_likely_(cached_lines > 0))
3154                 return cached_lines;
3155
3156         l = 0;
3157         e = getenv("LINES");
3158         if (e)
3159                 safe_atou(e, &l);
3160
3161         if (l <= 0)
3162                 l = fd_lines(STDOUT_FILENO);
3163
3164         if (l <= 0)
3165                 l = 24;
3166
3167         cached_lines = l;
3168         return cached_lines;
3169 }
3170
3171 /* intended to be used as a SIGWINCH sighandler */
3172 void columns_lines_cache_reset(int signum) {
3173         cached_columns = 0;
3174         cached_lines = 0;
3175 }
3176
3177 bool on_tty(void) {
3178         static int cached_on_tty = -1;
3179
3180         if (_unlikely_(cached_on_tty < 0))
3181                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3182
3183         return cached_on_tty;
3184 }
3185
3186 int files_same(const char *filea, const char *fileb) {
3187         struct stat a, b;
3188
3189         if (stat(filea, &a) < 0)
3190                 return -errno;
3191
3192         if (stat(fileb, &b) < 0)
3193                 return -errno;
3194
3195         return a.st_dev == b.st_dev &&
3196                a.st_ino == b.st_ino;
3197 }
3198
3199 int running_in_chroot(void) {
3200         int ret;
3201
3202         ret = files_same("/proc/1/root", "/");
3203         if (ret < 0)
3204                 return ret;
3205
3206         return ret == 0;
3207 }
3208
3209 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3210         size_t x;
3211         char *r;
3212
3213         assert(s);
3214         assert(percent <= 100);
3215         assert(new_length >= 3);
3216
3217         if (old_length <= 3 || old_length <= new_length)
3218                 return strndup(s, old_length);
3219
3220         r = new0(char, new_length+1);
3221         if (!r)
3222                 return NULL;
3223
3224         x = (new_length * percent) / 100;
3225
3226         if (x > new_length - 3)
3227                 x = new_length - 3;
3228
3229         memcpy(r, s, x);
3230         r[x] = '.';
3231         r[x+1] = '.';
3232         r[x+2] = '.';
3233         memcpy(r + x + 3,
3234                s + old_length - (new_length - x - 3),
3235                new_length - x - 3);
3236
3237         return r;
3238 }
3239
3240 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3241         size_t x;
3242         char *e;
3243         const char *i, *j;
3244         unsigned k, len, len2;
3245
3246         assert(s);
3247         assert(percent <= 100);
3248         assert(new_length >= 3);
3249
3250         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3251         if (ascii_is_valid(s))
3252                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3253
3254         if (old_length <= 3 || old_length <= new_length)
3255                 return strndup(s, old_length);
3256
3257         x = (new_length * percent) / 100;
3258
3259         if (x > new_length - 3)
3260                 x = new_length - 3;
3261
3262         k = 0;
3263         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3264                 int c;
3265
3266                 c = utf8_encoded_to_unichar(i);
3267                 if (c < 0)
3268                         return NULL;
3269                 k += unichar_iswide(c) ? 2 : 1;
3270         }
3271
3272         if (k > x) /* last character was wide and went over quota */
3273                 x ++;
3274
3275         for (j = s + old_length; k < new_length && j > i; ) {
3276                 int c;
3277
3278                 j = utf8_prev_char(j);
3279                 c = utf8_encoded_to_unichar(j);
3280                 if (c < 0)
3281                         return NULL;
3282                 k += unichar_iswide(c) ? 2 : 1;
3283         }
3284         assert(i <= j);
3285
3286         /* we don't actually need to ellipsize */
3287         if (i == j)
3288                 return memdup(s, old_length + 1);
3289
3290         /* make space for ellipsis */
3291         j = utf8_next_char(j);
3292
3293         len = i - s;
3294         len2 = s + old_length - j;
3295         e = new(char, len + 3 + len2 + 1);
3296         if (!e)
3297                 return NULL;
3298
3299         /*
3300         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3301                old_length, new_length, x, len, len2, k);
3302         */
3303
3304         memcpy(e, s, len);
3305         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3306         e[len + 1] = 0x80;
3307         e[len + 2] = 0xa6;
3308
3309         memcpy(e + len + 3, j, len2 + 1);
3310
3311         return e;
3312 }
3313
3314 char *ellipsize(const char *s, size_t length, unsigned percent) {
3315         return ellipsize_mem(s, strlen(s), length, percent);
3316 }
3317
3318 int touch(const char *path) {
3319         _cleanup_close_ int fd;
3320
3321         assert(path);
3322
3323         /* This just opens the file for writing, ensuring it
3324          * exists. It doesn't call utimensat() the way /usr/bin/touch
3325          * does it. */
3326
3327         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
3328         if (fd < 0)
3329                 return -errno;
3330
3331         return 0;
3332 }
3333
3334 char *unquote(const char *s, const char* quotes) {
3335         size_t l;
3336         assert(s);
3337
3338         /* This is rather stupid, simply removes the heading and
3339          * trailing quotes if there is one. Doesn't care about
3340          * escaping or anything. We should make this smarter one
3341          * day...*/
3342
3343         l = strlen(s);
3344         if (l < 2)
3345                 return strdup(s);
3346
3347         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3348                 return strndup(s+1, l-2);
3349
3350         return strdup(s);
3351 }
3352
3353 char *normalize_env_assignment(const char *s) {
3354         _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3355         char *eq, *r;
3356
3357         eq = strchr(s, '=');
3358         if (!eq) {
3359                 char *t;
3360
3361                 r = strdup(s);
3362                 if (!r)
3363                         return NULL;
3364
3365                 t = strstrip(r);
3366                 if (t == r)
3367                         return r;
3368
3369                 memmove(r, t, strlen(t) + 1);
3370                 return r;
3371         }
3372
3373         name = strndup(s, eq - s);
3374         if (!name)
3375                 return NULL;
3376
3377         p = strdup(eq + 1);
3378         if (!p)
3379                 return NULL;
3380
3381         value = unquote(strstrip(p), QUOTES);
3382         if (!value)
3383                 return NULL;
3384
3385         if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3386                 r = NULL;
3387
3388         return r;
3389 }
3390
3391 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3392         siginfo_t dummy;
3393
3394         assert(pid >= 1);
3395
3396         if (!status)
3397                 status = &dummy;
3398
3399         for (;;) {
3400                 zero(*status);
3401
3402                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3403
3404                         if (errno == EINTR)
3405                                 continue;
3406