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