chiark / gitweb /
util: treat fuse.sshfs as a network filesystem
[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 readlinkat_malloc(int fd, 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 = readlinkat(fd, 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_malloc(const char *p, char **ret) {
841         return readlinkat_malloc(AT_FDCWD, p, ret);
842 }
843
844 int readlink_and_make_absolute(const char *p, char **r) {
845         _cleanup_free_ char *target = NULL;
846         char *k;
847         int j;
848
849         assert(p);
850         assert(r);
851
852         j = readlink_malloc(p, &target);
853         if (j < 0)
854                 return j;
855
856         k = file_in_same_dir(p, target);
857         if (!k)
858                 return -ENOMEM;
859
860         *r = k;
861         return 0;
862 }
863
864 int readlink_and_canonicalize(const char *p, char **r) {
865         char *t, *s;
866         int j;
867
868         assert(p);
869         assert(r);
870
871         j = readlink_and_make_absolute(p, &t);
872         if (j < 0)
873                 return j;
874
875         s = canonicalize_file_name(t);
876         if (s) {
877                 free(t);
878                 *r = s;
879         } else
880                 *r = t;
881
882         path_kill_slashes(*r);
883
884         return 0;
885 }
886
887 int reset_all_signal_handlers(void) {
888         int sig;
889
890         for (sig = 1; sig < _NSIG; sig++) {
891                 struct sigaction sa = {
892                         .sa_handler = SIG_DFL,
893                         .sa_flags = SA_RESTART,
894                 };
895
896                 if (sig == SIGKILL || sig == SIGSTOP)
897                         continue;
898
899                 /* On Linux the first two RT signals are reserved by
900                  * glibc, and sigaction() will return EINVAL for them. */
901                 if ((sigaction(sig, &sa, NULL) < 0))
902                         if (errno != EINVAL)
903                                 return -errno;
904         }
905
906         return 0;
907 }
908
909 char *strstrip(char *s) {
910         char *e;
911
912         /* Drops trailing whitespace. Modifies the string in
913          * place. Returns pointer to first non-space character */
914
915         s += strspn(s, WHITESPACE);
916
917         for (e = strchr(s, 0); e > s; e --)
918                 if (!strchr(WHITESPACE, e[-1]))
919                         break;
920
921         *e = 0;
922
923         return s;
924 }
925
926 char *delete_chars(char *s, const char *bad) {
927         char *f, *t;
928
929         /* Drops all whitespace, regardless where in the string */
930
931         for (f = s, t = s; *f; f++) {
932                 if (strchr(bad, *f))
933                         continue;
934
935                 *(t++) = *f;
936         }
937
938         *t = 0;
939
940         return s;
941 }
942
943 char *file_in_same_dir(const char *path, const char *filename) {
944         char *e, *r;
945         size_t k;
946
947         assert(path);
948         assert(filename);
949
950         /* This removes the last component of path and appends
951          * filename, unless the latter is absolute anyway or the
952          * former isn't */
953
954         if (path_is_absolute(filename))
955                 return strdup(filename);
956
957         if (!(e = strrchr(path, '/')))
958                 return strdup(filename);
959
960         k = strlen(filename);
961         if (!(r = new(char, e-path+1+k+1)))
962                 return NULL;
963
964         memcpy(r, path, e-path+1);
965         memcpy(r+(e-path)+1, filename, k+1);
966
967         return r;
968 }
969
970 int rmdir_parents(const char *path, const char *stop) {
971         size_t l;
972         int r = 0;
973
974         assert(path);
975         assert(stop);
976
977         l = strlen(path);
978
979         /* Skip trailing slashes */
980         while (l > 0 && path[l-1] == '/')
981                 l--;
982
983         while (l > 0) {
984                 char *t;
985
986                 /* Skip last component */
987                 while (l > 0 && path[l-1] != '/')
988                         l--;
989
990                 /* Skip trailing slashes */
991                 while (l > 0 && path[l-1] == '/')
992                         l--;
993
994                 if (l <= 0)
995                         break;
996
997                 if (!(t = strndup(path, l)))
998                         return -ENOMEM;
999
1000                 if (path_startswith(stop, t)) {
1001                         free(t);
1002                         return 0;
1003                 }
1004
1005                 r = rmdir(t);
1006                 free(t);
1007
1008                 if (r < 0)
1009                         if (errno != ENOENT)
1010                                 return -errno;
1011         }
1012
1013         return 0;
1014 }
1015
1016 char hexchar(int x) {
1017         static const char table[16] = "0123456789abcdef";
1018
1019         return table[x & 15];
1020 }
1021
1022 int unhexchar(char c) {
1023
1024         if (c >= '0' && c <= '9')
1025                 return c - '0';
1026
1027         if (c >= 'a' && c <= 'f')
1028                 return c - 'a' + 10;
1029
1030         if (c >= 'A' && c <= 'F')
1031                 return c - 'A' + 10;
1032
1033         return -1;
1034 }
1035
1036 char *hexmem(const void *p, size_t l) {
1037         char *r, *z;
1038         const uint8_t *x;
1039
1040         z = r = malloc(l * 2 + 1);
1041         if (!r)
1042                 return NULL;
1043
1044         for (x = p; x < (const uint8_t*) p + l; x++) {
1045                 *(z++) = hexchar(*x >> 4);
1046                 *(z++) = hexchar(*x & 15);
1047         }
1048
1049         *z = 0;
1050         return r;
1051 }
1052
1053 void *unhexmem(const char *p, size_t l) {
1054         uint8_t *r, *z;
1055         const char *x;
1056
1057         assert(p);
1058
1059         z = r = malloc((l + 1) / 2 + 1);
1060         if (!r)
1061                 return NULL;
1062
1063         for (x = p; x < p + l; x += 2) {
1064                 int a, b;
1065
1066                 a = unhexchar(x[0]);
1067                 if (x+1 < p + l)
1068                         b = unhexchar(x[1]);
1069                 else
1070                         b = 0;
1071
1072                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1073         }
1074
1075         *z = 0;
1076         return r;
1077 }
1078
1079 char octchar(int x) {
1080         return '0' + (x & 7);
1081 }
1082
1083 int unoctchar(char c) {
1084
1085         if (c >= '0' && c <= '7')
1086                 return c - '0';
1087
1088         return -1;
1089 }
1090
1091 char decchar(int x) {
1092         return '0' + (x % 10);
1093 }
1094
1095 int undecchar(char c) {
1096
1097         if (c >= '0' && c <= '9')
1098                 return c - '0';
1099
1100         return -1;
1101 }
1102
1103 char *cescape(const char *s) {
1104         char *r, *t;
1105         const char *f;
1106
1107         assert(s);
1108
1109         /* Does C style string escaping. */
1110
1111         r = new(char, strlen(s)*4 + 1);
1112         if (!r)
1113                 return NULL;
1114
1115         for (f = s, t = r; *f; f++)
1116
1117                 switch (*f) {
1118
1119                 case '\a':
1120                         *(t++) = '\\';
1121                         *(t++) = 'a';
1122                         break;
1123                 case '\b':
1124                         *(t++) = '\\';
1125                         *(t++) = 'b';
1126                         break;
1127                 case '\f':
1128                         *(t++) = '\\';
1129                         *(t++) = 'f';
1130                         break;
1131                 case '\n':
1132                         *(t++) = '\\';
1133                         *(t++) = 'n';
1134                         break;
1135                 case '\r':
1136                         *(t++) = '\\';
1137                         *(t++) = 'r';
1138                         break;
1139                 case '\t':
1140                         *(t++) = '\\';
1141                         *(t++) = 't';
1142                         break;
1143                 case '\v':
1144                         *(t++) = '\\';
1145                         *(t++) = 'v';
1146                         break;
1147                 case '\\':
1148                         *(t++) = '\\';
1149                         *(t++) = '\\';
1150                         break;
1151                 case '"':
1152                         *(t++) = '\\';
1153                         *(t++) = '"';
1154                         break;
1155                 case '\'':
1156                         *(t++) = '\\';
1157                         *(t++) = '\'';
1158                         break;
1159
1160                 default:
1161                         /* For special chars we prefer octal over
1162                          * hexadecimal encoding, simply because glib's
1163                          * g_strescape() does the same */
1164                         if ((*f < ' ') || (*f >= 127)) {
1165                                 *(t++) = '\\';
1166                                 *(t++) = octchar((unsigned char) *f >> 6);
1167                                 *(t++) = octchar((unsigned char) *f >> 3);
1168                                 *(t++) = octchar((unsigned char) *f);
1169                         } else
1170                                 *(t++) = *f;
1171                         break;
1172                 }
1173
1174         *t = 0;
1175
1176         return r;
1177 }
1178
1179 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1180         char *r, *t;
1181         const char *f;
1182         size_t pl;
1183
1184         assert(s);
1185
1186         /* Undoes C style string escaping, and optionally prefixes it. */
1187
1188         pl = prefix ? strlen(prefix) : 0;
1189
1190         r = new(char, pl+length+1);
1191         if (!r)
1192                 return r;
1193
1194         if (prefix)
1195                 memcpy(r, prefix, pl);
1196
1197         for (f = s, t = r + pl; f < s + length; f++) {
1198
1199                 if (*f != '\\') {
1200                         *(t++) = *f;
1201                         continue;
1202                 }
1203
1204                 f++;
1205
1206                 switch (*f) {
1207
1208                 case 'a':
1209                         *(t++) = '\a';
1210                         break;
1211                 case 'b':
1212                         *(t++) = '\b';
1213                         break;
1214                 case 'f':
1215                         *(t++) = '\f';
1216                         break;
1217                 case 'n':
1218                         *(t++) = '\n';
1219                         break;
1220                 case 'r':
1221                         *(t++) = '\r';
1222                         break;
1223                 case 't':
1224                         *(t++) = '\t';
1225                         break;
1226                 case 'v':
1227                         *(t++) = '\v';
1228                         break;
1229                 case '\\':
1230                         *(t++) = '\\';
1231                         break;
1232                 case '"':
1233                         *(t++) = '"';
1234                         break;
1235                 case '\'':
1236                         *(t++) = '\'';
1237                         break;
1238
1239                 case 's':
1240                         /* This is an extension of the XDG syntax files */
1241                         *(t++) = ' ';
1242                         break;
1243
1244                 case 'x': {
1245                         /* hexadecimal encoding */
1246                         int a, b;
1247
1248                         a = unhexchar(f[1]);
1249                         b = unhexchar(f[2]);
1250
1251                         if (a < 0 || b < 0) {
1252                                 /* Invalid escape code, let's take it literal then */
1253                                 *(t++) = '\\';
1254                                 *(t++) = 'x';
1255                         } else {
1256                                 *(t++) = (char) ((a << 4) | b);
1257                                 f += 2;
1258                         }
1259
1260                         break;
1261                 }
1262
1263                 case '0':
1264                 case '1':
1265                 case '2':
1266                 case '3':
1267                 case '4':
1268                 case '5':
1269                 case '6':
1270                 case '7': {
1271                         /* octal encoding */
1272                         int a, b, c;
1273
1274                         a = unoctchar(f[0]);
1275                         b = unoctchar(f[1]);
1276                         c = unoctchar(f[2]);
1277
1278                         if (a < 0 || b < 0 || c < 0) {
1279                                 /* Invalid escape code, let's take it literal then */
1280                                 *(t++) = '\\';
1281                                 *(t++) = f[0];
1282                         } else {
1283                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1284                                 f += 2;
1285                         }
1286
1287                         break;
1288                 }
1289
1290                 case 0:
1291                         /* premature end of string.*/
1292                         *(t++) = '\\';
1293                         goto finish;
1294
1295                 default:
1296                         /* Invalid escape code, let's take it literal then */
1297                         *(t++) = '\\';
1298                         *(t++) = *f;
1299                         break;
1300                 }
1301         }
1302
1303 finish:
1304         *t = 0;
1305         return r;
1306 }
1307
1308 char *cunescape_length(const char *s, size_t length) {
1309         return cunescape_length_with_prefix(s, length, NULL);
1310 }
1311
1312 char *cunescape(const char *s) {
1313         assert(s);
1314
1315         return cunescape_length(s, strlen(s));
1316 }
1317
1318 char *xescape(const char *s, const char *bad) {
1319         char *r, *t;
1320         const char *f;
1321
1322         /* Escapes all chars in bad, in addition to \ and all special
1323          * chars, in \xFF style escaping. May be reversed with
1324          * cunescape. */
1325
1326         r = new(char, strlen(s) * 4 + 1);
1327         if (!r)
1328                 return NULL;
1329
1330         for (f = s, t = r; *f; f++) {
1331
1332                 if ((*f < ' ') || (*f >= 127) ||
1333                     (*f == '\\') || strchr(bad, *f)) {
1334                         *(t++) = '\\';
1335                         *(t++) = 'x';
1336                         *(t++) = hexchar(*f >> 4);
1337                         *(t++) = hexchar(*f);
1338                 } else
1339                         *(t++) = *f;
1340         }
1341
1342         *t = 0;
1343
1344         return r;
1345 }
1346
1347 char *ascii_strlower(char *t) {
1348         char *p;
1349
1350         assert(t);
1351
1352         for (p = t; *p; p++)
1353                 if (*p >= 'A' && *p <= 'Z')
1354                         *p = *p - 'A' + 'a';
1355
1356         return t;
1357 }
1358
1359 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1360         assert(filename);
1361
1362         return
1363                 filename[0] == '.' ||
1364                 streq(filename, "lost+found") ||
1365                 streq(filename, "aquota.user") ||
1366                 streq(filename, "aquota.group") ||
1367                 endswith(filename, ".rpmnew") ||
1368                 endswith(filename, ".rpmsave") ||
1369                 endswith(filename, ".rpmorig") ||
1370                 endswith(filename, ".dpkg-old") ||
1371                 endswith(filename, ".dpkg-new") ||
1372                 endswith(filename, ".swp");
1373 }
1374
1375 bool ignore_file(const char *filename) {
1376         assert(filename);
1377
1378         if (endswith(filename, "~"))
1379                 return true;
1380
1381         return ignore_file_allow_backup(filename);
1382 }
1383
1384 int fd_nonblock(int fd, bool nonblock) {
1385         int flags, nflags;
1386
1387         assert(fd >= 0);
1388
1389         flags = fcntl(fd, F_GETFL, 0);
1390         if (flags < 0)
1391                 return -errno;
1392
1393         if (nonblock)
1394                 nflags = flags | O_NONBLOCK;
1395         else
1396                 nflags = flags & ~O_NONBLOCK;
1397
1398         if (nflags == flags)
1399                 return 0;
1400
1401         if (fcntl(fd, F_SETFL, nflags) < 0)
1402                 return -errno;
1403
1404         return 0;
1405 }
1406
1407 int fd_cloexec(int fd, bool cloexec) {
1408         int flags, nflags;
1409
1410         assert(fd >= 0);
1411
1412         flags = fcntl(fd, F_GETFD, 0);
1413         if (flags < 0)
1414                 return -errno;
1415
1416         if (cloexec)
1417                 nflags = flags | FD_CLOEXEC;
1418         else
1419                 nflags = flags & ~FD_CLOEXEC;
1420
1421         if (nflags == flags)
1422                 return 0;
1423
1424         if (fcntl(fd, F_SETFD, nflags) < 0)
1425                 return -errno;
1426
1427         return 0;
1428 }
1429
1430 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1431         unsigned i;
1432
1433         assert(n_fdset == 0 || fdset);
1434
1435         for (i = 0; i < n_fdset; i++)
1436                 if (fdset[i] == fd)
1437                         return true;
1438
1439         return false;
1440 }
1441
1442 int close_all_fds(const int except[], unsigned n_except) {
1443         DIR *d;
1444         struct dirent *de;
1445         int r = 0;
1446
1447         assert(n_except == 0 || except);
1448
1449         d = opendir("/proc/self/fd");
1450         if (!d) {
1451                 int fd;
1452                 struct rlimit rl;
1453
1454                 /* When /proc isn't available (for example in chroots)
1455                  * the fallback is brute forcing through the fd
1456                  * table */
1457
1458                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1459                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1460
1461                         if (fd_in_set(fd, except, n_except))
1462                                 continue;
1463
1464                         if (close_nointr(fd) < 0)
1465                                 if (errno != EBADF && r == 0)
1466                                         r = -errno;
1467                 }
1468
1469                 return r;
1470         }
1471
1472         while ((de = readdir(d))) {
1473                 int fd = -1;
1474
1475                 if (ignore_file(de->d_name))
1476                         continue;
1477
1478                 if (safe_atoi(de->d_name, &fd) < 0)
1479                         /* Let's better ignore this, just in case */
1480                         continue;
1481
1482                 if (fd < 3)
1483                         continue;
1484
1485                 if (fd == dirfd(d))
1486                         continue;
1487
1488                 if (fd_in_set(fd, except, n_except))
1489                         continue;
1490
1491                 if (close_nointr(fd) < 0) {
1492                         /* Valgrind has its own FD and doesn't want to have it closed */
1493                         if (errno != EBADF && r == 0)
1494                                 r = -errno;
1495                 }
1496         }
1497
1498         closedir(d);
1499         return r;
1500 }
1501
1502 bool chars_intersect(const char *a, const char *b) {
1503         const char *p;
1504
1505         /* Returns true if any of the chars in a are in b. */
1506         for (p = a; *p; p++)
1507                 if (strchr(b, *p))
1508                         return true;
1509
1510         return false;
1511 }
1512
1513 bool fstype_is_network(const char *fstype) {
1514         static const char table[] =
1515                 "cifs\0"
1516                 "smbfs\0"
1517                 "sshfs\0"
1518                 "ncpfs\0"
1519                 "ncp\0"
1520                 "nfs\0"
1521                 "nfs4\0"
1522                 "gfs\0"
1523                 "gfs2\0"
1524                 "glusterfs\0";
1525
1526         const char *x;
1527
1528         x = startswith(fstype, "fuse.");
1529         if (x)
1530                 fstype = x;
1531
1532         return nulstr_contains(table, fstype);
1533 }
1534
1535 int chvt(int vt) {
1536         _cleanup_close_ int fd;
1537
1538         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1539         if (fd < 0)
1540                 return -errno;
1541
1542         if (vt < 0) {
1543                 int tiocl[2] = {
1544                         TIOCL_GETKMSGREDIRECT,
1545                         0
1546                 };
1547
1548                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1549                         return -errno;
1550
1551                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1552         }
1553
1554         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1555                 return -errno;
1556
1557         return 0;
1558 }
1559
1560 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1561         struct termios old_termios, new_termios;
1562         char c;
1563         char line[LINE_MAX];
1564
1565         assert(f);
1566         assert(ret);
1567
1568         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1569                 new_termios = old_termios;
1570
1571                 new_termios.c_lflag &= ~ICANON;
1572                 new_termios.c_cc[VMIN] = 1;
1573                 new_termios.c_cc[VTIME] = 0;
1574
1575                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1576                         size_t k;
1577
1578                         if (t != (usec_t) -1) {
1579                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1580                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1581                                         return -ETIMEDOUT;
1582                                 }
1583                         }
1584
1585                         k = fread(&c, 1, 1, f);
1586
1587                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1588
1589                         if (k <= 0)
1590                                 return -EIO;
1591
1592                         if (need_nl)
1593                                 *need_nl = c != '\n';
1594
1595                         *ret = c;
1596                         return 0;
1597                 }
1598         }
1599
1600         if (t != (usec_t) -1)
1601                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1602                         return -ETIMEDOUT;
1603
1604         if (!fgets(line, sizeof(line), f))
1605                 return -EIO;
1606
1607         truncate_nl(line);
1608
1609         if (strlen(line) != 1)
1610                 return -EBADMSG;
1611
1612         if (need_nl)
1613                 *need_nl = false;
1614
1615         *ret = line[0];
1616         return 0;
1617 }
1618
1619 int ask(char *ret, const char *replies, const char *text, ...) {
1620
1621         assert(ret);
1622         assert(replies);
1623         assert(text);
1624
1625         for (;;) {
1626                 va_list ap;
1627                 char c;
1628                 int r;
1629                 bool need_nl = true;
1630
1631                 if (on_tty())
1632                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1633
1634                 va_start(ap, text);
1635                 vprintf(text, ap);
1636                 va_end(ap);
1637
1638                 if (on_tty())
1639                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1640
1641                 fflush(stdout);
1642
1643                 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
1644                 if (r < 0) {
1645
1646                         if (r == -EBADMSG) {
1647                                 puts("Bad input, please try again.");
1648                                 continue;
1649                         }
1650
1651                         putchar('\n');
1652                         return r;
1653                 }
1654
1655                 if (need_nl)
1656                         putchar('\n');
1657
1658                 if (strchr(replies, c)) {
1659                         *ret = c;
1660                         return 0;
1661                 }
1662
1663                 puts("Read unexpected character, please try again.");
1664         }
1665 }
1666
1667 int reset_terminal_fd(int fd, bool switch_to_text) {
1668         struct termios termios;
1669         int r = 0;
1670
1671         /* Set terminal to some sane defaults */
1672
1673         assert(fd >= 0);
1674
1675         /* We leave locked terminal attributes untouched, so that
1676          * Plymouth may set whatever it wants to set, and we don't
1677          * interfere with that. */
1678
1679         /* Disable exclusive mode, just in case */
1680         ioctl(fd, TIOCNXCL);
1681
1682         /* Switch to text mode */
1683         if (switch_to_text)
1684                 ioctl(fd, KDSETMODE, KD_TEXT);
1685
1686         /* Enable console unicode mode */
1687         ioctl(fd, KDSKBMODE, K_UNICODE);
1688
1689         if (tcgetattr(fd, &termios) < 0) {
1690                 r = -errno;
1691                 goto finish;
1692         }
1693
1694         /* We only reset the stuff that matters to the software. How
1695          * hardware is set up we don't touch assuming that somebody
1696          * else will do that for us */
1697
1698         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1699         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1700         termios.c_oflag |= ONLCR;
1701         termios.c_cflag |= CREAD;
1702         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1703
1704         termios.c_cc[VINTR]    =   03;  /* ^C */
1705         termios.c_cc[VQUIT]    =  034;  /* ^\ */
1706         termios.c_cc[VERASE]   = 0177;
1707         termios.c_cc[VKILL]    =  025;  /* ^X */
1708         termios.c_cc[VEOF]     =   04;  /* ^D */
1709         termios.c_cc[VSTART]   =  021;  /* ^Q */
1710         termios.c_cc[VSTOP]    =  023;  /* ^S */
1711         termios.c_cc[VSUSP]    =  032;  /* ^Z */
1712         termios.c_cc[VLNEXT]   =  026;  /* ^V */
1713         termios.c_cc[VWERASE]  =  027;  /* ^W */
1714         termios.c_cc[VREPRINT] =  022;  /* ^R */
1715         termios.c_cc[VEOL]     =    0;
1716         termios.c_cc[VEOL2]    =    0;
1717
1718         termios.c_cc[VTIME]  = 0;
1719         termios.c_cc[VMIN]   = 1;
1720
1721         if (tcsetattr(fd, TCSANOW, &termios) < 0)
1722                 r = -errno;
1723
1724 finish:
1725         /* Just in case, flush all crap out */
1726         tcflush(fd, TCIOFLUSH);
1727
1728         return r;
1729 }
1730
1731 int reset_terminal(const char *name) {
1732         _cleanup_close_ int fd = -1;
1733
1734         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1735         if (fd < 0)
1736                 return fd;
1737
1738         return reset_terminal_fd(fd, true);
1739 }
1740
1741 int open_terminal(const char *name, int mode) {
1742         int fd, r;
1743         unsigned c = 0;
1744
1745         /*
1746          * If a TTY is in the process of being closed opening it might
1747          * cause EIO. This is horribly awful, but unlikely to be
1748          * changed in the kernel. Hence we work around this problem by
1749          * retrying a couple of times.
1750          *
1751          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1752          */
1753
1754         assert(!(mode & O_CREAT));
1755
1756         for (;;) {
1757                 fd = open(name, mode, 0);
1758                 if (fd >= 0)
1759                         break;
1760
1761                 if (errno != EIO)
1762                         return -errno;
1763
1764                 /* Max 1s in total */
1765                 if (c >= 20)
1766                         return -errno;
1767
1768                 usleep(50 * USEC_PER_MSEC);
1769                 c++;
1770         }
1771
1772         if (fd < 0)
1773                 return -errno;
1774
1775         r = isatty(fd);
1776         if (r < 0) {
1777                 safe_close(fd);
1778                 return -errno;
1779         }
1780
1781         if (!r) {
1782                 safe_close(fd);
1783                 return -ENOTTY;
1784         }
1785
1786         return fd;
1787 }
1788
1789 int flush_fd(int fd) {
1790         struct pollfd pollfd = {
1791                 .fd = fd,
1792                 .events = POLLIN,
1793         };
1794
1795         for (;;) {
1796                 char buf[LINE_MAX];
1797                 ssize_t l;
1798                 int r;
1799
1800                 r = poll(&pollfd, 1, 0);
1801                 if (r < 0) {
1802                         if (errno == EINTR)
1803                                 continue;
1804
1805                         return -errno;
1806
1807                 } else if (r == 0)
1808                         return 0;
1809
1810                 l = read(fd, buf, sizeof(buf));
1811                 if (l < 0) {
1812
1813                         if (errno == EINTR)
1814                                 continue;
1815
1816                         if (errno == EAGAIN)
1817                                 return 0;
1818
1819                         return -errno;
1820                 } else if (l == 0)
1821                         return 0;
1822         }
1823 }
1824
1825 int acquire_terminal(
1826                 const char *name,
1827                 bool fail,
1828                 bool force,
1829                 bool ignore_tiocstty_eperm,
1830                 usec_t timeout) {
1831
1832         int fd = -1, notify = -1, r = 0, wd = -1;
1833         usec_t ts = 0;
1834
1835         assert(name);
1836
1837         /* We use inotify to be notified when the tty is closed. We
1838          * create the watch before checking if we can actually acquire
1839          * it, so that we don't lose any event.
1840          *
1841          * Note: strictly speaking this actually watches for the
1842          * device being closed, it does *not* really watch whether a
1843          * tty loses its controlling process. However, unless some
1844          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1845          * its tty otherwise this will not become a problem. As long
1846          * as the administrator makes sure not configure any service
1847          * on the same tty as an untrusted user this should not be a
1848          * problem. (Which he probably should not do anyway.) */
1849
1850         if (timeout != (usec_t) -1)
1851                 ts = now(CLOCK_MONOTONIC);
1852
1853         if (!fail && !force) {
1854                 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
1855                 if (notify < 0) {
1856                         r = -errno;
1857                         goto fail;
1858                 }
1859
1860                 wd = inotify_add_watch(notify, name, IN_CLOSE);
1861                 if (wd < 0) {
1862                         r = -errno;
1863                         goto fail;
1864                 }
1865         }
1866
1867         for (;;) {
1868                 struct sigaction sa_old, sa_new = {
1869                         .sa_handler = SIG_IGN,
1870                         .sa_flags = SA_RESTART,
1871                 };
1872
1873                 if (notify >= 0) {
1874                         r = flush_fd(notify);
1875                         if (r < 0)
1876                                 goto fail;
1877                 }
1878
1879                 /* We pass here O_NOCTTY only so that we can check the return
1880                  * value TIOCSCTTY and have a reliable way to figure out if we
1881                  * successfully became the controlling process of the tty */
1882                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1883                 if (fd < 0)
1884                         return fd;
1885
1886                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1887                  * if we already own the tty. */
1888                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1889
1890                 /* First, try to get the tty */
1891                 if (ioctl(fd, TIOCSCTTY, force) < 0)
1892                         r = -errno;
1893
1894                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1895
1896                 /* Sometimes it makes sense to ignore TIOCSCTTY
1897                  * returning EPERM, i.e. when very likely we already
1898                  * are have this controlling terminal. */
1899                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1900                         r = 0;
1901
1902                 if (r < 0 && (force || fail || r != -EPERM)) {
1903                         goto fail;
1904                 }
1905
1906                 if (r >= 0)
1907                         break;
1908
1909                 assert(!fail);
1910                 assert(!force);
1911                 assert(notify >= 0);
1912
1913                 for (;;) {
1914                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1915                         ssize_t l;
1916                         struct inotify_event *e;
1917
1918                         if (timeout != (usec_t) -1) {
1919                                 usec_t n;
1920
1921                                 n = now(CLOCK_MONOTONIC);
1922                                 if (ts + timeout < n) {
1923                                         r = -ETIMEDOUT;
1924                                         goto fail;
1925                                 }
1926
1927                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
1928                                 if (r < 0)
1929                                         goto fail;
1930
1931                                 if (r == 0) {
1932                                         r = -ETIMEDOUT;
1933                                         goto fail;
1934                                 }
1935                         }
1936
1937                         l = read(notify, inotify_buffer, sizeof(inotify_buffer));
1938                         if (l < 0) {
1939
1940                                 if (errno == EINTR || errno == EAGAIN)
1941                                         continue;
1942
1943                                 r = -errno;
1944                                 goto fail;
1945                         }
1946
1947                         e = (struct inotify_event*) inotify_buffer;
1948
1949                         while (l > 0) {
1950                                 size_t step;
1951
1952                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
1953                                         r = -EIO;
1954                                         goto fail;
1955                                 }
1956
1957                                 step = sizeof(struct inotify_event) + e->len;
1958                                 assert(step <= (size_t) l);
1959
1960                                 e = (struct inotify_event*) ((uint8_t*) e + step);
1961                                 l -= step;
1962                         }
1963
1964                         break;
1965                 }
1966
1967                 /* We close the tty fd here since if the old session
1968                  * ended our handle will be dead. It's important that
1969                  * we do this after sleeping, so that we don't enter
1970                  * an endless loop. */
1971                 safe_close(fd);
1972         }
1973
1974         safe_close(notify);
1975
1976         r = reset_terminal_fd(fd, true);
1977         if (r < 0)
1978                 log_warning("Failed to reset terminal: %s", strerror(-r));
1979
1980         return fd;
1981
1982 fail:
1983         safe_close(fd);
1984         safe_close(notify);
1985
1986         return r;
1987 }
1988
1989 int release_terminal(void) {
1990         int r = 0;
1991         struct sigaction sa_old, sa_new = {
1992                 .sa_handler = SIG_IGN,
1993                 .sa_flags = SA_RESTART,
1994         };
1995         _cleanup_close_ int fd;
1996
1997         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
1998         if (fd < 0)
1999                 return -errno;
2000
2001         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2002          * by our own TIOCNOTTY */
2003         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2004
2005         if (ioctl(fd, TIOCNOTTY) < 0)
2006                 r = -errno;
2007
2008         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2009
2010         return r;
2011 }
2012
2013 int sigaction_many(const struct sigaction *sa, ...) {
2014         va_list ap;
2015         int r = 0, sig;
2016
2017         va_start(ap, sa);
2018         while ((sig = va_arg(ap, int)) > 0)
2019                 if (sigaction(sig, sa, NULL) < 0)
2020                         r = -errno;
2021         va_end(ap);
2022
2023         return r;
2024 }
2025
2026 int ignore_signals(int sig, ...) {
2027         struct sigaction sa = {
2028                 .sa_handler = SIG_IGN,
2029                 .sa_flags = SA_RESTART,
2030         };
2031         va_list ap;
2032         int r = 0;
2033
2034         if (sigaction(sig, &sa, NULL) < 0)
2035                 r = -errno;
2036
2037         va_start(ap, sig);
2038         while ((sig = va_arg(ap, int)) > 0)
2039                 if (sigaction(sig, &sa, NULL) < 0)
2040                         r = -errno;
2041         va_end(ap);
2042
2043         return r;
2044 }
2045
2046 int default_signals(int sig, ...) {
2047         struct sigaction sa = {
2048                 .sa_handler = SIG_DFL,
2049                 .sa_flags = SA_RESTART,
2050         };
2051         va_list ap;
2052         int r = 0;
2053
2054         if (sigaction(sig, &sa, NULL) < 0)
2055                 r = -errno;
2056
2057         va_start(ap, sig);
2058         while ((sig = va_arg(ap, int)) > 0)
2059                 if (sigaction(sig, &sa, NULL) < 0)
2060                         r = -errno;
2061         va_end(ap);
2062
2063         return r;
2064 }
2065
2066 void safe_close_pair(int p[]) {
2067         assert(p);
2068
2069         if (p[0] == p[1]) {
2070                 /* Special case pairs which use the same fd in both
2071                  * directions... */
2072                 p[0] = p[1] = safe_close(p[0]);
2073                 return;
2074         }
2075
2076         p[0] = safe_close(p[0]);
2077         p[1] = safe_close(p[1]);
2078 }
2079
2080 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2081         uint8_t *p = buf;
2082         ssize_t n = 0;
2083
2084         assert(fd >= 0);
2085         assert(buf);
2086
2087         while (nbytes > 0) {
2088                 ssize_t k;
2089
2090                 k = read(fd, p, nbytes);
2091                 if (k < 0 && errno == EINTR)
2092                         continue;
2093
2094                 if (k < 0 && errno == EAGAIN && do_poll) {
2095
2096                         /* We knowingly ignore any return value here,
2097                          * and expect that any error/EOF is reported
2098                          * via read() */
2099
2100                         fd_wait_for_event(fd, POLLIN, (usec_t) -1);
2101                         continue;
2102                 }
2103
2104                 if (k <= 0)
2105                         return n > 0 ? n : (k < 0 ? -errno : 0);
2106
2107                 p += k;
2108                 nbytes -= k;
2109                 n += k;
2110         }
2111
2112         return n;
2113 }
2114
2115 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2116         const uint8_t *p = buf;
2117         ssize_t n = 0;
2118
2119         assert(fd >= 0);
2120         assert(buf);
2121
2122         while (nbytes > 0) {
2123                 ssize_t k;
2124
2125                 k = write(fd, p, nbytes);
2126                 if (k < 0 && errno == EINTR)
2127                         continue;
2128
2129                 if (k < 0 && errno == EAGAIN && do_poll) {
2130
2131                         /* We knowingly ignore any return value here,
2132                          * and expect that any error/EOF is reported
2133                          * via write() */
2134
2135                         fd_wait_for_event(fd, POLLOUT, (usec_t) -1);
2136                         continue;
2137                 }
2138
2139                 if (k <= 0)
2140                         return n > 0 ? n : (k < 0 ? -errno : 0);
2141
2142                 p += k;
2143                 nbytes -= k;
2144                 n += k;
2145         }
2146
2147         return n;
2148 }
2149
2150 int parse_size(const char *t, off_t base, off_t *size) {
2151
2152         /* Soo, sometimes we want to parse IEC binary suffxies, and
2153          * sometimes SI decimal suffixes. This function can parse
2154          * both. Which one is the right way depends on the
2155          * context. Wikipedia suggests that SI is customary for
2156          * hardrware metrics and network speeds, while IEC is
2157          * customary for most data sizes used by software and volatile
2158          * (RAM) memory. Hence be careful which one you pick!
2159          *
2160          * In either case we use just K, M, G as suffix, and not Ki,
2161          * Mi, Gi or so (as IEC would suggest). That's because that's
2162          * frickin' ugly. But this means you really need to make sure
2163          * to document which base you are parsing when you use this
2164          * call. */
2165
2166         struct table {
2167                 const char *suffix;
2168                 unsigned long long factor;
2169         };
2170
2171         static const struct table iec[] = {
2172                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2173                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2174                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2175                 { "G", 1024ULL*1024ULL*1024ULL },
2176                 { "M", 1024ULL*1024ULL },
2177                 { "K", 1024ULL },
2178                 { "B", 1 },
2179                 { "", 1 },
2180         };
2181
2182         static const struct table si[] = {
2183                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2184                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2185                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2186                 { "G", 1000ULL*1000ULL*1000ULL },
2187                 { "M", 1000ULL*1000ULL },
2188                 { "K", 1000ULL },
2189                 { "B", 1 },
2190                 { "", 1 },
2191         };
2192
2193         const struct table *table;
2194         const char *p;
2195         unsigned long long r = 0;
2196         unsigned n_entries, start_pos = 0;
2197
2198         assert(t);
2199         assert(base == 1000 || base == 1024);
2200         assert(size);
2201
2202         if (base == 1000) {
2203                 table = si;
2204                 n_entries = ELEMENTSOF(si);
2205         } else {
2206                 table = iec;
2207                 n_entries = ELEMENTSOF(iec);
2208         }
2209
2210         p = t;
2211         do {
2212                 long long l;
2213                 unsigned long long l2;
2214                 double frac = 0;
2215                 char *e;
2216                 unsigned i;
2217
2218                 errno = 0;
2219                 l = strtoll(p, &e, 10);
2220
2221                 if (errno > 0)
2222                         return -errno;
2223
2224                 if (l < 0)
2225                         return -ERANGE;
2226
2227                 if (e == p)
2228                         return -EINVAL;
2229
2230                 if (*e == '.') {
2231                         e++;
2232                         if (*e >= '0' && *e <= '9') {
2233                                 char *e2;
2234
2235                                 /* strotoull itself would accept space/+/- */
2236                                 l2 = strtoull(e, &e2, 10);
2237
2238                                 if (errno == ERANGE)
2239                                         return -errno;
2240
2241                                 /* Ignore failure. E.g. 10.M is valid */
2242                                 frac = l2;
2243                                 for (; e < e2; e++)
2244                                         frac /= 10;
2245                         }
2246                 }
2247
2248                 e += strspn(e, WHITESPACE);
2249
2250                 for (i = start_pos; i < n_entries; i++)
2251                         if (startswith(e, table[i].suffix)) {
2252                                 unsigned long long tmp;
2253                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2254                                         return -ERANGE;
2255                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2256                                 if (tmp > ULLONG_MAX - r)
2257                                         return -ERANGE;
2258
2259                                 r += tmp;
2260                                 if ((unsigned long long) (off_t) r != r)
2261                                         return -ERANGE;
2262
2263                                 p = e + strlen(table[i].suffix);
2264
2265                                 start_pos = i + 1;
2266                                 break;
2267                         }
2268
2269                 if (i >= n_entries)
2270                         return -EINVAL;
2271
2272         } while (*p);
2273
2274         *size = r;
2275
2276         return 0;
2277 }
2278
2279 int make_stdio(int fd) {
2280         int r, s, t;
2281
2282         assert(fd >= 0);
2283
2284         r = dup3(fd, STDIN_FILENO, 0);
2285         s = dup3(fd, STDOUT_FILENO, 0);
2286         t = dup3(fd, STDERR_FILENO, 0);
2287
2288         if (fd >= 3)
2289                 safe_close(fd);
2290
2291         if (r < 0 || s < 0 || t < 0)
2292                 return -errno;
2293
2294         /* We rely here that the new fd has O_CLOEXEC not set */
2295
2296         return 0;
2297 }
2298
2299 int make_null_stdio(void) {
2300         int null_fd;
2301
2302         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2303         if (null_fd < 0)
2304                 return -errno;
2305
2306         return make_stdio(null_fd);
2307 }
2308
2309 bool is_device_path(const char *path) {
2310
2311         /* Returns true on paths that refer to a device, either in
2312          * sysfs or in /dev */
2313
2314         return
2315                 path_startswith(path, "/dev/") ||
2316                 path_startswith(path, "/sys/");
2317 }
2318
2319 int dir_is_empty(const char *path) {
2320         _cleanup_closedir_ DIR *d;
2321
2322         d = opendir(path);
2323         if (!d)
2324                 return -errno;
2325
2326         for (;;) {
2327                 struct dirent *de;
2328
2329                 errno = 0;
2330                 de = readdir(d);
2331                 if (!de && errno != 0)
2332                         return -errno;
2333
2334                 if (!de)
2335                         return 1;
2336
2337                 if (!ignore_file(de->d_name))
2338                         return 0;
2339         }
2340 }
2341
2342 char* dirname_malloc(const char *path) {
2343         char *d, *dir, *dir2;
2344
2345         d = strdup(path);
2346         if (!d)
2347                 return NULL;
2348         dir = dirname(d);
2349         assert(dir);
2350
2351         if (dir != d) {
2352                 dir2 = strdup(dir);
2353                 free(d);
2354                 return dir2;
2355         }
2356
2357         return dir;
2358 }
2359
2360 int dev_urandom(void *p, size_t n) {
2361         _cleanup_close_ int fd;
2362         ssize_t k;
2363
2364         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2365         if (fd < 0)
2366                 return errno == ENOENT ? -ENOSYS : -errno;
2367
2368         k = loop_read(fd, p, n, true);
2369         if (k < 0)
2370                 return (int) k;
2371         if ((size_t) k != n)
2372                 return -EIO;
2373
2374         return 0;
2375 }
2376
2377 void random_bytes(void *p, size_t n) {
2378         static bool srand_called = false;
2379         uint8_t *q;
2380         int r;
2381
2382         r = dev_urandom(p, n);
2383         if (r >= 0)
2384                 return;
2385
2386         /* If some idiot made /dev/urandom unavailable to us, he'll
2387          * get a PRNG instead. */
2388
2389         if (!srand_called) {
2390                 unsigned x = 0;
2391
2392 #ifdef HAVE_SYS_AUXV_H
2393                 /* The kernel provides us with a bit of entropy in
2394                  * auxv, so let's try to make use of that to seed the
2395                  * pseudo-random generator. It's better than
2396                  * nothing... */
2397
2398                 void *auxv;
2399
2400                 auxv = (void*) getauxval(AT_RANDOM);
2401                 if (auxv)
2402                         x ^= *(unsigned*) auxv;
2403 #endif
2404
2405                 x ^= (unsigned) now(CLOCK_REALTIME);
2406                 x ^= (unsigned) gettid();
2407
2408                 srand(x);
2409                 srand_called = true;
2410         }
2411
2412         for (q = p; q < (uint8_t*) p + n; q ++)
2413                 *q = rand();
2414 }
2415
2416 void rename_process(const char name[8]) {
2417         assert(name);
2418
2419         /* This is a like a poor man's setproctitle(). It changes the
2420          * comm field, argv[0], and also the glibc's internally used
2421          * name of the process. For the first one a limit of 16 chars
2422          * applies, to the second one usually one of 10 (i.e. length
2423          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2424          * "systemd"). If you pass a longer string it will be
2425          * truncated */
2426
2427         prctl(PR_SET_NAME, name);
2428
2429         if (program_invocation_name)
2430                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2431
2432         if (saved_argc > 0) {
2433                 int i;
2434
2435                 if (saved_argv[0])
2436                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2437
2438                 for (i = 1; i < saved_argc; i++) {
2439                         if (!saved_argv[i])
2440                                 break;
2441
2442                         memzero(saved_argv[i], strlen(saved_argv[i]));
2443                 }
2444         }
2445 }
2446
2447 void sigset_add_many(sigset_t *ss, ...) {
2448         va_list ap;
2449         int sig;
2450
2451         assert(ss);
2452
2453         va_start(ap, ss);
2454         while ((sig = va_arg(ap, int)) > 0)
2455                 assert_se(sigaddset(ss, sig) == 0);
2456         va_end(ap);
2457 }
2458
2459 int sigprocmask_many(int how, ...) {
2460         va_list ap;
2461         sigset_t ss;
2462         int sig;
2463
2464         assert_se(sigemptyset(&ss) == 0);
2465
2466         va_start(ap, how);
2467         while ((sig = va_arg(ap, int)) > 0)
2468                 assert_se(sigaddset(&ss, sig) == 0);
2469         va_end(ap);
2470
2471         if (sigprocmask(how, &ss, NULL) < 0)
2472                 return -errno;
2473
2474         return 0;
2475 }
2476
2477 char* gethostname_malloc(void) {
2478         struct utsname u;
2479
2480         assert_se(uname(&u) >= 0);
2481
2482         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2483                 return strdup(u.nodename);
2484
2485         return strdup(u.sysname);
2486 }
2487
2488 bool hostname_is_set(void) {
2489         struct utsname u;
2490
2491         assert_se(uname(&u) >= 0);
2492
2493         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2494 }
2495
2496 static char *lookup_uid(uid_t uid) {
2497         long bufsize;
2498         char *name;
2499         _cleanup_free_ char *buf = NULL;
2500         struct passwd pwbuf, *pw = NULL;
2501
2502         /* Shortcut things to avoid NSS lookups */
2503         if (uid == 0)
2504                 return strdup("root");
2505
2506         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2507         if (bufsize <= 0)
2508                 bufsize = 4096;
2509
2510         buf = malloc(bufsize);
2511         if (!buf)
2512                 return NULL;
2513
2514         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2515                 return strdup(pw->pw_name);
2516
2517         if (asprintf(&name, UID_FMT, uid) < 0)
2518                 return NULL;
2519
2520         return name;
2521 }
2522
2523 char* getlogname_malloc(void) {
2524         uid_t uid;
2525         struct stat st;
2526
2527         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2528                 uid = st.st_uid;
2529         else
2530                 uid = getuid();
2531
2532         return lookup_uid(uid);
2533 }
2534
2535 char *getusername_malloc(void) {
2536         const char *e;
2537
2538         e = getenv("USER");
2539         if (e)
2540                 return strdup(e);
2541
2542         return lookup_uid(getuid());
2543 }
2544
2545 int getttyname_malloc(int fd, char **r) {
2546         char path[PATH_MAX], *c;
2547         int k;
2548
2549         assert(r);
2550
2551         k = ttyname_r(fd, path, sizeof(path));
2552         if (k > 0)
2553                 return -k;
2554
2555         char_array_0(path);
2556
2557         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2558         if (!c)
2559                 return -ENOMEM;
2560
2561         *r = c;
2562         return 0;
2563 }
2564
2565 int getttyname_harder(int fd, char **r) {
2566         int k;
2567         char *s;
2568
2569         k = getttyname_malloc(fd, &s);
2570         if (k < 0)
2571                 return k;
2572
2573         if (streq(s, "tty")) {
2574                 free(s);
2575                 return get_ctty(0, NULL, r);
2576         }
2577
2578         *r = s;
2579         return 0;
2580 }
2581
2582 int get_ctty_devnr(pid_t pid, dev_t *d) {
2583         int r;
2584         _cleanup_free_ char *line = NULL;
2585         const char *p;
2586         unsigned long ttynr;
2587
2588         assert(pid >= 0);
2589
2590         p = procfs_file_alloca(pid, "stat");
2591         r = read_one_line_file(p, &line);
2592         if (r < 0)
2593                 return r;
2594
2595         p = strrchr(line, ')');
2596         if (!p)
2597                 return -EIO;
2598
2599         p++;
2600
2601         if (sscanf(p, " "
2602                    "%*c "  /* state */
2603                    "%*d "  /* ppid */
2604                    "%*d "  /* pgrp */
2605                    "%*d "  /* session */
2606                    "%lu ", /* ttynr */
2607                    &ttynr) != 1)
2608                 return -EIO;
2609
2610         if (major(ttynr) == 0 && minor(ttynr) == 0)
2611                 return -ENOENT;
2612
2613         if (d)
2614                 *d = (dev_t) ttynr;
2615
2616         return 0;
2617 }
2618
2619 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2620         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2621         _cleanup_free_ char *s = NULL;
2622         const char *p;
2623         dev_t devnr;
2624         int k;
2625
2626         assert(r);
2627
2628         k = get_ctty_devnr(pid, &devnr);
2629         if (k < 0)
2630                 return k;
2631
2632         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2633
2634         k = readlink_malloc(fn, &s);
2635         if (k < 0) {
2636
2637                 if (k != -ENOENT)
2638                         return k;
2639
2640                 /* This is an ugly hack */
2641                 if (major(devnr) == 136) {
2642                         asprintf(&b, "pts/%u", minor(devnr));
2643                         goto finish;
2644                 }
2645
2646                 /* Probably something like the ptys which have no
2647                  * symlink in /dev/char. Let's return something
2648                  * vaguely useful. */
2649
2650                 b = strdup(fn + 5);
2651                 goto finish;
2652         }
2653
2654         if (startswith(s, "/dev/"))
2655                 p = s + 5;
2656         else if (startswith(s, "../"))
2657                 p = s + 3;
2658         else
2659                 p = s;
2660
2661         b = strdup(p);
2662
2663 finish:
2664         if (!b)
2665                 return -ENOMEM;
2666
2667         *r = b;
2668         if (_devnr)
2669                 *_devnr = devnr;
2670
2671         return 0;
2672 }
2673
2674 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2675         _cleanup_closedir_ DIR *d = NULL;
2676         int ret = 0;
2677
2678         assert(fd >= 0);
2679
2680         /* This returns the first error we run into, but nevertheless
2681          * tries to go on. This closes the passed fd. */
2682
2683         d = fdopendir(fd);
2684         if (!d) {
2685                 safe_close(fd);
2686
2687                 return errno == ENOENT ? 0 : -errno;
2688         }
2689
2690         for (;;) {
2691                 struct dirent *de;
2692                 bool is_dir, keep_around;
2693                 struct stat st;
2694                 int r;
2695
2696                 errno = 0;
2697                 de = readdir(d);
2698                 if (!de) {
2699                         if (errno != 0 && ret == 0)
2700                                 ret = -errno;
2701                         return ret;
2702                 }
2703
2704                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2705                         continue;
2706
2707                 if (de->d_type == DT_UNKNOWN ||
2708                     honour_sticky ||
2709                     (de->d_type == DT_DIR && root_dev)) {
2710                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2711                                 if (ret == 0 && errno != ENOENT)
2712                                         ret = -errno;
2713                                 continue;
2714                         }
2715
2716                         is_dir = S_ISDIR(st.st_mode);
2717                         keep_around =
2718                                 honour_sticky &&
2719                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2720                                 (st.st_mode & S_ISVTX);
2721                 } else {
2722                         is_dir = de->d_type == DT_DIR;
2723                         keep_around = false;
2724                 }
2725
2726                 if (is_dir) {
2727                         int subdir_fd;
2728
2729                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2730                         if (root_dev && st.st_dev != root_dev->st_dev)
2731                                 continue;
2732
2733                         subdir_fd = openat(fd, de->d_name,
2734                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2735                         if (subdir_fd < 0) {
2736                                 if (ret == 0 && errno != ENOENT)
2737                                         ret = -errno;
2738                                 continue;
2739                         }
2740
2741                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2742                         if (r < 0 && ret == 0)
2743                                 ret = r;
2744
2745                         if (!keep_around)
2746                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2747                                         if (ret == 0 && errno != ENOENT)
2748                                                 ret = -errno;
2749                                 }
2750
2751                 } else if (!only_dirs && !keep_around) {
2752
2753                         if (unlinkat(fd, de->d_name, 0) < 0) {
2754                                 if (ret == 0 && errno != ENOENT)
2755                                         ret = -errno;
2756                         }
2757                 }
2758         }
2759 }
2760
2761 _pure_ static int is_temporary_fs(struct statfs *s) {
2762         assert(s);
2763
2764         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2765                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2766 }
2767
2768 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2769         struct statfs s;
2770
2771         assert(fd >= 0);
2772
2773         if (fstatfs(fd, &s) < 0) {
2774                 safe_close(fd);
2775                 return -errno;
2776         }
2777
2778         /* We refuse to clean disk file systems with this call. This
2779          * is extra paranoia just to be sure we never ever remove
2780          * non-state data */
2781         if (!is_temporary_fs(&s)) {
2782                 log_error("Attempted to remove disk file system, and we can't allow that.");
2783                 safe_close(fd);
2784                 return -EPERM;
2785         }
2786
2787         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2788 }
2789
2790 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2791         int fd, r;
2792         struct statfs s;
2793
2794         assert(path);
2795
2796         /* We refuse to clean the root file system with this
2797          * call. This is extra paranoia to never cause a really
2798          * seriously broken system. */
2799         if (path_equal(path, "/")) {
2800                 log_error("Attempted to remove entire root file system, and we can't allow that.");
2801                 return -EPERM;
2802         }
2803
2804         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2805         if (fd < 0) {
2806
2807                 if (errno != ENOTDIR)
2808                         return -errno;
2809
2810                 if (!dangerous) {
2811                         if (statfs(path, &s) < 0)
2812                                 return -errno;
2813
2814                         if (!is_temporary_fs(&s)) {
2815                                 log_error("Attempted to remove disk file system, and we can't allow that.");
2816                                 return -EPERM;
2817                         }
2818                 }
2819
2820                 if (delete_root && !only_dirs)
2821                         if (unlink(path) < 0 && errno != ENOENT)
2822                                 return -errno;
2823
2824                 return 0;
2825         }
2826
2827         if (!dangerous) {
2828                 if (fstatfs(fd, &s) < 0) {
2829                         safe_close(fd);
2830                         return -errno;
2831                 }
2832
2833                 if (!is_temporary_fs(&s)) {
2834                         log_error("Attempted to remove disk file system, and we can't allow that.");
2835                         safe_close(fd);
2836                         return -EPERM;
2837                 }
2838         }
2839
2840         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2841         if (delete_root) {
2842
2843                 if (honour_sticky && file_is_priv_sticky(path) > 0)
2844                         return r;
2845
2846                 if (rmdir(path) < 0 && errno != ENOENT) {
2847                         if (r == 0)
2848                                 r = -errno;
2849                 }
2850         }
2851
2852         return r;
2853 }
2854
2855 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2856         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2857 }
2858
2859 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2860         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2861 }
2862
2863 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2864         assert(path);
2865
2866         /* Under the assumption that we are running privileged we
2867          * first change the access mode and only then hand out
2868          * ownership to avoid a window where access is too open. */
2869
2870         if (mode != (mode_t) -1)
2871                 if (chmod(path, mode) < 0)
2872                         return -errno;
2873
2874         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2875                 if (chown(path, uid, gid) < 0)
2876                         return -errno;
2877
2878         return 0;
2879 }
2880
2881 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2882         assert(fd >= 0);
2883
2884         /* Under the assumption that we are running privileged we
2885          * first change the access mode and only then hand out
2886          * ownership to avoid a window where access is too open. */
2887
2888         if (mode != (mode_t) -1)
2889                 if (fchmod(fd, mode) < 0)
2890                         return -errno;
2891
2892         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2893                 if (fchown(fd, uid, gid) < 0)
2894                         return -errno;
2895
2896         return 0;
2897 }
2898
2899 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2900         cpu_set_t *r;
2901         unsigned n = 1024;
2902
2903         /* Allocates the cpuset in the right size */
2904
2905         for (;;) {
2906                 if (!(r = CPU_ALLOC(n)))
2907                         return NULL;
2908
2909                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2910                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2911
2912                         if (ncpus)
2913                                 *ncpus = n;
2914
2915                         return r;
2916                 }
2917
2918                 CPU_FREE(r);
2919
2920                 if (errno != EINVAL)
2921                         return NULL;
2922
2923                 n *= 2;
2924         }
2925 }
2926
2927 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2928         static const char status_indent[] = "         "; /* "[" STATUS "] " */
2929         _cleanup_free_ char *s = NULL;
2930         _cleanup_close_ int fd = -1;
2931         struct iovec iovec[6] = {};
2932         int n = 0;
2933         static bool prev_ephemeral;
2934
2935         assert(format);
2936
2937         /* This is independent of logging, as status messages are
2938          * optional and go exclusively to the console. */
2939
2940         if (vasprintf(&s, format, ap) < 0)
2941                 return log_oom();
2942
2943         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2944         if (fd < 0)
2945                 return fd;
2946
2947         if (ellipse) {
2948                 char *e;
2949                 size_t emax, sl;
2950                 int c;
2951
2952                 c = fd_columns(fd);
2953                 if (c <= 0)
2954                         c = 80;
2955
2956                 sl = status ? sizeof(status_indent)-1 : 0;
2957
2958                 emax = c - sl - 1;
2959                 if (emax < 3)
2960                         emax = 3;
2961
2962                 e = ellipsize(s, emax, 75);
2963                 if (e) {
2964                         free(s);
2965                         s = e;
2966                 }
2967         }
2968
2969         if (prev_ephemeral)
2970                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2971         prev_ephemeral = ephemeral;
2972
2973         if (status) {
2974                 if (!isempty(status)) {
2975                         IOVEC_SET_STRING(iovec[n++], "[");
2976                         IOVEC_SET_STRING(iovec[n++], status);
2977                         IOVEC_SET_STRING(iovec[n++], "] ");
2978                 } else
2979                         IOVEC_SET_STRING(iovec[n++], status_indent);
2980         }
2981
2982         IOVEC_SET_STRING(iovec[n++], s);
2983         if (!ephemeral)
2984                 IOVEC_SET_STRING(iovec[n++], "\n");
2985
2986         if (writev(fd, iovec, n) < 0)
2987                 return -errno;
2988
2989         return 0;
2990 }
2991
2992 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
2993         va_list ap;
2994         int r;
2995
2996         assert(format);
2997
2998         va_start(ap, format);
2999         r = status_vprintf(status, ellipse, ephemeral, format, ap);
3000         va_end(ap);
3001
3002         return r;
3003 }
3004
3005 char *replace_env(const char *format, char **env) {
3006         enum {
3007                 WORD,
3008                 CURLY,
3009                 VARIABLE
3010         } state = WORD;
3011
3012         const char *e, *word = format;
3013         char *r = NULL, *k;
3014
3015         assert(format);
3016
3017         for (e = format; *e; e ++) {
3018
3019                 switch (state) {
3020
3021                 case WORD:
3022                         if (*e == '$')
3023                                 state = CURLY;
3024                         break;
3025
3026                 case CURLY:
3027                         if (*e == '{') {
3028                                 if (!(k = strnappend(r, word, e-word-1)))
3029                                         goto fail;
3030
3031                                 free(r);
3032                                 r = k;
3033
3034                                 word = e-1;
3035                                 state = VARIABLE;
3036
3037                         } else if (*e == '$') {
3038                                 if (!(k = strnappend(r, word, e-word)))
3039                                         goto fail;
3040
3041                                 free(r);
3042                                 r = k;
3043
3044                                 word = e+1;
3045                                 state = WORD;
3046                         } else
3047                                 state = WORD;
3048                         break;
3049
3050                 case VARIABLE:
3051                         if (*e == '}') {
3052                                 const char *t;
3053
3054                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3055
3056                                 k = strappend(r, t);
3057                                 if (!k)
3058                                         goto fail;
3059
3060                                 free(r);
3061                                 r = k;
3062
3063                                 word = e+1;
3064                                 state = WORD;
3065                         }
3066                         break;
3067                 }
3068         }
3069
3070         if (!(k = strnappend(r, word, e-word)))
3071                 goto fail;
3072
3073         free(r);
3074         return k;
3075
3076 fail:
3077         free(r);
3078         return NULL;
3079 }
3080
3081 char **replace_env_argv(char **argv, char **env) {
3082         char **r, **i;
3083         unsigned k = 0, l = 0;
3084
3085         l = strv_length(argv);
3086
3087         if (!(r = new(char*, l+1)))
3088                 return NULL;
3089
3090         STRV_FOREACH(i, argv) {
3091
3092                 /* If $FOO appears as single word, replace it by the split up variable */
3093                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3094                         char *e;
3095                         char **w, **m;
3096                         unsigned q;
3097
3098                         e = strv_env_get(env, *i+1);
3099                         if (e) {
3100
3101                                 if (!(m = strv_split_quoted(e))) {
3102                                         r[k] = NULL;
3103                                         strv_free(r);
3104                                         return NULL;
3105                                 }
3106                         } else
3107                                 m = NULL;
3108
3109                         q = strv_length(m);
3110                         l = l + q - 1;
3111
3112                         if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3113                                 r[k] = NULL;
3114                                 strv_free(r);
3115                                 strv_free(m);
3116                                 return NULL;
3117                         }
3118
3119                         r = w;
3120                         if (m) {
3121                                 memcpy(r + k, m, q * sizeof(char*));
3122                                 free(m);
3123                         }
3124
3125                         k += q;
3126                         continue;
3127                 }
3128
3129                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3130                 if (!(r[k++] = replace_env(*i, env))) {
3131                         strv_free(r);
3132                         return NULL;
3133                 }
3134         }
3135
3136         r[k] = NULL;
3137         return r;
3138 }
3139
3140 int fd_columns(int fd) {
3141         struct winsize ws = {};
3142
3143         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3144                 return -errno;
3145
3146         if (ws.ws_col <= 0)
3147                 return -EIO;
3148
3149         return ws.ws_col;
3150 }
3151
3152 unsigned columns(void) {
3153         const char *e;
3154         int c;
3155
3156         if (_likely_(cached_columns > 0))
3157                 return cached_columns;
3158
3159         c = 0;
3160         e = getenv("COLUMNS");
3161         if (e)
3162                 safe_atoi(e, &c);
3163
3164         if (c <= 0)
3165                 c = fd_columns(STDOUT_FILENO);
3166
3167         if (c <= 0)
3168                 c = 80;
3169
3170         cached_columns = c;
3171         return c;
3172 }
3173
3174 int fd_lines(int fd) {
3175         struct winsize ws = {};
3176
3177         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3178                 return -errno;
3179
3180         if (ws.ws_row <= 0)
3181                 return -EIO;
3182
3183         return ws.ws_row;
3184 }
3185
3186 unsigned lines(void) {
3187         const char *e;
3188         unsigned l;
3189
3190         if (_likely_(cached_lines > 0))
3191                 return cached_lines;
3192
3193         l = 0;
3194         e = getenv("LINES");
3195         if (e)
3196                 safe_atou(e, &l);
3197
3198         if (l <= 0)
3199                 l = fd_lines(STDOUT_FILENO);
3200
3201         if (l <= 0)
3202                 l = 24;
3203
3204         cached_lines = l;
3205         return cached_lines;
3206 }
3207
3208 /* intended to be used as a SIGWINCH sighandler */
3209 void columns_lines_cache_reset(int signum) {
3210         cached_columns = 0;
3211         cached_lines = 0;
3212 }
3213
3214 bool on_tty(void) {
3215         static int cached_on_tty = -1;
3216
3217         if (_unlikely_(cached_on_tty < 0))
3218                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3219
3220         return cached_on_tty;
3221 }
3222
3223 int files_same(const char *filea, const char *fileb) {
3224         struct stat a, b;
3225
3226         if (stat(filea, &a) < 0)
3227                 return -errno;
3228
3229         if (stat(fileb, &b) < 0)
3230                 return -errno;
3231
3232         return a.st_dev == b.st_dev &&
3233                a.st_ino == b.st_ino;
3234 }
3235
3236 int running_in_chroot(void) {
3237         int ret;
3238
3239         ret = files_same("/proc/1/root", "/");
3240         if (ret < 0)
3241                 return ret;
3242
3243         return ret == 0;
3244 }
3245
3246 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3247         size_t x;
3248         char *r;
3249
3250         assert(s);
3251         assert(percent <= 100);
3252         assert(new_length >= 3);
3253
3254         if (old_length <= 3 || old_length <= new_length)
3255                 return strndup(s, old_length);
3256
3257         r = new0(char, new_length+1);
3258         if (!r)
3259                 return NULL;
3260
3261         x = (new_length * percent) / 100;
3262
3263         if (x > new_length - 3)
3264                 x = new_length - 3;
3265
3266         memcpy(r, s, x);
3267         r[x] = '.';
3268         r[x+1] = '.';
3269         r[x+2] = '.';
3270         memcpy(r + x + 3,
3271                s + old_length - (new_length - x - 3),
3272                new_length - x - 3);
3273
3274         return r;
3275 }
3276
3277 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3278         size_t x;
3279         char *e;
3280         const char *i, *j;
3281         unsigned k, len, len2;
3282
3283         assert(s);
3284         assert(percent <= 100);
3285         assert(new_length >= 3);
3286
3287         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3288         if (ascii_is_valid(s))
3289                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3290
3291         if (old_length <= 3 || old_length <= new_length)
3292                 return strndup(s, old_length);
3293
3294         x = (new_length * percent) / 100;
3295
3296         if (x > new_length - 3)
3297                 x = new_length - 3;
3298
3299         k = 0;
3300         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3301                 int c;
3302
3303                 c = utf8_encoded_to_unichar(i);
3304                 if (c < 0)
3305                         return NULL;
3306                 k += unichar_iswide(c) ? 2 : 1;
3307         }
3308
3309         if (k > x) /* last character was wide and went over quota */
3310                 x ++;
3311
3312         for (j = s + old_length; k < new_length && j > i; ) {
3313                 int c;
3314
3315                 j = utf8_prev_char(j);
3316                 c = utf8_encoded_to_unichar(j);
3317                 if (c < 0)
3318                         return NULL;
3319                 k += unichar_iswide(c) ? 2 : 1;
3320         }
3321         assert(i <= j);
3322
3323         /* we don't actually need to ellipsize */
3324         if (i == j)
3325                 return memdup(s, old_length + 1);
3326
3327         /* make space for ellipsis */
3328         j = utf8_next_char(j);
3329
3330         len = i - s;
3331         len2 = s + old_length - j;
3332         e = new(char, len + 3 + len2 + 1);
3333         if (!e)
3334                 return NULL;
3335
3336         /*
3337         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3338                old_length, new_length, x, len, len2, k);
3339         */
3340
3341         memcpy(e, s, len);
3342         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3343         e[len + 1] = 0x80;
3344         e[len + 2] = 0xa6;
3345
3346         memcpy(e + len + 3, j, len2 + 1);
3347
3348         return e;
3349 }
3350
3351 char *ellipsize(const char *s, size_t length, unsigned percent) {
3352         return ellipsize_mem(s, strlen(s), length, percent);
3353 }
3354
3355 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
3356         _cleanup_close_ int fd;
3357         int r;
3358
3359         assert(path);
3360
3361         if (parents)
3362                 mkdir_parents(path, 0755);
3363
3364         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3365         if (fd < 0)
3366                 return -errno;
3367
3368         if (mode > 0) {
3369                 r = fchmod(fd, mode);
3370                 if (r < 0)
3371                         return -errno;
3372         }
3373
3374         if (uid != (uid_t) -1 || gid != (gid_t) -1) {
3375                 r = fchown(fd, uid, gid);
3376                 if (r < 0)
3377                         return -errno;
3378         }
3379
3380         if (stamp != (usec_t) -1) {
3381                 struct timespec ts[2];
3382
3383                 timespec_store(&ts[0], stamp);
3384                 ts[1] = ts[0];
3385                 r = futimens(fd, ts);
3386         } else
3387                 r = futimens(fd, NULL);
3388         if (r < 0)
3389                 return -errno;
3390
3391         return 0;
3392 }
3393
3394 int touch(const char *path) {
3395         return touch_file(path, false, (usec_t) -1, (uid_t) -1, (gid_t) -1, 0);
3396 }
3397
3398 char *unquote(const char *s, const char* quotes) {
3399         size_t l;
3400         assert(s);
3401
3402         /* This is rather stupid, simply removes the heading and
3403          * trailing quotes if there is one. Doesn't care about
3404          * escaping or anything. We should make this smarter one
3405          * day...*/
3406
3407         l = strlen(s);
3408         if (l < 2)
3409                 return strdup(s);
3410
3411         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3412                 return strndup(s+1, l-2);
3413
3414         return strdup(s);
3415 }
3416
3417 char *normalize_env_assignment(const char *s) {
3418         _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3419         char *eq, *r;
3420
3421         eq = strchr(s, '=');
3422         if (!eq) {
3423                 char *t;
3424
3425                 r = strdup(s);
3426                 if (!r)
3427                         return NULL;
3428
3429                 t = strstrip(r);
3430                 if (t == r)
3431                         return r;
3432
3433                 memmove(r, t, strlen(t) + 1);
3434                 return r;
3435         }
3436
3437         name = strndup(s, eq - s);
3438         if (!name)
3439                 return NULL;
3440
3441         p = strdup(eq + 1);
3442         if (!p)
3443                 return NULL;
3444
3445         value = unquote(strstrip(p), QUOTES);
3446         if (!value)
3447                 return NULL;
3448
3449         if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3450                 r = NULL;
3451
3452         return r;
3453 }
3454
3455 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3456         siginfo_t dummy;
3457
3458         assert(pid >= 1);
3459
3460         if (!status)
3461                 status = &dummy;
3462
3463         for (;;) {
3464                 zero(*status);
3465
3466                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3467
3468                         if (errno == EINTR)
3469                                 continue;
3470
3471                         return -errno;
3472                 }
3473
3474                 return 0;
3475         }
3476 }
3477
3478 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3479         int r;
3480         siginfo_t status;
3481
3482         assert(name);
3483         assert(pid > 1);
3484
3485         r = wait_for_terminate(pid, &status);
3486         if (r < 0) {
3487                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3488                 return r;
3489         }
3490
3491         if (status.si_code == CLD_EXITED) {
3492                 if (status.si_status != 0) {
3493                         log_warning("%s failed with error code %i.", name, status.si_status);
3494                         return status.si_status;
3495                 }
3496
3497                 log_debug("%s succeeded.", name);
3498                 return 0;
3499
3500         } else if (status.si_code == CLD_KILLED ||
3501                    status.si_code == CLD_DUMPED) {
3502
3503                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3504                 return -EPROTO;
3505         }
3506
3507         log_warning("%s failed due to unknown reason.", name);
3508         return -EPROTO;
3509 }
3510
3511 noreturn void freeze(void) {
3512
3513         /* Make sure nobody waits for us on a socket anymore */
3514         close_all_fds(NULL, 0);
3515
3516         sync();
3517
3518         for (;;)
3519                 pause();
3520 }
3521
3522 bool null_or_empty(struct stat *st) {
3523         assert(st);
3524
3525         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3526                 return true;
3527
3528         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3529                 return true;
3530
3531         return false;
3532 }
3533
3534 int null_or_empty_path(const char *fn) {
3535         struct stat st;
3536
3537         assert(fn);
3538
3539         if (stat(fn, &st) < 0)
3540                 return -errno;
3541
3542         return null_or_empty(&st);
3543 }
3544
3545 DIR *xopendirat(int fd, const char *name, int flags) {
3546         int nfd;
3547         DIR *d;
3548
3549         assert(!(flags & O_CREAT));
3550
3551         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3552         if (nfd < 0)
3553                 return NULL;
3554
3555         d = fdopendir(nfd);
3556         if (!d) {
3557                 safe_close(nfd);
3558                 return NULL;
3559         }
3560
3561         return d;
3562 }
3563
3564 int signal_from_string_try_harder(const char *s) {
3565         int signo;
3566         assert(s);
3567
3568         signo = signal_from_string(s);
3569         if (signo <= 0)
3570                 if (startswith(s, "SIG"))
3571                         return signal_from_string(s+3);
3572
3573         return signo;
3574 }
3575
3576 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3577         _cleanup_free_ char *t = NULL, *u = NULL;
3578         size_t enc_len;
3579
3580         u = unquote(tagvalue, "\"\'");
3581         if (!u)
3582                 return NULL;
3583
3584         enc_len = strlen(u) * 4 + 1;
3585         t = new(char, enc_len);
3586         if (!t)
3587                 return NULL;
3588
3589         if (encode_devnode_name(u, t, enc_len) < 0)
3590                 return NULL;
3591
3592         return strjoin("/dev/disk/by-", by, "/", t, NULL);
3593 }
3594
3595 char *fstab_node_to_udev_node(const char *p) {
3596         assert(p);
3597
3598         if (startswith(p, "LABEL="))
3599                 return tag_to_udev_node(p+6, "label");
3600
3601         if (startswith(p, "UUID="))
3602                 return tag_to_udev_node(p+5, "uuid");
3603
3604         if (startswith(p, "PARTUUID="))
3605                 return tag_to_udev_node(p+9, "partuuid");
3606
3607         if (startswith(p, "PARTLABEL="))
3608                 return tag_to_udev_node(p+10, "partlabel");
3609
3610         return strdup(p);
3611 }
3612
3613 bool tty_is_vc(const char *tty) {
3614         assert(tty);
3615
3616         return vtnr_from_tty(tty) >= 0;
3617 }
3618
3619 bool tty_is_console(const char *tty) {
3620         assert(tty);
3621
3622         if (startswith(tty, "/dev/"))
3623                 tty += 5;
3624
3625         return streq(tty, "console");
3626 }
3627
3628 int vtnr_from_tty(const char *tty) {
3629         int i, r;
3630
3631         assert(tty);
3632
3633         if (startswith(tty, "/dev/"))
3634                 tty += 5;
3635
3636         if (!startswith(tty, "tty") )
3637                 return -EINVAL;
3638
3639         if (tty[3] < '0' || tty[3] > '9')
3640                 return -EINVAL;
3641
3642         r = safe_atoi(tty+3, &i);
3643         if (r < 0)
3644                 return r;
3645
3646         if (i < 0 || i > 63)
3647                 return -EINVAL;
3648
3649         return i;
3650 }
3651
3652 char *resolve_dev_console(char **active) {
3653         char *tty;
3654
3655         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3656          * (i.e. not read-only-mounted which is a sign for container setups) */
3657
3658         if (path_is_read_only_fs("/sys") > 0)
3659                 return NULL;
3660
3661         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3662                 return NULL;
3663
3664         /* If multiple log outputs are configured the last one is what
3665          * /dev/console points to */
3666         tty = strrchr(*active, ' ');
3667         if (tty)
3668                 tty++;
3669         else
3670                 tty = *active;
3671
3672         if (streq(tty, "tty0")) {
3673                 char *tmp;
3674
3675                 /* Get the active VC (e.g. tty1) */
3676                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3677                         free(*active);
3678                         tty = *active = tmp;
3679                 }
3680         }
3681
3682         return tty;
3683 }
3684
3685 bool tty_is_vc_resolve(const char *tty) {
3686         _cleanup_free_ char *active = NULL;
3687
3688         assert(tty);
3689
3690         if (startswith(tty, "/dev/"))
3691                 tty += 5;
3692
3693         if (streq(tty, "console")) {
3694                 tty = resolve_dev_console(&active);
3695                 if (!tty)
3696                         return false;
3697         }
3698
3699         return tty_is_vc(tty);
3700 }
3701
3702 const char *default_term_for_tty(const char *tty) {
3703         assert(tty);
3704
3705         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3706 }
3707
3708 bool dirent_is_file(const struct dirent *de) {
3709         assert(de);
3710
3711         if (ignore_file(de->d_name))
3712                 return false;
3713
3714         if (de->d_type != DT_REG &&
3715             de->d_type != DT_LNK &&
3716             de->d_type != DT_UNKNOWN)
3717                 return false;
3718
3719         return true;
3720 }
3721
3722 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3723         assert(de);
3724
3725         if (de->d_type != DT_REG &&
3726             de->d_type != DT_LNK &&
3727             de->d_type != DT_UNKNOWN)
3728                 return false;
3729
3730         if (ignore_file_allow_backup(de->d_name))
3731                 return false;
3732
3733         return endswith(de->d_name, suffix);
3734 }
3735
3736 void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {
3737         pid_t executor_pid;
3738         int r;
3739
3740         assert(directory);
3741
3742         /* Executes all binaries in a directory in parallel and waits
3743          * for them to finish. Optionally a timeout is applied. */
3744
3745         executor_pid = fork();
3746         if (executor_pid < 0) {
3747                 log_error("Failed to fork: %m");
3748                 return;
3749
3750         } else if (executor_pid == 0) {
3751                 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
3752                 _cleanup_closedir_ DIR *_d = NULL;
3753                 struct dirent *de;
3754                 sigset_t ss;
3755
3756                 /* We fork this all off from a child process so that
3757                  * we can somewhat cleanly make use of SIGALRM to set
3758                  * a time limit */
3759
3760                 reset_all_signal_handlers();
3761
3762                 assert_se(sigemptyset(&ss) == 0);
3763                 assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);
3764
3765                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3766
3767                 if (!d) {
3768                         d = _d = opendir(directory);
3769                         if (!d) {
3770                                 if (errno == ENOENT)
3771                                         _exit(EXIT_SUCCESS);
3772
3773                                 log_error("Failed to enumerate directory %s: %m", directory);
3774                                 _exit(EXIT_FAILURE);
3775                         }
3776                 }
3777
3778                 pids = hashmap_new(NULL, NULL);
3779                 if (!pids) {
3780                         log_oom();
3781                         _exit(EXIT_FAILURE);
3782                 }
3783
3784                 FOREACH_DIRENT(de, d, break) {
3785                         _cleanup_free_ char *path = NULL;
3786                         pid_t pid;
3787
3788                         if (!dirent_is_file(de))
3789                                 continue;
3790
3791                         if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
3792                                 log_oom();
3793                                 _exit(EXIT_FAILURE);
3794                         }
3795
3796                         pid = fork();
3797                         if (pid < 0) {
3798                                 log_error("Failed to fork: %m");
3799                                 continue;
3800                         } else if (pid == 0) {
3801                                 char *_argv[2];
3802
3803                                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3804
3805                                 if (!argv) {
3806                                         _argv[0] = path;
3807                                         _argv[1] = NULL;
3808                                         argv = _argv;
3809                                 } else
3810                                         argv[0] = path;
3811
3812                                 execv(path, argv);
3813                                 log_error("Failed to execute %s: %m", path);
3814                                 _exit(EXIT_FAILURE);
3815                         }
3816
3817
3818                         log_debug("Spawned %s as " PID_FMT ".", path, pid);
3819
3820                         r = hashmap_put(pids, UINT_TO_PTR(pid), path);
3821                         if (r < 0) {
3822                                 log_oom();
3823                                 _exit(EXIT_FAILURE);
3824                         }
3825
3826                         path = NULL;
3827                 }
3828
3829                 /* Abort execution of this process after the
3830                  * timout. We simply rely on SIGALRM as default action
3831                  * terminating the process, and turn on alarm(). */
3832
3833                 if (timeout != (usec_t) -1)
3834                         alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
3835
3836                 while (!hashmap_isempty(pids)) {
3837                         _cleanup_free_ char *path = NULL;
3838                         pid_t pid;
3839
3840                         pid = PTR_TO_UINT(hashmap_first_key(pids));
3841                         assert(pid > 0);
3842
3843                         path = hashmap_remove(pids, UINT_TO_PTR(pid));
3844                         assert(path);
3845
3846                         wait_for_terminate_and_warn(path, pid);
3847                 }
3848
3849                 _exit(EXIT_SUCCESS);
3850         }
3851
3852         wait_for_terminate_and_warn(directory, executor_pid);
3853 }
3854
3855 int kill_and_sigcont(pid_t pid, int sig) {
3856         int r;
3857
3858         r = kill(pid, sig) < 0 ? -errno : 0;
3859
3860         if (r >= 0)
3861                 kill(pid, SIGCONT);
3862
3863         return r;
3864 }
3865
3866 bool nulstr_contains(const char*nulstr, const char *needle) {
3867         const char *i;
3868
3869         if (!nulstr)
3870                 return false;
3871
3872         NULSTR_FOREACH(i, nulstr)
3873                 if (streq(i, needle))
3874                         return true;
3875
3876         return false;
3877 }
3878
3879 bool plymouth_running(void) {
3880         return access("/run/plymouth/pid", F_OK) >= 0;
3881 }
3882
3883 char* strshorten(char *s, size_t l) {
3884         assert(s);
3885
3886         if (l < strlen(s))
3887                 s[l] = 0;
3888
3889         return s;
3890 }
3891
3892 static bool hostname_valid_char(char c) {
3893         return
3894                 (c >= 'a' && c <= 'z') ||
3895                 (c >= 'A' && c <= 'Z') ||
3896                 (c >= '0' && c <= '9') ||
3897                 c == '-' ||
3898                 c == '_' ||
3899                 c == '.';
3900 }
3901
3902 bool hostname_is_valid(const char *s) {
3903         const char *p;
3904         bool dot;
3905
3906         if (isempty(s))
3907                 return false;
3908
3909         for (p = s, dot = true; *p; p++) {
3910                 if (*p == '.') {
3911                         if (dot)
3912                                 return false;
3913
3914                         dot = true;
3915                 } else {
3916                         if (!hostname_valid_char(*p))
3917                                 return false;
3918
3919                         dot = false;
3920                 }
3921         }
3922
3923         if (dot)
3924                 return false;
3925
3926         if (p-s > HOST_NAME_MAX)
3927                 return false;
3928
3929         return true;
3930 }
3931
3932 char* hostname_cleanup(char *s, bool lowercase) {
3933         char *p, *d;
3934         bool dot;
3935
3936         for (p = s, d = s, dot = true; *p; p++) {
3937                 if (*p == '.') {
3938                         if (dot)
3939                                 continue;
3940
3941                         *(d++) = '.';
3942                         dot = true;
3943                 } else if (hostname_valid_char(*p)) {
3944                         *(d++) = lowercase ? tolower(*p) : *p;
3945                         dot = false;
3946                 }
3947
3948         }
3949
3950         if (dot && d > s)
3951                 d[-1] = 0;
3952         else
3953                 *d = 0;
3954
3955         strshorten(s, HOST_NAME_MAX);
3956
3957         return s;
3958 }
3959
3960 int pipe_eof(int fd) {
3961         struct pollfd pollfd = {
3962                 .fd = fd,
3963                 .events = POLLIN|POLLHUP,
3964         };
3965