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