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