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