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