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