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