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