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