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