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