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