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