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