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