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