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