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