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