chiark / gitweb /
Get rid of some more unused defines and dirs
[elogind.git] / src / shared / util.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <string.h>
23 #include <unistd.h>
24 #include <errno.h>
25 #include <stdlib.h>
26 #include <signal.h>
27 #include <libintl.h>
28 #include <locale.h>
29 #include <stdio.h>
30 #include <syslog.h>
31 #include <sched.h>
32 #include <sys/resource.h>
33 #include <linux/sched.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <fcntl.h>
37 #include <dirent.h>
38 #include <sys/ioctl.h>
39 #include <linux/vt.h>
40 #include <linux/tiocl.h>
41 #include <termios.h>
42 #include <stdarg.h>
43 #include <poll.h>
44 #include <ctype.h>
45 #include <sys/prctl.h>
46 #include <sys/utsname.h>
47 #include <pwd.h>
48 #include <netinet/ip.h>
49 #include <linux/kd.h>
50 #include <sys/wait.h>
51 #include <sys/time.h>
52 #include <glob.h>
53 #include <grp.h>
54 #include <sys/mman.h>
55 #include <sys/vfs.h>
56 #include <sys/mount.h>
57 #include <linux/magic.h>
58 #include <limits.h>
59 #include <langinfo.h>
60 #include <locale.h>
61 #include <sys/personality.h>
62 #include <sys/xattr.h>
63 #include <sys/statvfs.h>
64 #include <sys/file.h>
65 #include <linux/fs.h>
66
67 /* When we include libgen.h because we need dirname() we immediately
68  * undefine basename() since libgen.h defines it as a macro to the XDG
69  * version which is really broken. */
70 #include <libgen.h>
71 #undef basename
72
73 #ifdef HAVE_SYS_AUXV_H
74 #include <sys/auxv.h>
75 #endif
76
77 #include "config.h"
78 #include "macro.h"
79 #include "util.h"
80 #include "ioprio.h"
81 #include "missing.h"
82 #include "log.h"
83 #include "strv.h"
84 #include "mkdir.h"
85 #include "path-util.h"
86 #include "exit-status.h"
87 #include "hashmap.h"
88 #include "env-util.h"
89 #include "fileio.h"
90 #include "device-nodes.h"
91 #include "utf8.h"
92 #include "gunicode.h"
93 #include "virt.h"
94 #include "def.h"
95 #include "sparse-endian.h"
96
97 /* Put this test here for a lack of better place */
98 assert_cc(EAGAIN == EWOULDBLOCK);
99
100 int saved_argc = 0;
101 char **saved_argv = NULL;
102
103 static volatile unsigned cached_columns = 0;
104 static volatile unsigned cached_lines = 0;
105
106 size_t page_size(void) {
107         static thread_local size_t pgsz = 0;
108         long r;
109
110         if (_likely_(pgsz > 0))
111                 return pgsz;
112
113         r = sysconf(_SC_PAGESIZE);
114         assert(r > 0);
115
116         pgsz = (size_t) r;
117         return pgsz;
118 }
119
120 bool streq_ptr(const char *a, const char *b) {
121
122         /* Like streq(), but tries to make sense of NULL pointers */
123
124         if (a && b)
125                 return streq(a, b);
126
127         if (!a && !b)
128                 return true;
129
130         return false;
131 }
132
133 char* endswith(const char *s, const char *postfix) {
134         size_t sl, pl;
135
136         assert(s);
137         assert(postfix);
138
139         sl = strlen(s);
140         pl = strlen(postfix);
141
142         if (pl == 0)
143                 return (char*) s + sl;
144
145         if (sl < pl)
146                 return NULL;
147
148         if (memcmp(s + sl - pl, postfix, pl) != 0)
149                 return NULL;
150
151         return (char*) s + sl - pl;
152 }
153
154 char* 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. */
1337
1338         r = new(char, strlen(s)*4 + 1);
1339         if (!r)
1340                 return NULL;
1341
1342         for (f = s, t = r; *f; f++)
1343                 t += cescape_char(*f, t);
1344
1345         *t = 0;
1346
1347         return r;
1348 }
1349
1350 static int cunescape_one(const char *p, size_t length, char *ret) {
1351         int r = 1;
1352
1353         assert(p);
1354         assert(*p);
1355         assert(ret);
1356
1357         if (length != (size_t) -1 && length < 1)
1358                 return -EINVAL;
1359
1360         switch (p[0]) {
1361
1362         case 'a':
1363                 *ret = '\a';
1364                 break;
1365         case 'b':
1366                 *ret = '\b';
1367                 break;
1368         case 'f':
1369                 *ret = '\f';
1370                 break;
1371         case 'n':
1372                 *ret = '\n';
1373                 break;
1374         case 'r':
1375                 *ret = '\r';
1376                 break;
1377         case 't':
1378                 *ret = '\t';
1379                 break;
1380         case 'v':
1381                 *ret = '\v';
1382                 break;
1383         case '\\':
1384                 *ret = '\\';
1385                 break;
1386         case '"':
1387                 *ret = '"';
1388                 break;
1389         case '\'':
1390                 *ret = '\'';
1391                 break;
1392
1393         case 's':
1394                 /* This is an extension of the XDG syntax files */
1395                 *ret = ' ';
1396                 break;
1397
1398         case 'x': {
1399                 /* hexadecimal encoding */
1400                 int a, b;
1401
1402                 if (length != (size_t) -1 && length < 3)
1403                         return -EINVAL;
1404
1405                 a = unhexchar(p[1]);
1406                 if (a < 0)
1407                         return -EINVAL;
1408
1409                 b = unhexchar(p[2]);
1410                 if (b < 0)
1411                         return -EINVAL;
1412
1413                 /* don't allow NUL bytes */
1414                 if (a == 0 && b == 0)
1415                         return -EINVAL;
1416
1417                 *ret = (char) ((a << 4) | b);
1418                 r = 3;
1419                 break;
1420         }
1421
1422         case '0':
1423         case '1':
1424         case '2':
1425         case '3':
1426         case '4':
1427         case '5':
1428         case '6':
1429         case '7': {
1430                 /* octal encoding */
1431                 int a, b, c, m;
1432
1433                 if (length != (size_t) -1 && length < 4)
1434                         return -EINVAL;
1435
1436                 a = unoctchar(p[0]);
1437                 if (a < 0)
1438                         return -EINVAL;
1439
1440                 b = unoctchar(p[1]);
1441                 if (b < 0)
1442                         return -EINVAL;
1443
1444                 c = unoctchar(p[2]);
1445                 if (c < 0)
1446                         return -EINVAL;
1447
1448                 /* don't allow NUL bytes */
1449                 if (a == 0 && b == 0 && c == 0)
1450                         return -EINVAL;
1451
1452                 /* Don't allow bytes above 255 */
1453                 m = (a << 6) | (b << 3) | c;
1454                 if (m > 255)
1455                         return -EINVAL;
1456
1457                 *ret = (char) m;
1458                 r = 3;
1459                 break;
1460         }
1461
1462         default:
1463                 return -EINVAL;
1464         }
1465
1466         return r;
1467 }
1468
1469 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1470         char *r, *t;
1471         const char *f;
1472         size_t pl;
1473
1474         assert(s);
1475
1476         /* Undoes C style string escaping, and optionally prefixes it. */
1477
1478         pl = prefix ? strlen(prefix) : 0;
1479
1480         r = new(char, pl+length+1);
1481         if (!r)
1482                 return NULL;
1483
1484         if (prefix)
1485                 memcpy(r, prefix, pl);
1486
1487         for (f = s, t = r + pl; f < s + length; f++) {
1488                 size_t remaining;
1489                 int k;
1490
1491                 remaining = s + length - f;
1492                 assert(remaining > 0);
1493
1494                 if (*f != '\\' || remaining == 1) {
1495                         /* a literal literal, or a trailing backslash, copy verbatim */
1496                         *(t++) = *f;
1497                         continue;
1498                 }
1499
1500                 k = cunescape_one(f + 1, remaining - 1, t);
1501                 if (k < 0) {
1502                         /* Invalid escape code, let's take it literal then */
1503                         *(t++) = '\\';
1504                         continue;
1505                 }
1506
1507                 f += k;
1508                 t++;
1509         }
1510
1511         *t = 0;
1512         return r;
1513 }
1514
1515 char *cunescape_length(const char *s, size_t length) {
1516         return cunescape_length_with_prefix(s, length, NULL);
1517 }
1518
1519 char *cunescape(const char *s) {
1520         assert(s);
1521
1522         return cunescape_length(s, strlen(s));
1523 }
1524
1525 char *xescape(const char *s, const char *bad) {
1526         char *r, *t;
1527         const char *f;
1528
1529         /* Escapes all chars in bad, in addition to \ and all special
1530          * chars, in \xFF style escaping. May be reversed with
1531          * cunescape. */
1532
1533         r = new(char, strlen(s) * 4 + 1);
1534         if (!r)
1535                 return NULL;
1536
1537         for (f = s, t = r; *f; f++) {
1538
1539                 if ((*f < ' ') || (*f >= 127) ||
1540                     (*f == '\\') || strchr(bad, *f)) {
1541                         *(t++) = '\\';
1542                         *(t++) = 'x';
1543                         *(t++) = hexchar(*f >> 4);
1544                         *(t++) = hexchar(*f);
1545                 } else
1546                         *(t++) = *f;
1547         }
1548
1549         *t = 0;
1550
1551         return r;
1552 }
1553
1554 char *ascii_strlower(char *t) {
1555         char *p;
1556
1557         assert(t);
1558
1559         for (p = t; *p; p++)
1560                 if (*p >= 'A' && *p <= 'Z')
1561                         *p = *p - 'A' + 'a';
1562
1563         return t;
1564 }
1565
1566 _pure_ static bool hidden_file_allow_backup(const char *filename) {
1567         assert(filename);
1568
1569         return
1570                 filename[0] == '.' ||
1571                 streq(filename, "lost+found") ||
1572                 streq(filename, "aquota.user") ||
1573                 streq(filename, "aquota.group") ||
1574                 endswith(filename, ".rpmnew") ||
1575                 endswith(filename, ".rpmsave") ||
1576                 endswith(filename, ".rpmorig") ||
1577                 endswith(filename, ".dpkg-old") ||
1578                 endswith(filename, ".dpkg-new") ||
1579                 endswith(filename, ".dpkg-tmp") ||
1580                 endswith(filename, ".dpkg-dist") ||
1581                 endswith(filename, ".dpkg-bak") ||
1582                 endswith(filename, ".dpkg-backup") ||
1583                 endswith(filename, ".dpkg-remove") ||
1584                 endswith(filename, ".swp");
1585 }
1586
1587 bool hidden_file(const char *filename) {
1588         assert(filename);
1589
1590         if (endswith(filename, "~"))
1591                 return true;
1592
1593         return hidden_file_allow_backup(filename);
1594 }
1595
1596 int fd_nonblock(int fd, bool nonblock) {
1597         int flags, nflags;
1598
1599         assert(fd >= 0);
1600
1601         flags = fcntl(fd, F_GETFL, 0);
1602         if (flags < 0)
1603                 return -errno;
1604
1605         if (nonblock)
1606                 nflags = flags | O_NONBLOCK;
1607         else
1608                 nflags = flags & ~O_NONBLOCK;
1609
1610         if (nflags == flags)
1611                 return 0;
1612
1613         if (fcntl(fd, F_SETFL, nflags) < 0)
1614                 return -errno;
1615
1616         return 0;
1617 }
1618
1619 int fd_cloexec(int fd, bool cloexec) {
1620         int flags, nflags;
1621
1622         assert(fd >= 0);
1623
1624         flags = fcntl(fd, F_GETFD, 0);
1625         if (flags < 0)
1626                 return -errno;
1627
1628         if (cloexec)
1629                 nflags = flags | FD_CLOEXEC;
1630         else
1631                 nflags = flags & ~FD_CLOEXEC;
1632
1633         if (nflags == flags)
1634                 return 0;
1635
1636         if (fcntl(fd, F_SETFD, nflags) < 0)
1637                 return -errno;
1638
1639         return 0;
1640 }
1641
1642 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1643         unsigned i;
1644
1645         assert(n_fdset == 0 || fdset);
1646
1647         for (i = 0; i < n_fdset; i++)
1648                 if (fdset[i] == fd)
1649                         return true;
1650
1651         return false;
1652 }
1653
1654 int close_all_fds(const int except[], unsigned n_except) {
1655         _cleanup_closedir_ DIR *d = NULL;
1656         struct dirent *de;
1657         int r = 0;
1658
1659         assert(n_except == 0 || except);
1660
1661         d = opendir("/proc/self/fd");
1662         if (!d) {
1663                 int fd;
1664                 struct rlimit rl;
1665
1666                 /* When /proc isn't available (for example in chroots)
1667                  * the fallback is brute forcing through the fd
1668                  * table */
1669
1670                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1671                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1672
1673                         if (fd_in_set(fd, except, n_except))
1674                                 continue;
1675
1676                         if (close_nointr(fd) < 0)
1677                                 if (errno != EBADF && r == 0)
1678                                         r = -errno;
1679                 }
1680
1681                 return r;
1682         }
1683
1684         while ((de = readdir(d))) {
1685                 int fd = -1;
1686
1687                 if (hidden_file(de->d_name))
1688                         continue;
1689
1690                 if (safe_atoi(de->d_name, &fd) < 0)
1691                         /* Let's better ignore this, just in case */
1692                         continue;
1693
1694                 if (fd < 3)
1695                         continue;
1696
1697                 if (fd == dirfd(d))
1698                         continue;
1699
1700                 if (fd_in_set(fd, except, n_except))
1701                         continue;
1702
1703                 if (close_nointr(fd) < 0) {
1704                         /* Valgrind has its own FD and doesn't want to have it closed */
1705                         if (errno != EBADF && r == 0)
1706                                 r = -errno;
1707                 }
1708         }
1709
1710         return r;
1711 }
1712
1713 bool chars_intersect(const char *a, const char *b) {
1714         const char *p;
1715
1716         /* Returns true if any of the chars in a are in b. */
1717         for (p = a; *p; p++)
1718                 if (strchr(b, *p))
1719                         return true;
1720
1721         return false;
1722 }
1723
1724 bool fstype_is_network(const char *fstype) {
1725         static const char table[] =
1726                 "afs\0"
1727                 "cifs\0"
1728                 "smbfs\0"
1729                 "sshfs\0"
1730                 "ncpfs\0"
1731                 "ncp\0"
1732                 "nfs\0"
1733                 "nfs4\0"
1734                 "gfs\0"
1735                 "gfs2\0"
1736                 "glusterfs\0";
1737
1738         const char *x;
1739
1740         x = startswith(fstype, "fuse.");
1741         if (x)
1742                 fstype = x;
1743
1744         return nulstr_contains(table, fstype);
1745 }
1746
1747 int chvt(int vt) {
1748         _cleanup_close_ int fd;
1749
1750         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1751         if (fd < 0)
1752                 return -errno;
1753
1754         if (vt < 0) {
1755                 int tiocl[2] = {
1756                         TIOCL_GETKMSGREDIRECT,
1757                         0
1758                 };
1759
1760                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1761                         return -errno;
1762
1763                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1764         }
1765
1766         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1767                 return -errno;
1768
1769         return 0;
1770 }
1771
1772 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1773         struct termios old_termios, new_termios;
1774         char c, line[LINE_MAX];
1775
1776         assert(f);
1777         assert(ret);
1778
1779         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1780                 new_termios = old_termios;
1781
1782                 new_termios.c_lflag &= ~ICANON;
1783                 new_termios.c_cc[VMIN] = 1;
1784                 new_termios.c_cc[VTIME] = 0;
1785
1786                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1787                         size_t k;
1788
1789                         if (t != USEC_INFINITY) {
1790                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1791                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1792                                         return -ETIMEDOUT;
1793                                 }
1794                         }
1795
1796                         k = fread(&c, 1, 1, f);
1797
1798                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1799
1800                         if (k <= 0)
1801                                 return -EIO;
1802
1803                         if (need_nl)
1804                                 *need_nl = c != '\n';
1805
1806                         *ret = c;
1807                         return 0;
1808                 }
1809         }
1810
1811         if (t != USEC_INFINITY) {
1812                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1813                         return -ETIMEDOUT;
1814         }
1815
1816         errno = 0;
1817         if (!fgets(line, sizeof(line), f))
1818                 return errno ? -errno : -EIO;
1819
1820         truncate_nl(line);
1821
1822         if (strlen(line) != 1)
1823                 return -EBADMSG;
1824
1825         if (need_nl)
1826                 *need_nl = false;
1827
1828         *ret = line[0];
1829         return 0;
1830 }
1831
1832 int ask_char(char *ret, const char *replies, const char *text, ...) {
1833         int r;
1834
1835         assert(ret);
1836         assert(replies);
1837         assert(text);
1838
1839         for (;;) {
1840                 va_list ap;
1841                 char c;
1842                 bool need_nl = true;
1843
1844                 if (on_tty())
1845                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1846
1847                 va_start(ap, text);
1848                 vprintf(text, ap);
1849                 va_end(ap);
1850
1851                 if (on_tty())
1852                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1853
1854                 fflush(stdout);
1855
1856                 r = read_one_char(stdin, &c, USEC_INFINITY, &need_nl);
1857                 if (r < 0) {
1858
1859                         if (r == -EBADMSG) {
1860                                 puts("Bad input, please try again.");
1861                                 continue;
1862                         }
1863
1864                         putchar('\n');
1865                         return r;
1866                 }
1867
1868                 if (need_nl)
1869                         putchar('\n');
1870
1871                 if (strchr(replies, c)) {
1872                         *ret = c;
1873                         return 0;
1874                 }
1875
1876                 puts("Read unexpected character, please try again.");
1877         }
1878 }
1879
1880 int ask_string(char **ret, const char *text, ...) {
1881         assert(ret);
1882         assert(text);
1883
1884         for (;;) {
1885                 char line[LINE_MAX];
1886                 va_list ap;
1887
1888                 if (on_tty())
1889                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1890
1891                 va_start(ap, text);
1892                 vprintf(text, ap);
1893                 va_end(ap);
1894
1895                 if (on_tty())
1896                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1897
1898                 fflush(stdout);
1899
1900                 errno = 0;
1901                 if (!fgets(line, sizeof(line), stdin))
1902                         return errno ? -errno : -EIO;
1903
1904                 if (!endswith(line, "\n"))
1905                         putchar('\n');
1906                 else {
1907                         char *s;
1908
1909                         if (isempty(line))
1910                                 continue;
1911
1912                         truncate_nl(line);
1913                         s = strdup(line);
1914                         if (!s)
1915                                 return -ENOMEM;
1916
1917                         *ret = s;
1918                         return 0;
1919                 }
1920         }
1921 }
1922
1923 int reset_terminal_fd(int fd, bool switch_to_text) {
1924         struct termios termios;
1925         int r = 0;
1926
1927         /* Set terminal to some sane defaults */
1928
1929         assert(fd >= 0);
1930
1931         /* We leave locked terminal attributes untouched, so that
1932          * Plymouth may set whatever it wants to set, and we don't
1933          * interfere with that. */
1934
1935         /* Disable exclusive mode, just in case */
1936         ioctl(fd, TIOCNXCL);
1937
1938         /* Switch to text mode */
1939         if (switch_to_text)
1940                 ioctl(fd, KDSETMODE, KD_TEXT);
1941
1942         /* Enable console unicode mode */
1943         ioctl(fd, KDSKBMODE, K_UNICODE);
1944
1945         if (tcgetattr(fd, &termios) < 0) {
1946                 r = -errno;
1947                 goto finish;
1948         }
1949
1950         /* We only reset the stuff that matters to the software. How
1951          * hardware is set up we don't touch assuming that somebody
1952          * else will do that for us */
1953
1954         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1955         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1956         termios.c_oflag |= ONLCR;
1957         termios.c_cflag |= CREAD;
1958         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1959
1960         termios.c_cc[VINTR]    =   03;  /* ^C */
1961         termios.c_cc[VQUIT]    =  034;  /* ^\ */
1962         termios.c_cc[VERASE]   = 0177;
1963         termios.c_cc[VKILL]    =  025;  /* ^X */
1964         termios.c_cc[VEOF]     =   04;  /* ^D */
1965         termios.c_cc[VSTART]   =  021;  /* ^Q */
1966         termios.c_cc[VSTOP]    =  023;  /* ^S */
1967         termios.c_cc[VSUSP]    =  032;  /* ^Z */
1968         termios.c_cc[VLNEXT]   =  026;  /* ^V */
1969         termios.c_cc[VWERASE]  =  027;  /* ^W */
1970         termios.c_cc[VREPRINT] =  022;  /* ^R */
1971         termios.c_cc[VEOL]     =    0;
1972         termios.c_cc[VEOL2]    =    0;
1973
1974         termios.c_cc[VTIME]  = 0;
1975         termios.c_cc[VMIN]   = 1;
1976
1977         if (tcsetattr(fd, TCSANOW, &termios) < 0)
1978                 r = -errno;
1979
1980 finish:
1981         /* Just in case, flush all crap out */
1982         tcflush(fd, TCIOFLUSH);
1983
1984         return r;
1985 }
1986
1987 int reset_terminal(const char *name) {
1988         _cleanup_close_ int fd = -1;
1989
1990         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1991         if (fd < 0)
1992                 return fd;
1993
1994         return reset_terminal_fd(fd, true);
1995 }
1996
1997 int open_terminal(const char *name, int mode) {
1998         int fd, r;
1999         unsigned c = 0;
2000
2001         /*
2002          * If a TTY is in the process of being closed opening it might
2003          * cause EIO. This is horribly awful, but unlikely to be
2004          * changed in the kernel. Hence we work around this problem by
2005          * retrying a couple of times.
2006          *
2007          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
2008          */
2009
2010         assert(!(mode & O_CREAT));
2011
2012         for (;;) {
2013                 fd = open(name, mode, 0);
2014                 if (fd >= 0)
2015                         break;
2016
2017                 if (errno != EIO)
2018                         return -errno;
2019
2020                 /* Max 1s in total */
2021                 if (c >= 20)
2022                         return -errno;
2023
2024                 usleep(50 * USEC_PER_MSEC);
2025                 c++;
2026         }
2027
2028         r = isatty(fd);
2029         if (r < 0) {
2030                 safe_close(fd);
2031                 return -errno;
2032         }
2033
2034         if (!r) {
2035                 safe_close(fd);
2036                 return -ENOTTY;
2037         }
2038
2039         return fd;
2040 }
2041
2042 int flush_fd(int fd) {
2043         struct pollfd pollfd = {
2044                 .fd = fd,
2045                 .events = POLLIN,
2046         };
2047
2048         for (;;) {
2049                 char buf[LINE_MAX];
2050                 ssize_t l;
2051                 int r;
2052
2053                 r = poll(&pollfd, 1, 0);
2054                 if (r < 0) {
2055                         if (errno == EINTR)
2056                                 continue;
2057
2058                         return -errno;
2059
2060                 } else if (r == 0)
2061                         return 0;
2062
2063                 l = read(fd, buf, sizeof(buf));
2064                 if (l < 0) {
2065
2066                         if (errno == EINTR)
2067                                 continue;
2068
2069                         if (errno == EAGAIN)
2070                                 return 0;
2071
2072                         return -errno;
2073                 } else if (l == 0)
2074                         return 0;
2075         }
2076 }
2077
2078 int acquire_terminal(
2079                 const char *name,
2080                 bool fail,
2081                 bool force,
2082                 bool ignore_tiocstty_eperm,
2083                 usec_t timeout) {
2084
2085         int fd = -1, notify = -1, r = 0, wd = -1;
2086         usec_t ts = 0;
2087
2088         assert(name);
2089
2090         /* We use inotify to be notified when the tty is closed. We
2091          * create the watch before checking if we can actually acquire
2092          * it, so that we don't lose any event.
2093          *
2094          * Note: strictly speaking this actually watches for the
2095          * device being closed, it does *not* really watch whether a
2096          * tty loses its controlling process. However, unless some
2097          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2098          * its tty otherwise this will not become a problem. As long
2099          * as the administrator makes sure not configure any service
2100          * on the same tty as an untrusted user this should not be a
2101          * problem. (Which he probably should not do anyway.) */
2102
2103         if (timeout != USEC_INFINITY)
2104                 ts = now(CLOCK_MONOTONIC);
2105
2106         if (!fail && !force) {
2107                 notify = inotify_init1(IN_CLOEXEC | (timeout != USEC_INFINITY ? IN_NONBLOCK : 0));
2108                 if (notify < 0) {
2109                         r = -errno;
2110                         goto fail;
2111                 }
2112
2113                 wd = inotify_add_watch(notify, name, IN_CLOSE);
2114                 if (wd < 0) {
2115                         r = -errno;
2116                         goto fail;
2117                 }
2118         }
2119
2120         for (;;) {
2121                 struct sigaction sa_old, sa_new = {
2122                         .sa_handler = SIG_IGN,
2123                         .sa_flags = SA_RESTART,
2124                 };
2125
2126                 if (notify >= 0) {
2127                         r = flush_fd(notify);
2128                         if (r < 0)
2129                                 goto fail;
2130                 }
2131
2132                 /* We pass here O_NOCTTY only so that we can check the return
2133                  * value TIOCSCTTY and have a reliable way to figure out if we
2134                  * successfully became the controlling process of the tty */
2135                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2136                 if (fd < 0)
2137                         return fd;
2138
2139                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2140                  * if we already own the tty. */
2141                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2142
2143                 /* First, try to get the tty */
2144                 if (ioctl(fd, TIOCSCTTY, force) < 0)
2145                         r = -errno;
2146
2147                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2148
2149                 /* Sometimes it makes sense to ignore TIOCSCTTY
2150                  * returning EPERM, i.e. when very likely we already
2151                  * are have this controlling terminal. */
2152                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
2153                         r = 0;
2154
2155                 if (r < 0 && (force || fail || r != -EPERM)) {
2156                         goto fail;
2157                 }
2158
2159                 if (r >= 0)
2160                         break;
2161
2162                 assert(!fail);
2163                 assert(!force);
2164                 assert(notify >= 0);
2165
2166                 for (;;) {
2167                         union inotify_event_buffer buffer;
2168                         struct inotify_event *e;
2169                         ssize_t l;
2170
2171                         if (timeout != USEC_INFINITY) {
2172                                 usec_t n;
2173
2174                                 n = now(CLOCK_MONOTONIC);
2175                                 if (ts + timeout < n) {
2176                                         r = -ETIMEDOUT;
2177                                         goto fail;
2178                                 }
2179
2180                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2181                                 if (r < 0)
2182                                         goto fail;
2183
2184                                 if (r == 0) {
2185                                         r = -ETIMEDOUT;
2186                                         goto fail;
2187                                 }
2188                         }
2189
2190                         l = read(notify, &buffer, sizeof(buffer));
2191                         if (l < 0) {
2192                                 if (errno == EINTR || errno == EAGAIN)
2193                                         continue;
2194
2195                                 r = -errno;
2196                                 goto fail;
2197                         }
2198
2199                         FOREACH_INOTIFY_EVENT(e, buffer, l) {
2200                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2201                                         r = -EIO;
2202                                         goto fail;
2203                                 }
2204                         }
2205
2206                         break;
2207                 }
2208
2209                 /* We close the tty fd here since if the old session
2210                  * ended our handle will be dead. It's important that
2211                  * we do this after sleeping, so that we don't enter
2212                  * an endless loop. */
2213                 fd = safe_close(fd);
2214         }
2215
2216         safe_close(notify);
2217
2218         r = reset_terminal_fd(fd, true);
2219         if (r < 0)
2220                 log_warning_errno(r, "Failed to reset terminal: %m");
2221
2222         return fd;
2223
2224 fail:
2225         safe_close(fd);
2226         safe_close(notify);
2227
2228         return r;
2229 }
2230
2231 int release_terminal(void) {
2232         static const struct sigaction sa_new = {
2233                 .sa_handler = SIG_IGN,
2234                 .sa_flags = SA_RESTART,
2235         };
2236
2237         _cleanup_close_ int fd = -1;
2238         struct sigaction sa_old;
2239         int r = 0;
2240
2241         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2242         if (fd < 0)
2243                 return -errno;
2244
2245         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2246          * by our own TIOCNOTTY */
2247         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2248
2249         if (ioctl(fd, TIOCNOTTY) < 0)
2250                 r = -errno;
2251
2252         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2253
2254         return r;
2255 }
2256
2257 int sigaction_many(const struct sigaction *sa, ...) {
2258         va_list ap;
2259         int r = 0, sig;
2260
2261         va_start(ap, sa);
2262         while ((sig = va_arg(ap, int)) > 0)
2263                 if (sigaction(sig, sa, NULL) < 0)
2264                         r = -errno;
2265         va_end(ap);
2266
2267         return r;
2268 }
2269
2270 int ignore_signals(int sig, ...) {
2271         struct sigaction sa = {
2272                 .sa_handler = SIG_IGN,
2273                 .sa_flags = SA_RESTART,
2274         };
2275         va_list ap;
2276         int r = 0;
2277
2278         if (sigaction(sig, &sa, NULL) < 0)
2279                 r = -errno;
2280
2281         va_start(ap, sig);
2282         while ((sig = va_arg(ap, int)) > 0)
2283                 if (sigaction(sig, &sa, NULL) < 0)
2284                         r = -errno;
2285         va_end(ap);
2286
2287         return r;
2288 }
2289
2290 int default_signals(int sig, ...) {
2291         struct sigaction sa = {
2292                 .sa_handler = SIG_DFL,
2293                 .sa_flags = SA_RESTART,
2294         };
2295         va_list ap;
2296         int r = 0;
2297
2298         if (sigaction(sig, &sa, NULL) < 0)
2299                 r = -errno;
2300
2301         va_start(ap, sig);
2302         while ((sig = va_arg(ap, int)) > 0)
2303                 if (sigaction(sig, &sa, NULL) < 0)
2304                         r = -errno;
2305         va_end(ap);
2306
2307         return r;
2308 }
2309
2310 void safe_close_pair(int p[]) {
2311         assert(p);
2312
2313         if (p[0] == p[1]) {
2314                 /* Special case pairs which use the same fd in both
2315                  * directions... */
2316                 p[0] = p[1] = safe_close(p[0]);
2317                 return;
2318         }
2319
2320         p[0] = safe_close(p[0]);
2321         p[1] = safe_close(p[1]);
2322 }
2323
2324 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2325         uint8_t *p = buf;
2326         ssize_t n = 0;
2327
2328         assert(fd >= 0);
2329         assert(buf);
2330
2331         while (nbytes > 0) {
2332                 ssize_t k;
2333
2334                 k = read(fd, p, nbytes);
2335                 if (k < 0) {
2336                         if (errno == EINTR)
2337                                 continue;
2338
2339                         if (errno == EAGAIN && do_poll) {
2340
2341                                 /* We knowingly ignore any return value here,
2342                                  * and expect that any error/EOF is reported
2343                                  * via read() */
2344
2345                                 fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
2346                                 continue;
2347                         }
2348
2349                         return n > 0 ? n : -errno;
2350                 }
2351
2352                 if (k == 0)
2353                         return n;
2354
2355                 p += k;
2356                 nbytes -= k;
2357                 n += k;
2358         }
2359
2360         return n;
2361 }
2362
2363 int loop_read_exact(int fd, void *buf, size_t nbytes, bool do_poll) {
2364         ssize_t n;
2365
2366         n = loop_read(fd, buf, nbytes, do_poll);
2367         if (n < 0)
2368                 return n;
2369         if ((size_t) n != nbytes)
2370                 return -EIO;
2371         return 0;
2372 }
2373
2374 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2375         const uint8_t *p = buf;
2376
2377         assert(fd >= 0);
2378         assert(buf);
2379
2380         errno = 0;
2381
2382         while (nbytes > 0) {
2383                 ssize_t k;
2384
2385                 k = write(fd, p, nbytes);
2386                 if (k < 0) {
2387                         if (errno == EINTR)
2388                                 continue;
2389
2390                         if (errno == EAGAIN && do_poll) {
2391                                 /* We knowingly ignore any return value here,
2392                                  * and expect that any error/EOF is reported
2393                                  * via write() */
2394
2395                                 fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
2396                                 continue;
2397                         }
2398
2399                         return -errno;
2400                 }
2401
2402                 if (k == 0) /* Can't really happen */
2403                         return -EIO;
2404
2405                 p += k;
2406                 nbytes -= k;
2407         }
2408
2409         return 0;
2410 }
2411
2412 int parse_size(const char *t, off_t base, off_t *size) {
2413
2414         /* Soo, sometimes we want to parse IEC binary suffxies, and
2415          * sometimes SI decimal suffixes. This function can parse
2416          * both. Which one is the right way depends on the
2417          * context. Wikipedia suggests that SI is customary for
2418          * hardrware metrics and network speeds, while IEC is
2419          * customary for most data sizes used by software and volatile
2420          * (RAM) memory. Hence be careful which one you pick!
2421          *
2422          * In either case we use just K, M, G as suffix, and not Ki,
2423          * Mi, Gi or so (as IEC would suggest). That's because that's
2424          * frickin' ugly. But this means you really need to make sure
2425          * to document which base you are parsing when you use this
2426          * call. */
2427
2428         struct table {
2429                 const char *suffix;
2430                 unsigned long long factor;
2431         };
2432
2433         static const struct table iec[] = {
2434                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2435                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2436                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2437                 { "G", 1024ULL*1024ULL*1024ULL },
2438                 { "M", 1024ULL*1024ULL },
2439                 { "K", 1024ULL },
2440                 { "B", 1 },
2441                 { "", 1 },
2442         };
2443
2444         static const struct table si[] = {
2445                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2446                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2447                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2448                 { "G", 1000ULL*1000ULL*1000ULL },
2449                 { "M", 1000ULL*1000ULL },
2450                 { "K", 1000ULL },
2451                 { "B", 1 },
2452                 { "", 1 },
2453         };
2454
2455         const struct table *table;
2456         const char *p;
2457         unsigned long long r = 0;
2458         unsigned n_entries, start_pos = 0;
2459
2460         assert(t);
2461         assert(base == 1000 || base == 1024);
2462         assert(size);
2463
2464         if (base == 1000) {
2465                 table = si;
2466                 n_entries = ELEMENTSOF(si);
2467         } else {
2468                 table = iec;
2469                 n_entries = ELEMENTSOF(iec);
2470         }
2471
2472         p = t;
2473         do {
2474                 long long l;
2475                 unsigned long long l2;
2476                 double frac = 0;
2477                 char *e;
2478                 unsigned i;
2479
2480                 errno = 0;
2481                 l = strtoll(p, &e, 10);
2482
2483                 if (errno > 0)
2484                         return -errno;
2485
2486                 if (l < 0)
2487                         return -ERANGE;
2488
2489                 if (e == p)
2490                         return -EINVAL;
2491
2492                 if (*e == '.') {
2493                         e++;
2494                         if (*e >= '0' && *e <= '9') {
2495                                 char *e2;
2496
2497                                 /* strotoull itself would accept space/+/- */
2498                                 l2 = strtoull(e, &e2, 10);
2499
2500                                 if (errno == ERANGE)
2501                                         return -errno;
2502
2503                                 /* Ignore failure. E.g. 10.M is valid */
2504                                 frac = l2;
2505                                 for (; e < e2; e++)
2506                                         frac /= 10;
2507                         }
2508                 }
2509
2510                 e += strspn(e, WHITESPACE);
2511
2512                 for (i = start_pos; i < n_entries; i++)
2513                         if (startswith(e, table[i].suffix)) {
2514                                 unsigned long long tmp;
2515                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2516                                         return -ERANGE;
2517                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2518                                 if (tmp > ULLONG_MAX - r)
2519                                         return -ERANGE;
2520
2521                                 r += tmp;
2522                                 if ((unsigned long long) (off_t) r != r)
2523                                         return -ERANGE;
2524
2525                                 p = e + strlen(table[i].suffix);
2526
2527                                 start_pos = i + 1;
2528                                 break;
2529                         }
2530
2531                 if (i >= n_entries)
2532                         return -EINVAL;
2533
2534         } while (*p);
2535
2536         *size = r;
2537
2538         return 0;
2539 }
2540
2541 int make_stdio(int fd) {
2542         int r, s, t;
2543
2544         assert(fd >= 0);
2545
2546         r = dup2(fd, STDIN_FILENO);
2547         s = dup2(fd, STDOUT_FILENO);
2548         t = dup2(fd, STDERR_FILENO);
2549
2550         if (fd >= 3)
2551                 safe_close(fd);
2552
2553         if (r < 0 || s < 0 || t < 0)
2554                 return -errno;
2555
2556         /* Explicitly unset O_CLOEXEC, since if fd was < 3, then
2557          * dup2() was a NOP and the bit hence possibly set. */
2558         fd_cloexec(STDIN_FILENO, false);
2559         fd_cloexec(STDOUT_FILENO, false);
2560         fd_cloexec(STDERR_FILENO, false);
2561
2562         return 0;
2563 }
2564
2565 int make_null_stdio(void) {
2566         int null_fd;
2567
2568         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2569         if (null_fd < 0)
2570                 return -errno;
2571
2572         return make_stdio(null_fd);
2573 }
2574
2575 bool is_device_path(const char *path) {
2576
2577         /* Returns true on paths that refer to a device, either in
2578          * sysfs or in /dev */
2579
2580         return
2581                 path_startswith(path, "/dev/") ||
2582                 path_startswith(path, "/sys/");
2583 }
2584
2585 int dir_is_empty(const char *path) {
2586         _cleanup_closedir_ DIR *d;
2587
2588         d = opendir(path);
2589         if (!d)
2590                 return -errno;
2591
2592         for (;;) {
2593                 struct dirent *de;
2594
2595                 errno = 0;
2596                 de = readdir(d);
2597                 if (!de && errno != 0)
2598                         return -errno;
2599
2600                 if (!de)
2601                         return 1;
2602
2603                 if (!hidden_file(de->d_name))
2604                         return 0;
2605         }
2606 }
2607
2608 char* dirname_malloc(const char *path) {
2609         char *d, *dir, *dir2;
2610
2611         d = strdup(path);
2612         if (!d)
2613                 return NULL;
2614         dir = dirname(d);
2615         assert(dir);
2616
2617         if (dir != d) {
2618                 dir2 = strdup(dir);
2619                 free(d);
2620                 return dir2;
2621         }
2622
2623         return dir;
2624 }
2625
2626 int dev_urandom(void *p, size_t n) {
2627         static int have_syscall = -1;
2628
2629         _cleanup_close_ int fd = -1;
2630         int r;
2631
2632         /* Gathers some randomness from the kernel. This call will
2633          * never block, and will always return some data from the
2634          * kernel, regardless if the random pool is fully initialized
2635          * or not. It thus makes no guarantee for the quality of the
2636          * returned entropy, but is good enough for or usual usecases
2637          * of seeding the hash functions for hashtable */
2638
2639         /* Use the getrandom() syscall unless we know we don't have
2640          * it, or when the requested size is too large for it. */
2641         if (have_syscall != 0 || (size_t) (int) n != n) {
2642                 r = getrandom(p, n, GRND_NONBLOCK);
2643                 if (r == (int) n) {
2644                         have_syscall = true;
2645                         return 0;
2646                 }
2647
2648                 if (r < 0) {
2649                         if (errno == ENOSYS)
2650                                 /* we lack the syscall, continue with
2651                                  * reading from /dev/urandom */
2652                                 have_syscall = false;
2653                         else if (errno == EAGAIN)
2654                                 /* not enough entropy for now. Let's
2655                                  * remember to use the syscall the
2656                                  * next time, again, but also read
2657                                  * from /dev/urandom for now, which
2658                                  * doesn't care about the current
2659                                  * amount of entropy.  */
2660                                 have_syscall = true;
2661                         else
2662                                 return -errno;
2663                 } else
2664                         /* too short read? */
2665                         return -ENODATA;
2666         }
2667
2668         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2669         if (fd < 0)
2670                 return errno == ENOENT ? -ENOSYS : -errno;
2671
2672         return loop_read_exact(fd, p, n, true);
2673 }
2674
2675 void initialize_srand(void) {
2676         static bool srand_called = false;
2677         unsigned x;
2678 #ifdef HAVE_SYS_AUXV_H
2679         void *auxv;
2680 #endif
2681
2682         if (srand_called)
2683                 return;
2684
2685         x = 0;
2686
2687 #ifdef HAVE_SYS_AUXV_H
2688         /* The kernel provides us with a bit of entropy in auxv, so
2689          * let's try to make use of that to seed the pseudo-random
2690          * generator. It's better than nothing... */
2691
2692         auxv = (void*) getauxval(AT_RANDOM);
2693         if (auxv)
2694                 x ^= *(unsigned*) auxv;
2695 #endif
2696
2697         x ^= (unsigned) now(CLOCK_REALTIME);
2698         x ^= (unsigned) gettid();
2699
2700         srand(x);
2701         srand_called = true;
2702 }
2703
2704 void random_bytes(void *p, size_t n) {
2705         uint8_t *q;
2706         int r;
2707
2708         r = dev_urandom(p, n);
2709         if (r >= 0)
2710                 return;
2711
2712         /* If some idiot made /dev/urandom unavailable to us, he'll
2713          * get a PRNG instead. */
2714
2715         initialize_srand();
2716
2717         for (q = p; q < (uint8_t*) p + n; q ++)
2718                 *q = rand();
2719 }
2720
2721 void rename_process(const char name[8]) {
2722         assert(name);
2723
2724         /* This is a like a poor man's setproctitle(). It changes the
2725          * comm field, argv[0], and also the glibc's internally used
2726          * name of the process. For the first one a limit of 16 chars
2727          * applies, to the second one usually one of 10 (i.e. length
2728          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2729          * "systemd"). If you pass a longer string it will be
2730          * truncated */
2731
2732         prctl(PR_SET_NAME, name);
2733
2734         if (program_invocation_name)
2735                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2736
2737         if (saved_argc > 0) {
2738                 int i;
2739
2740                 if (saved_argv[0])
2741                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2742
2743                 for (i = 1; i < saved_argc; i++) {
2744                         if (!saved_argv[i])
2745                                 break;
2746
2747                         memzero(saved_argv[i], strlen(saved_argv[i]));
2748                 }
2749         }
2750 }
2751
2752 void sigset_add_many(sigset_t *ss, ...) {
2753         va_list ap;
2754         int sig;
2755
2756         assert(ss);
2757
2758         va_start(ap, ss);
2759         while ((sig = va_arg(ap, int)) > 0)
2760                 assert_se(sigaddset(ss, sig) == 0);
2761         va_end(ap);
2762 }
2763
2764 int sigprocmask_many(int how, ...) {
2765         va_list ap;
2766         sigset_t ss;
2767         int sig;
2768
2769         assert_se(sigemptyset(&ss) == 0);
2770
2771         va_start(ap, how);
2772         while ((sig = va_arg(ap, int)) > 0)
2773                 assert_se(sigaddset(&ss, sig) == 0);
2774         va_end(ap);
2775
2776         if (sigprocmask(how, &ss, NULL) < 0)
2777                 return -errno;
2778
2779         return 0;
2780 }
2781
2782 char* gethostname_malloc(void) {
2783         struct utsname u;
2784
2785         assert_se(uname(&u) >= 0);
2786
2787         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2788                 return strdup(u.nodename);
2789
2790         return strdup(u.sysname);
2791 }
2792
2793 bool hostname_is_set(void) {
2794         struct utsname u;
2795
2796         assert_se(uname(&u) >= 0);
2797
2798         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2799 }
2800
2801 char *lookup_uid(uid_t uid) {
2802         long bufsize;
2803         char *name;
2804         _cleanup_free_ char *buf = NULL;
2805         struct passwd pwbuf, *pw = NULL;
2806
2807         /* Shortcut things to avoid NSS lookups */
2808         if (uid == 0)
2809                 return strdup("root");
2810
2811         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2812         if (bufsize <= 0)
2813                 bufsize = 4096;
2814
2815         buf = malloc(bufsize);
2816         if (!buf)
2817                 return NULL;
2818
2819         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2820                 return strdup(pw->pw_name);
2821
2822         if (asprintf(&name, UID_FMT, uid) < 0)
2823                 return NULL;
2824
2825         return name;
2826 }
2827
2828 char* getlogname_malloc(void) {
2829         uid_t uid;
2830         struct stat st;
2831
2832         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2833                 uid = st.st_uid;
2834         else
2835                 uid = getuid();
2836
2837         return lookup_uid(uid);
2838 }
2839
2840 char *getusername_malloc(void) {
2841         const char *e;
2842
2843         e = getenv("USER");
2844         if (e)
2845                 return strdup(e);
2846
2847         return lookup_uid(getuid());
2848 }
2849
2850 int getttyname_malloc(int fd, char **ret) {
2851         size_t l = 100;
2852         int r;
2853
2854         assert(fd >= 0);
2855         assert(ret);
2856
2857         for (;;) {
2858                 char path[l];
2859
2860                 r = ttyname_r(fd, path, sizeof(path));
2861                 if (r == 0) {
2862                         const char *p;
2863                         char *c;
2864
2865                         p = startswith(path, "/dev/");
2866                         c = strdup(p ?: path);
2867                         if (!c)
2868                                 return -ENOMEM;
2869
2870                         *ret = c;
2871                         return 0;
2872                 }
2873
2874                 if (r != ERANGE)
2875                         return -r;
2876
2877                 l *= 2;
2878         }
2879
2880         return 0;
2881 }
2882
2883 int getttyname_harder(int fd, char **r) {
2884         int k;
2885         char *s = NULL;
2886
2887         k = getttyname_malloc(fd, &s);
2888         if (k < 0)
2889                 return k;
2890
2891         if (streq(s, "tty")) {
2892                 free(s);
2893                 return get_ctty(0, NULL, r);
2894         }
2895
2896         *r = s;
2897         return 0;
2898 }
2899
2900 int get_ctty_devnr(pid_t pid, dev_t *d) {
2901         int r;
2902         _cleanup_free_ char *line = NULL;
2903         const char *p;
2904         unsigned long ttynr;
2905
2906         assert(pid >= 0);
2907
2908         p = procfs_file_alloca(pid, "stat");
2909         r = read_one_line_file(p, &line);
2910         if (r < 0)
2911                 return r;
2912
2913         p = strrchr(line, ')');
2914         if (!p)
2915                 return -EIO;
2916
2917         p++;
2918
2919         if (sscanf(p, " "
2920                    "%*c "  /* state */
2921                    "%*d "  /* ppid */
2922                    "%*d "  /* pgrp */
2923                    "%*d "  /* session */
2924                    "%lu ", /* ttynr */
2925                    &ttynr) != 1)
2926                 return -EIO;
2927
2928         if (major(ttynr) == 0 && minor(ttynr) == 0)
2929                 return -ENOENT;
2930
2931         if (d)
2932                 *d = (dev_t) ttynr;
2933
2934         return 0;
2935 }
2936
2937 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2938         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2939         _cleanup_free_ char *s = NULL;
2940         const char *p;
2941         dev_t devnr;
2942         int k;
2943
2944         assert(r);
2945
2946         k = get_ctty_devnr(pid, &devnr);
2947         if (k < 0)
2948                 return k;
2949
2950         sprintf(fn, "/dev/char/%u:%u", major(devnr), minor(devnr));
2951
2952         k = readlink_malloc(fn, &s);
2953         if (k < 0) {
2954
2955                 if (k != -ENOENT)
2956                         return k;
2957
2958                 /* This is an ugly hack */
2959                 if (major(devnr) == 136) {
2960                         if (asprintf(&b, "pts/%u", minor(devnr)) < 0)
2961                                 return -ENOMEM;
2962                 } else {
2963                         /* Probably something like the ptys which have no
2964                          * symlink in /dev/char. Let's return something
2965                          * vaguely useful. */
2966
2967                         b = strdup(fn + 5);
2968                         if (!b)
2969                                 return -ENOMEM;
2970                 }
2971         } else {
2972                 if (startswith(s, "/dev/"))
2973                         p = s + 5;
2974                 else if (startswith(s, "../"))
2975                         p = s + 3;
2976                 else
2977                         p = s;
2978
2979                 b = strdup(p);
2980                 if (!b)
2981                         return -ENOMEM;
2982         }
2983
2984         *r = b;
2985         if (_devnr)
2986                 *_devnr = devnr;
2987
2988         return 0;
2989 }
2990
2991 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2992         _cleanup_closedir_ DIR *d = NULL;
2993         int ret = 0;
2994
2995         assert(fd >= 0);
2996
2997         /* This returns the first error we run into, but nevertheless
2998          * tries to go on. This closes the passed fd. */
2999
3000         d = fdopendir(fd);
3001         if (!d) {
3002                 safe_close(fd);
3003
3004                 return errno == ENOENT ? 0 : -errno;
3005         }
3006
3007         for (;;) {
3008                 struct dirent *de;
3009                 bool is_dir, keep_around;
3010                 struct stat st;
3011                 int r;
3012
3013                 errno = 0;
3014                 de = readdir(d);
3015                 if (!de) {
3016                         if (errno != 0 && ret == 0)
3017                                 ret = -errno;
3018                         return ret;
3019                 }
3020
3021                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
3022                         continue;
3023
3024                 if (de->d_type == DT_UNKNOWN ||
3025                     honour_sticky ||
3026                     (de->d_type == DT_DIR && root_dev)) {
3027                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
3028                                 if (ret == 0 && errno != ENOENT)
3029                                         ret = -errno;
3030                                 continue;
3031                         }
3032
3033                         is_dir = S_ISDIR(st.st_mode);
3034                         keep_around =
3035                                 honour_sticky &&
3036                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
3037                                 (st.st_mode & S_ISVTX);
3038                 } else {
3039                         is_dir = de->d_type == DT_DIR;
3040                         keep_around = false;
3041                 }
3042
3043                 if (is_dir) {
3044                         int subdir_fd;
3045
3046                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
3047                         if (root_dev && st.st_dev != root_dev->st_dev)
3048                                 continue;
3049
3050                         subdir_fd = openat(fd, de->d_name,
3051                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3052                         if (subdir_fd < 0) {
3053                                 if (ret == 0 && errno != ENOENT)
3054                                         ret = -errno;
3055                                 continue;
3056                         }
3057
3058                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
3059                         if (r < 0 && ret == 0)
3060                                 ret = r;
3061
3062                         if (!keep_around)
3063                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
3064                                         if (ret == 0 && errno != ENOENT)
3065                                                 ret = -errno;
3066                                 }
3067
3068                 } else if (!only_dirs && !keep_around) {
3069
3070                         if (unlinkat(fd, de->d_name, 0) < 0) {
3071                                 if (ret == 0 && errno != ENOENT)
3072                                         ret = -errno;
3073                         }
3074                 }
3075         }
3076 }
3077
3078 _pure_ static int is_temporary_fs(struct statfs *s) {
3079         assert(s);
3080
3081         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
3082                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
3083 }
3084
3085 int is_fd_on_temporary_fs(int fd) {
3086         struct statfs s;
3087
3088         if (fstatfs(fd, &s) < 0)
3089                 return -errno;
3090
3091         return is_temporary_fs(&s);
3092 }
3093
3094 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3095         struct statfs s;
3096
3097         assert(fd >= 0);
3098
3099         if (fstatfs(fd, &s) < 0) {
3100                 safe_close(fd);
3101                 return -errno;
3102         }
3103
3104         /* We refuse to clean disk file systems with this call. This
3105          * is extra paranoia just to be sure we never ever remove
3106          * non-state data */
3107         if (!is_temporary_fs(&s)) {
3108                 log_error("Attempted to remove disk file system, and we can't allow that.");
3109                 safe_close(fd);
3110                 return -EPERM;
3111         }
3112
3113         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
3114 }
3115
3116 static int file_is_priv_sticky(const char *p) {
3117         struct stat st;
3118
3119         assert(p);
3120
3121         if (lstat(p, &st) < 0)
3122                 return -errno;
3123
3124         return
3125                 (st.st_uid == 0 || st.st_uid == getuid()) &&
3126                 (st.st_mode & S_ISVTX);
3127 }
3128
3129 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
3130         int fd, r;
3131         struct statfs s;
3132
3133         assert(path);
3134
3135         /* We refuse to clean the root file system with this
3136          * call. This is extra paranoia to never cause a really
3137          * seriously broken system. */
3138         if (path_equal(path, "/")) {
3139                 log_error("Attempted to remove entire root file system, and we can't allow that.");
3140                 return -EPERM;
3141         }
3142
3143         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3144         if (fd < 0) {
3145
3146                 if (errno != ENOTDIR && errno != ELOOP)
3147                         return -errno;
3148
3149                 if (!dangerous) {
3150                         if (statfs(path, &s) < 0)
3151                                 return -errno;
3152
3153                         if (!is_temporary_fs(&s)) {
3154                                 log_error("Attempted to remove disk file system, and we can't allow that.");
3155                                 return -EPERM;
3156                         }
3157                 }
3158
3159                 if (delete_root && !only_dirs)
3160                         if (unlink(path) < 0 && errno != ENOENT)
3161                                 return -errno;
3162
3163                 return 0;
3164         }
3165
3166         if (!dangerous) {
3167                 if (fstatfs(fd, &s) < 0) {
3168                         safe_close(fd);
3169                         return -errno;
3170                 }
3171
3172                 if (!is_temporary_fs(&s)) {
3173                         log_error("Attempted to remove disk file system, and we can't allow that.");
3174                         safe_close(fd);
3175                         return -EPERM;
3176                 }
3177         }
3178
3179         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
3180         if (delete_root) {
3181
3182                 if (honour_sticky && file_is_priv_sticky(path) > 0)
3183                         return r;
3184
3185                 if (rmdir(path) < 0 && errno != ENOENT) {
3186                         if (r == 0)
3187                                 r = -errno;
3188                 }
3189         }
3190
3191         return r;
3192 }
3193
3194 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3195         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
3196 }
3197
3198 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3199         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
3200 }
3201
3202 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3203         assert(path);
3204
3205         /* Under the assumption that we are running privileged we
3206          * first change the access mode and only then hand out
3207          * ownership to avoid a window where access is too open. */
3208
3209         if (mode != MODE_INVALID)
3210                 if (chmod(path, mode) < 0)
3211                         return -errno;
3212
3213         if (uid != UID_INVALID || gid != GID_INVALID)
3214                 if (chown(path, uid, gid) < 0)
3215                         return -errno;
3216
3217         return 0;
3218 }
3219
3220 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3221         assert(fd >= 0);
3222
3223         /* Under the assumption that we are running privileged we
3224          * first change the access mode and only then hand out
3225          * ownership to avoid a window where access is too open. */
3226
3227         if (mode != MODE_INVALID)
3228                 if (fchmod(fd, mode) < 0)
3229                         return -errno;
3230
3231         if (uid != UID_INVALID || gid != GID_INVALID)
3232                 if (fchown(fd, uid, gid) < 0)
3233                         return -errno;
3234
3235         return 0;
3236 }
3237
3238 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3239         cpu_set_t *r;
3240         unsigned n = 1024;
3241
3242         /* Allocates the cpuset in the right size */
3243
3244         for (;;) {
3245                 if (!(r = CPU_ALLOC(n)))
3246                         return NULL;
3247
3248                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3249                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3250
3251                         if (ncpus)
3252                                 *ncpus = n;
3253
3254                         return r;
3255                 }
3256
3257                 CPU_FREE(r);
3258
3259                 if (errno != EINVAL)
3260                         return NULL;
3261
3262                 n *= 2;
3263         }
3264 }
3265
3266 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
3267         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3268         _cleanup_free_ char *s = NULL;
3269         _cleanup_close_ int fd = -1;
3270         struct iovec iovec[6] = {};
3271         int n = 0;
3272         static bool prev_ephemeral;
3273
3274         assert(format);
3275
3276         /* This is independent of logging, as status messages are
3277          * optional and go exclusively to the console. */
3278
3279         if (vasprintf(&s, format, ap) < 0)
3280                 return log_oom();
3281
3282         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3283         if (fd < 0)
3284                 return fd;
3285
3286         if (ellipse) {
3287                 char *e;
3288                 size_t emax, sl;
3289                 int c;
3290
3291                 c = fd_columns(fd);
3292                 if (c <= 0)
3293                         c = 80;
3294
3295                 sl = status ? sizeof(status_indent)-1 : 0;
3296
3297                 emax = c - sl - 1;
3298                 if (emax < 3)
3299                         emax = 3;
3300
3301                 e = ellipsize(s, emax, 50);
3302                 if (e) {
3303                         free(s);
3304                         s = e;
3305                 }
3306         }
3307
3308         if (prev_ephemeral)
3309                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3310         prev_ephemeral = ephemeral;
3311
3312         if (status) {
3313                 if (!isempty(status)) {
3314                         IOVEC_SET_STRING(iovec[n++], "[");
3315                         IOVEC_SET_STRING(iovec[n++], status);
3316                         IOVEC_SET_STRING(iovec[n++], "] ");
3317                 } else
3318                         IOVEC_SET_STRING(iovec[n++], status_indent);
3319         }
3320
3321         IOVEC_SET_STRING(iovec[n++], s);
3322         if (!ephemeral)
3323                 IOVEC_SET_STRING(iovec[n++], "\n");
3324
3325         if (writev(fd, iovec, n) < 0)
3326                 return -errno;
3327
3328         return 0;
3329 }
3330
3331 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3332         va_list ap;
3333         int r;
3334
3335         assert(format);
3336
3337         va_start(ap, format);
3338         r = status_vprintf(status, ellipse, ephemeral, format, ap);
3339         va_end(ap);
3340
3341         return r;
3342 }
3343
3344 char *replace_env(const char *format, char **env) {
3345         enum {
3346                 WORD,
3347                 CURLY,
3348                 VARIABLE
3349         } state = WORD;
3350
3351         const char *e, *word = format;
3352         char *r = NULL, *k;
3353
3354         assert(format);
3355
3356         for (e = format; *e; e ++) {
3357
3358                 switch (state) {
3359
3360                 case WORD:
3361                         if (*e == '$')
3362                                 state = CURLY;
3363                         break;
3364
3365                 case CURLY:
3366                         if (*e == '{') {
3367                                 k = strnappend(r, word, e-word-1);
3368                                 if (!k)
3369                                         goto fail;
3370
3371                                 free(r);
3372                                 r = k;
3373
3374                                 word = e-1;
3375                                 state = VARIABLE;
3376
3377                         } else if (*e == '$') {
3378                                 k = strnappend(r, word, e-word);
3379                                 if (!k)
3380                                         goto fail;
3381
3382                                 free(r);
3383                                 r = k;
3384
3385                                 word = e+1;
3386                                 state = WORD;
3387                         } else
3388                                 state = WORD;
3389                         break;
3390
3391                 case VARIABLE:
3392                         if (*e == '}') {
3393                                 const char *t;
3394
3395                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3396
3397                                 k = strappend(r, t);
3398                                 if (!k)
3399                                         goto fail;
3400
3401                                 free(r);
3402                                 r = k;
3403
3404                                 word = e+1;
3405                                 state = WORD;
3406                         }
3407                         break;
3408                 }
3409         }
3410
3411         k = strnappend(r, word, e-word);