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