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