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