chiark / gitweb /
util: avoid considering dpkg temporary files relevant for anything
[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, ".dpkg-tmp") ||
1426                 endswith(filename, ".swp");
1427 }
1428
1429 bool ignore_file(const char *filename) {
1430         assert(filename);
1431
1432         if (endswith(filename, "~"))
1433                 return true;
1434
1435         return ignore_file_allow_backup(filename);
1436 }
1437
1438 int fd_nonblock(int fd, bool nonblock) {
1439         int flags, nflags;
1440
1441         assert(fd >= 0);
1442
1443         flags = fcntl(fd, F_GETFL, 0);
1444         if (flags < 0)
1445                 return -errno;
1446
1447         if (nonblock)
1448                 nflags = flags | O_NONBLOCK;
1449         else
1450                 nflags = flags & ~O_NONBLOCK;
1451
1452         if (nflags == flags)
1453                 return 0;
1454
1455         if (fcntl(fd, F_SETFL, nflags) < 0)
1456                 return -errno;
1457
1458         return 0;
1459 }
1460
1461 int fd_cloexec(int fd, bool cloexec) {
1462         int flags, nflags;
1463
1464         assert(fd >= 0);
1465
1466         flags = fcntl(fd, F_GETFD, 0);
1467         if (flags < 0)
1468                 return -errno;
1469
1470         if (cloexec)
1471                 nflags = flags | FD_CLOEXEC;
1472         else
1473                 nflags = flags & ~FD_CLOEXEC;
1474
1475         if (nflags == flags)
1476                 return 0;
1477
1478         if (fcntl(fd, F_SETFD, nflags) < 0)
1479                 return -errno;
1480
1481         return 0;
1482 }
1483
1484 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1485         unsigned i;
1486
1487         assert(n_fdset == 0 || fdset);
1488
1489         for (i = 0; i < n_fdset; i++)
1490                 if (fdset[i] == fd)
1491                         return true;
1492
1493         return false;
1494 }
1495
1496 int close_all_fds(const int except[], unsigned n_except) {
1497         _cleanup_closedir_ DIR *d = NULL;
1498         struct dirent *de;
1499         int r = 0;
1500
1501         assert(n_except == 0 || except);
1502
1503         d = opendir("/proc/self/fd");
1504         if (!d) {
1505                 int fd;
1506                 struct rlimit rl;
1507
1508                 /* When /proc isn't available (for example in chroots)
1509                  * the fallback is brute forcing through the fd
1510                  * table */
1511
1512                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1513                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1514
1515                         if (fd_in_set(fd, except, n_except))
1516                                 continue;
1517
1518                         if (close_nointr(fd) < 0)
1519                                 if (errno != EBADF && r == 0)
1520                                         r = -errno;
1521                 }
1522
1523                 return r;
1524         }
1525
1526         while ((de = readdir(d))) {
1527                 int fd = -1;
1528
1529                 if (ignore_file(de->d_name))
1530                         continue;
1531
1532                 if (safe_atoi(de->d_name, &fd) < 0)
1533                         /* Let's better ignore this, just in case */
1534                         continue;
1535
1536                 if (fd < 3)
1537                         continue;
1538
1539                 if (fd == dirfd(d))
1540                         continue;
1541
1542                 if (fd_in_set(fd, except, n_except))
1543                         continue;
1544
1545                 if (close_nointr(fd) < 0) {
1546                         /* Valgrind has its own FD and doesn't want to have it closed */
1547                         if (errno != EBADF && r == 0)
1548                                 r = -errno;
1549                 }
1550         }
1551
1552         return r;
1553 }
1554
1555 bool chars_intersect(const char *a, const char *b) {
1556         const char *p;
1557
1558         /* Returns true if any of the chars in a are in b. */
1559         for (p = a; *p; p++)
1560                 if (strchr(b, *p))
1561                         return true;
1562
1563         return false;
1564 }
1565
1566 bool fstype_is_network(const char *fstype) {
1567         static const char table[] =
1568                 "cifs\0"
1569                 "smbfs\0"
1570                 "sshfs\0"
1571                 "ncpfs\0"
1572                 "ncp\0"
1573                 "nfs\0"
1574                 "nfs4\0"
1575                 "gfs\0"
1576                 "gfs2\0"
1577                 "glusterfs\0";
1578
1579         const char *x;
1580
1581         x = startswith(fstype, "fuse.");
1582         if (x)
1583                 fstype = x;
1584
1585         return nulstr_contains(table, fstype);
1586 }
1587
1588 int chvt(int vt) {
1589         _cleanup_close_ int fd;
1590
1591         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1592         if (fd < 0)
1593                 return -errno;
1594
1595         if (vt < 0) {
1596                 int tiocl[2] = {
1597                         TIOCL_GETKMSGREDIRECT,
1598                         0
1599                 };
1600
1601                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1602                         return -errno;
1603
1604                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1605         }
1606
1607         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1608                 return -errno;
1609
1610         return 0;
1611 }
1612
1613 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1614         struct termios old_termios, new_termios;
1615         char c, line[LINE_MAX];
1616
1617         assert(f);
1618         assert(ret);
1619
1620         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1621                 new_termios = old_termios;
1622
1623                 new_termios.c_lflag &= ~ICANON;
1624                 new_termios.c_cc[VMIN] = 1;
1625                 new_termios.c_cc[VTIME] = 0;
1626
1627                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1628                         size_t k;
1629
1630                         if (t != USEC_INFINITY) {
1631                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1632                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1633                                         return -ETIMEDOUT;
1634                                 }
1635                         }
1636
1637                         k = fread(&c, 1, 1, f);
1638
1639                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1640
1641                         if (k <= 0)
1642                                 return -EIO;
1643
1644                         if (need_nl)
1645                                 *need_nl = c != '\n';
1646
1647                         *ret = c;
1648                         return 0;
1649                 }
1650         }
1651
1652         if (t != USEC_INFINITY) {
1653                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1654                         return -ETIMEDOUT;
1655         }
1656
1657         errno = 0;
1658         if (!fgets(line, sizeof(line), f))
1659                 return errno ? -errno : -EIO;
1660
1661         truncate_nl(line);
1662
1663         if (strlen(line) != 1)
1664                 return -EBADMSG;
1665
1666         if (need_nl)
1667                 *need_nl = false;
1668
1669         *ret = line[0];
1670         return 0;
1671 }
1672
1673 int ask_char(char *ret, const char *replies, const char *text, ...) {
1674         int r;
1675
1676         assert(ret);
1677         assert(replies);
1678         assert(text);
1679
1680         for (;;) {
1681                 va_list ap;
1682                 char c;
1683                 bool need_nl = true;
1684
1685                 if (on_tty())
1686                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1687
1688                 va_start(ap, text);
1689                 vprintf(text, ap);
1690                 va_end(ap);
1691
1692                 if (on_tty())
1693                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1694
1695                 fflush(stdout);
1696
1697                 r = read_one_char(stdin, &c, USEC_INFINITY, &need_nl);
1698                 if (r < 0) {
1699
1700                         if (r == -EBADMSG) {
1701                                 puts("Bad input, please try again.");
1702                                 continue;
1703                         }
1704
1705                         putchar('\n');
1706                         return r;
1707                 }
1708
1709                 if (need_nl)
1710                         putchar('\n');
1711
1712                 if (strchr(replies, c)) {
1713                         *ret = c;
1714                         return 0;
1715                 }
1716
1717                 puts("Read unexpected character, please try again.");
1718         }
1719 }
1720
1721 int ask_string(char **ret, const char *text, ...) {
1722         assert(ret);
1723         assert(text);
1724
1725         for (;;) {
1726                 char line[LINE_MAX];
1727                 va_list ap;
1728
1729                 if (on_tty())
1730                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1731
1732                 va_start(ap, text);
1733                 vprintf(text, ap);
1734                 va_end(ap);
1735
1736                 if (on_tty())
1737                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1738
1739                 fflush(stdout);
1740
1741                 errno = 0;
1742                 if (!fgets(line, sizeof(line), stdin))
1743                         return errno ? -errno : -EIO;
1744
1745                 if (!endswith(line, "\n"))
1746                         putchar('\n');
1747                 else {
1748                         char *s;
1749
1750                         if (isempty(line))
1751                                 continue;
1752
1753                         truncate_nl(line);
1754                         s = strdup(line);
1755                         if (!s)
1756                                 return -ENOMEM;
1757
1758                         *ret = s;
1759                         return 0;
1760                 }
1761         }
1762 }
1763
1764 int reset_terminal_fd(int fd, bool switch_to_text) {
1765         struct termios termios;
1766         int r = 0;
1767
1768         /* Set terminal to some sane defaults */
1769
1770         assert(fd >= 0);
1771
1772         /* We leave locked terminal attributes untouched, so that
1773          * Plymouth may set whatever it wants to set, and we don't
1774          * interfere with that. */
1775
1776         /* Disable exclusive mode, just in case */
1777         ioctl(fd, TIOCNXCL);
1778
1779         /* Switch to text mode */
1780         if (switch_to_text)
1781                 ioctl(fd, KDSETMODE, KD_TEXT);
1782
1783         /* Enable console unicode mode */
1784         ioctl(fd, KDSKBMODE, K_UNICODE);
1785
1786         if (tcgetattr(fd, &termios) < 0) {
1787                 r = -errno;
1788                 goto finish;
1789         }
1790
1791         /* We only reset the stuff that matters to the software. How
1792          * hardware is set up we don't touch assuming that somebody
1793          * else will do that for us */
1794
1795         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1796         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1797         termios.c_oflag |= ONLCR;
1798         termios.c_cflag |= CREAD;
1799         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1800
1801         termios.c_cc[VINTR]    =   03;  /* ^C */
1802         termios.c_cc[VQUIT]    =  034;  /* ^\ */
1803         termios.c_cc[VERASE]   = 0177;
1804         termios.c_cc[VKILL]    =  025;  /* ^X */
1805         termios.c_cc[VEOF]     =   04;  /* ^D */
1806         termios.c_cc[VSTART]   =  021;  /* ^Q */
1807         termios.c_cc[VSTOP]    =  023;  /* ^S */
1808         termios.c_cc[VSUSP]    =  032;  /* ^Z */
1809         termios.c_cc[VLNEXT]   =  026;  /* ^V */
1810         termios.c_cc[VWERASE]  =  027;  /* ^W */
1811         termios.c_cc[VREPRINT] =  022;  /* ^R */
1812         termios.c_cc[VEOL]     =    0;
1813         termios.c_cc[VEOL2]    =    0;
1814
1815         termios.c_cc[VTIME]  = 0;
1816         termios.c_cc[VMIN]   = 1;
1817
1818         if (tcsetattr(fd, TCSANOW, &termios) < 0)
1819                 r = -errno;
1820
1821 finish:
1822         /* Just in case, flush all crap out */
1823         tcflush(fd, TCIOFLUSH);
1824
1825         return r;
1826 }
1827
1828 int reset_terminal(const char *name) {
1829         _cleanup_close_ int fd = -1;
1830
1831         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1832         if (fd < 0)
1833                 return fd;
1834
1835         return reset_terminal_fd(fd, true);
1836 }
1837
1838 int open_terminal(const char *name, int mode) {
1839         int fd, r;
1840         unsigned c = 0;
1841
1842         /*
1843          * If a TTY is in the process of being closed opening it might
1844          * cause EIO. This is horribly awful, but unlikely to be
1845          * changed in the kernel. Hence we work around this problem by
1846          * retrying a couple of times.
1847          *
1848          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1849          */
1850
1851         assert(!(mode & O_CREAT));
1852
1853         for (;;) {
1854                 fd = open(name, mode, 0);
1855                 if (fd >= 0)
1856                         break;
1857
1858                 if (errno != EIO)
1859                         return -errno;
1860
1861                 /* Max 1s in total */
1862                 if (c >= 20)
1863                         return -errno;
1864
1865                 usleep(50 * USEC_PER_MSEC);
1866                 c++;
1867         }
1868
1869         if (fd < 0)
1870                 return -errno;
1871
1872         r = isatty(fd);
1873         if (r < 0) {
1874                 safe_close(fd);
1875                 return -errno;
1876         }
1877
1878         if (!r) {
1879                 safe_close(fd);
1880                 return -ENOTTY;
1881         }
1882
1883         return fd;
1884 }
1885
1886 int flush_fd(int fd) {
1887         struct pollfd pollfd = {
1888                 .fd = fd,
1889                 .events = POLLIN,
1890         };
1891
1892         for (;;) {
1893                 char buf[LINE_MAX];
1894                 ssize_t l;
1895                 int r;
1896
1897                 r = poll(&pollfd, 1, 0);
1898                 if (r < 0) {
1899                         if (errno == EINTR)
1900                                 continue;
1901
1902                         return -errno;
1903
1904                 } else if (r == 0)
1905                         return 0;
1906
1907                 l = read(fd, buf, sizeof(buf));
1908                 if (l < 0) {
1909
1910                         if (errno == EINTR)
1911                                 continue;
1912
1913                         if (errno == EAGAIN)
1914                                 return 0;
1915
1916                         return -errno;
1917                 } else if (l == 0)
1918                         return 0;
1919         }
1920 }
1921
1922 int acquire_terminal(
1923                 const char *name,
1924                 bool fail,
1925                 bool force,
1926                 bool ignore_tiocstty_eperm,
1927                 usec_t timeout) {
1928
1929         int fd = -1, notify = -1, r = 0, wd = -1;
1930         usec_t ts = 0;
1931
1932         assert(name);
1933
1934         /* We use inotify to be notified when the tty is closed. We
1935          * create the watch before checking if we can actually acquire
1936          * it, so that we don't lose any event.
1937          *
1938          * Note: strictly speaking this actually watches for the
1939          * device being closed, it does *not* really watch whether a
1940          * tty loses its controlling process. However, unless some
1941          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1942          * its tty otherwise this will not become a problem. As long
1943          * as the administrator makes sure not configure any service
1944          * on the same tty as an untrusted user this should not be a
1945          * problem. (Which he probably should not do anyway.) */
1946
1947         if (timeout != USEC_INFINITY)
1948                 ts = now(CLOCK_MONOTONIC);
1949
1950         if (!fail && !force) {
1951                 notify = inotify_init1(IN_CLOEXEC | (timeout != USEC_INFINITY ? IN_NONBLOCK : 0));
1952                 if (notify < 0) {
1953                         r = -errno;
1954                         goto fail;
1955                 }
1956
1957                 wd = inotify_add_watch(notify, name, IN_CLOSE);
1958                 if (wd < 0) {
1959                         r = -errno;
1960                         goto fail;
1961                 }
1962         }
1963
1964         for (;;) {
1965                 struct sigaction sa_old, sa_new = {
1966                         .sa_handler = SIG_IGN,
1967                         .sa_flags = SA_RESTART,
1968                 };
1969
1970                 if (notify >= 0) {
1971                         r = flush_fd(notify);
1972                         if (r < 0)
1973                                 goto fail;
1974                 }
1975
1976                 /* We pass here O_NOCTTY only so that we can check the return
1977                  * value TIOCSCTTY and have a reliable way to figure out if we
1978                  * successfully became the controlling process of the tty */
1979                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1980                 if (fd < 0)
1981                         return fd;
1982
1983                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1984                  * if we already own the tty. */
1985                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1986
1987                 /* First, try to get the tty */
1988                 if (ioctl(fd, TIOCSCTTY, force) < 0)
1989                         r = -errno;
1990
1991                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1992
1993                 /* Sometimes it makes sense to ignore TIOCSCTTY
1994                  * returning EPERM, i.e. when very likely we already
1995                  * are have this controlling terminal. */
1996                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1997                         r = 0;
1998
1999                 if (r < 0 && (force || fail || r != -EPERM)) {
2000                         goto fail;
2001                 }
2002
2003                 if (r >= 0)
2004                         break;
2005
2006                 assert(!fail);
2007                 assert(!force);
2008                 assert(notify >= 0);
2009
2010                 for (;;) {
2011                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
2012                         ssize_t l;
2013                         struct inotify_event *e;
2014
2015                         if (timeout != USEC_INFINITY) {
2016                                 usec_t n;
2017
2018                                 n = now(CLOCK_MONOTONIC);
2019                                 if (ts + timeout < n) {
2020                                         r = -ETIMEDOUT;
2021                                         goto fail;
2022                                 }
2023
2024                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2025                                 if (r < 0)
2026                                         goto fail;
2027
2028                                 if (r == 0) {
2029                                         r = -ETIMEDOUT;
2030                                         goto fail;
2031                                 }
2032                         }
2033
2034                         l = read(notify, inotify_buffer, sizeof(inotify_buffer));
2035                         if (l < 0) {
2036
2037                                 if (errno == EINTR || errno == EAGAIN)
2038                                         continue;
2039
2040                                 r = -errno;
2041                                 goto fail;
2042                         }
2043
2044                         e = (struct inotify_event*) inotify_buffer;
2045
2046                         while (l > 0) {
2047                                 size_t step;
2048
2049                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2050                                         r = -EIO;
2051                                         goto fail;
2052                                 }
2053
2054                                 step = sizeof(struct inotify_event) + e->len;
2055                                 assert(step <= (size_t) l);
2056
2057                                 e = (struct inotify_event*) ((uint8_t*) e + step);
2058                                 l -= step;
2059                         }
2060
2061                         break;
2062                 }
2063
2064                 /* We close the tty fd here since if the old session
2065                  * ended our handle will be dead. It's important that
2066                  * we do this after sleeping, so that we don't enter
2067                  * an endless loop. */
2068                 safe_close(fd);
2069         }
2070
2071         safe_close(notify);
2072
2073         r = reset_terminal_fd(fd, true);
2074         if (r < 0)
2075                 log_warning("Failed to reset terminal: %s", strerror(-r));
2076
2077         return fd;
2078
2079 fail:
2080         safe_close(fd);
2081         safe_close(notify);
2082
2083         return r;
2084 }
2085
2086 int release_terminal(void) {
2087         int r = 0;
2088         struct sigaction sa_old, sa_new = {
2089                 .sa_handler = SIG_IGN,
2090                 .sa_flags = SA_RESTART,
2091         };
2092         _cleanup_close_ int fd;
2093
2094         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2095         if (fd < 0)
2096                 return -errno;
2097
2098         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2099          * by our own TIOCNOTTY */
2100         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2101
2102         if (ioctl(fd, TIOCNOTTY) < 0)
2103                 r = -errno;
2104
2105         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2106
2107         return r;
2108 }
2109
2110 int sigaction_many(const struct sigaction *sa, ...) {
2111         va_list ap;
2112         int r = 0, sig;
2113
2114         va_start(ap, sa);
2115         while ((sig = va_arg(ap, int)) > 0)
2116                 if (sigaction(sig, sa, NULL) < 0)
2117                         r = -errno;
2118         va_end(ap);
2119
2120         return r;
2121 }
2122
2123 int ignore_signals(int sig, ...) {
2124         struct sigaction sa = {
2125                 .sa_handler = SIG_IGN,
2126                 .sa_flags = SA_RESTART,
2127         };
2128         va_list ap;
2129         int r = 0;
2130
2131         if (sigaction(sig, &sa, NULL) < 0)
2132                 r = -errno;
2133
2134         va_start(ap, sig);
2135         while ((sig = va_arg(ap, int)) > 0)
2136                 if (sigaction(sig, &sa, NULL) < 0)
2137                         r = -errno;
2138         va_end(ap);
2139
2140         return r;
2141 }
2142
2143 int default_signals(int sig, ...) {
2144         struct sigaction sa = {
2145                 .sa_handler = SIG_DFL,
2146                 .sa_flags = SA_RESTART,
2147         };
2148         va_list ap;
2149         int r = 0;
2150
2151         if (sigaction(sig, &sa, NULL) < 0)
2152                 r = -errno;
2153
2154         va_start(ap, sig);
2155         while ((sig = va_arg(ap, int)) > 0)
2156                 if (sigaction(sig, &sa, NULL) < 0)
2157                         r = -errno;
2158         va_end(ap);
2159
2160         return r;
2161 }
2162
2163 void safe_close_pair(int p[]) {
2164         assert(p);
2165
2166         if (p[0] == p[1]) {
2167                 /* Special case pairs which use the same fd in both
2168                  * directions... */
2169                 p[0] = p[1] = safe_close(p[0]);
2170                 return;
2171         }
2172
2173         p[0] = safe_close(p[0]);
2174         p[1] = safe_close(p[1]);
2175 }
2176
2177 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2178         uint8_t *p = buf;
2179         ssize_t n = 0;
2180
2181         assert(fd >= 0);
2182         assert(buf);
2183
2184         while (nbytes > 0) {
2185                 ssize_t k;
2186
2187                 k = read(fd, p, nbytes);
2188                 if (k < 0 && errno == EINTR)
2189                         continue;
2190
2191                 if (k < 0 && errno == EAGAIN && do_poll) {
2192
2193                         /* We knowingly ignore any return value here,
2194                          * and expect that any error/EOF is reported
2195                          * via read() */
2196
2197                         fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
2198                         continue;
2199                 }
2200
2201                 if (k <= 0)
2202                         return n > 0 ? n : (k < 0 ? -errno : 0);
2203
2204                 p += k;
2205                 nbytes -= k;
2206                 n += k;
2207         }
2208
2209         return n;
2210 }
2211
2212 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2213         const uint8_t *p = buf;
2214         ssize_t n = 0;
2215
2216         assert(fd >= 0);
2217         assert(buf);
2218
2219         while (nbytes > 0) {
2220                 ssize_t k;
2221
2222                 k = write(fd, p, nbytes);
2223                 if (k < 0 && errno == EINTR)
2224                         continue;
2225
2226                 if (k < 0 && errno == EAGAIN && do_poll) {
2227
2228                         /* We knowingly ignore any return value here,
2229                          * and expect that any error/EOF is reported
2230                          * via write() */
2231
2232                         fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
2233                         continue;
2234                 }
2235
2236                 if (k <= 0)
2237                         return n > 0 ? n : (k < 0 ? -errno : 0);
2238
2239                 p += k;
2240                 nbytes -= k;
2241                 n += k;
2242         }
2243
2244         return n;
2245 }
2246
2247 int parse_size(const char *t, off_t base, off_t *size) {
2248
2249         /* Soo, sometimes we want to parse IEC binary suffxies, and
2250          * sometimes SI decimal suffixes. This function can parse
2251          * both. Which one is the right way depends on the
2252          * context. Wikipedia suggests that SI is customary for
2253          * hardrware metrics and network speeds, while IEC is
2254          * customary for most data sizes used by software and volatile
2255          * (RAM) memory. Hence be careful which one you pick!
2256          *
2257          * In either case we use just K, M, G as suffix, and not Ki,
2258          * Mi, Gi or so (as IEC would suggest). That's because that's
2259          * frickin' ugly. But this means you really need to make sure
2260          * to document which base you are parsing when you use this
2261          * call. */
2262
2263         struct table {
2264                 const char *suffix;
2265                 unsigned long long factor;
2266         };
2267
2268         static const struct table iec[] = {
2269                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2270                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2271                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2272                 { "G", 1024ULL*1024ULL*1024ULL },
2273                 { "M", 1024ULL*1024ULL },
2274                 { "K", 1024ULL },
2275                 { "B", 1 },
2276                 { "", 1 },
2277         };
2278
2279         static const struct table si[] = {
2280                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2281                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2282                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2283                 { "G", 1000ULL*1000ULL*1000ULL },
2284                 { "M", 1000ULL*1000ULL },
2285                 { "K", 1000ULL },
2286                 { "B", 1 },
2287                 { "", 1 },
2288         };
2289
2290         const struct table *table;
2291         const char *p;
2292         unsigned long long r = 0;
2293         unsigned n_entries, start_pos = 0;
2294
2295         assert(t);
2296         assert(base == 1000 || base == 1024);
2297         assert(size);
2298
2299         if (base == 1000) {
2300                 table = si;
2301                 n_entries = ELEMENTSOF(si);
2302         } else {
2303                 table = iec;
2304                 n_entries = ELEMENTSOF(iec);
2305         }
2306
2307         p = t;
2308         do {
2309                 long long l;
2310                 unsigned long long l2;
2311                 double frac = 0;
2312                 char *e;
2313                 unsigned i;
2314
2315                 errno = 0;
2316                 l = strtoll(p, &e, 10);
2317
2318                 if (errno > 0)
2319                         return -errno;
2320
2321                 if (l < 0)
2322                         return -ERANGE;
2323
2324                 if (e == p)
2325                         return -EINVAL;
2326
2327                 if (*e == '.') {
2328                         e++;
2329                         if (*e >= '0' && *e <= '9') {
2330                                 char *e2;
2331
2332                                 /* strotoull itself would accept space/+/- */
2333                                 l2 = strtoull(e, &e2, 10);
2334
2335                                 if (errno == ERANGE)
2336                                         return -errno;
2337
2338                                 /* Ignore failure. E.g. 10.M is valid */
2339                                 frac = l2;
2340                                 for (; e < e2; e++)
2341                                         frac /= 10;
2342                         }
2343                 }
2344
2345                 e += strspn(e, WHITESPACE);
2346
2347                 for (i = start_pos; i < n_entries; i++)
2348                         if (startswith(e, table[i].suffix)) {
2349                                 unsigned long long tmp;
2350                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2351                                         return -ERANGE;
2352                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2353                                 if (tmp > ULLONG_MAX - r)
2354                                         return -ERANGE;
2355
2356                                 r += tmp;
2357                                 if ((unsigned long long) (off_t) r != r)
2358                                         return -ERANGE;
2359
2360                                 p = e + strlen(table[i].suffix);
2361
2362                                 start_pos = i + 1;
2363                                 break;
2364                         }
2365
2366                 if (i >= n_entries)
2367                         return -EINVAL;
2368
2369         } while (*p);
2370
2371         *size = r;
2372
2373         return 0;
2374 }
2375
2376 int make_stdio(int fd) {
2377         int r, s, t;
2378
2379         assert(fd >= 0);
2380
2381         r = dup3(fd, STDIN_FILENO, 0);
2382         s = dup3(fd, STDOUT_FILENO, 0);
2383         t = dup3(fd, STDERR_FILENO, 0);
2384
2385         if (fd >= 3)
2386                 safe_close(fd);
2387
2388         if (r < 0 || s < 0 || t < 0)
2389                 return -errno;
2390
2391         /* We rely here that the new fd has O_CLOEXEC not set */
2392
2393         return 0;
2394 }
2395
2396 int make_null_stdio(void) {
2397         int null_fd;
2398
2399         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2400         if (null_fd < 0)
2401                 return -errno;
2402
2403         return make_stdio(null_fd);
2404 }
2405
2406 bool is_device_path(const char *path) {
2407
2408         /* Returns true on paths that refer to a device, either in
2409          * sysfs or in /dev */
2410
2411         return
2412                 path_startswith(path, "/dev/") ||
2413                 path_startswith(path, "/sys/");
2414 }
2415
2416 int dir_is_empty(const char *path) {
2417         _cleanup_closedir_ DIR *d;
2418
2419         d = opendir(path);
2420         if (!d)
2421                 return -errno;
2422
2423         for (;;) {
2424                 struct dirent *de;
2425
2426                 errno = 0;
2427                 de = readdir(d);
2428                 if (!de && errno != 0)
2429                         return -errno;
2430
2431                 if (!de)
2432                         return 1;
2433
2434                 if (!ignore_file(de->d_name))
2435                         return 0;
2436         }
2437 }
2438
2439 char* dirname_malloc(const char *path) {
2440         char *d, *dir, *dir2;
2441
2442         d = strdup(path);
2443         if (!d)
2444                 return NULL;
2445         dir = dirname(d);
2446         assert(dir);
2447
2448         if (dir != d) {
2449                 dir2 = strdup(dir);
2450                 free(d);
2451                 return dir2;
2452         }
2453
2454         return dir;
2455 }
2456
2457 int dev_urandom(void *p, size_t n) {
2458         _cleanup_close_ int fd;
2459         ssize_t k;
2460
2461         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2462         if (fd < 0)
2463                 return errno == ENOENT ? -ENOSYS : -errno;
2464
2465         k = loop_read(fd, p, n, true);
2466         if (k < 0)
2467                 return (int) k;
2468         if ((size_t) k != n)
2469                 return -EIO;
2470
2471         return 0;
2472 }
2473
2474 void random_bytes(void *p, size_t n) {
2475         static bool srand_called = false;
2476         uint8_t *q;
2477         int r;
2478
2479         r = dev_urandom(p, n);
2480         if (r >= 0)
2481                 return;
2482
2483         /* If some idiot made /dev/urandom unavailable to us, he'll
2484          * get a PRNG instead. */
2485
2486         if (!srand_called) {
2487                 unsigned x = 0;
2488
2489 #ifdef HAVE_SYS_AUXV_H
2490                 /* The kernel provides us with a bit of entropy in
2491                  * auxv, so let's try to make use of that to seed the
2492                  * pseudo-random generator. It's better than
2493                  * nothing... */
2494
2495                 void *auxv;
2496
2497                 auxv = (void*) getauxval(AT_RANDOM);
2498                 if (auxv)
2499                         x ^= *(unsigned*) auxv;
2500 #endif
2501
2502                 x ^= (unsigned) now(CLOCK_REALTIME);
2503                 x ^= (unsigned) gettid();
2504
2505                 srand(x);
2506                 srand_called = true;
2507         }
2508
2509         for (q = p; q < (uint8_t*) p + n; q ++)
2510                 *q = rand();
2511 }
2512
2513 void rename_process(const char name[8]) {
2514         assert(name);
2515
2516         /* This is a like a poor man's setproctitle(). It changes the
2517          * comm field, argv[0], and also the glibc's internally used
2518          * name of the process. For the first one a limit of 16 chars
2519          * applies, to the second one usually one of 10 (i.e. length
2520          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2521          * "systemd"). If you pass a longer string it will be
2522          * truncated */
2523
2524         prctl(PR_SET_NAME, name);
2525
2526         if (program_invocation_name)
2527                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2528
2529         if (saved_argc > 0) {
2530                 int i;
2531
2532                 if (saved_argv[0])
2533                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2534
2535                 for (i = 1; i < saved_argc; i++) {
2536                         if (!saved_argv[i])
2537                                 break;
2538
2539                         memzero(saved_argv[i], strlen(saved_argv[i]));
2540                 }
2541         }
2542 }
2543
2544 void sigset_add_many(sigset_t *ss, ...) {
2545         va_list ap;
2546         int sig;
2547
2548         assert(ss);
2549
2550         va_start(ap, ss);
2551         while ((sig = va_arg(ap, int)) > 0)
2552                 assert_se(sigaddset(ss, sig) == 0);
2553         va_end(ap);
2554 }
2555
2556 int sigprocmask_many(int how, ...) {
2557         va_list ap;
2558         sigset_t ss;
2559         int sig;
2560
2561         assert_se(sigemptyset(&ss) == 0);
2562
2563         va_start(ap, how);
2564         while ((sig = va_arg(ap, int)) > 0)
2565                 assert_se(sigaddset(&ss, sig) == 0);
2566         va_end(ap);
2567
2568         if (sigprocmask(how, &ss, NULL) < 0)
2569                 return -errno;
2570
2571         return 0;
2572 }
2573
2574 char* gethostname_malloc(void) {
2575         struct utsname u;
2576
2577         assert_se(uname(&u) >= 0);
2578
2579         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2580                 return strdup(u.nodename);
2581
2582         return strdup(u.sysname);
2583 }
2584
2585 bool hostname_is_set(void) {
2586         struct utsname u;
2587
2588         assert_se(uname(&u) >= 0);
2589
2590         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2591 }
2592
2593 static char *lookup_uid(uid_t uid) {
2594         long bufsize;
2595         char *name;
2596         _cleanup_free_ char *buf = NULL;
2597         struct passwd pwbuf, *pw = NULL;
2598
2599         /* Shortcut things to avoid NSS lookups */
2600         if (uid == 0)
2601                 return strdup("root");
2602
2603         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2604         if (bufsize <= 0)
2605                 bufsize = 4096;
2606
2607         buf = malloc(bufsize);
2608         if (!buf)
2609                 return NULL;
2610
2611         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2612                 return strdup(pw->pw_name);
2613
2614         if (asprintf(&name, UID_FMT, uid) < 0)
2615                 return NULL;
2616
2617         return name;
2618 }
2619
2620 char* getlogname_malloc(void) {
2621         uid_t uid;
2622         struct stat st;
2623
2624         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2625                 uid = st.st_uid;
2626         else
2627                 uid = getuid();
2628
2629         return lookup_uid(uid);
2630 }
2631
2632 char *getusername_malloc(void) {
2633         const char *e;
2634
2635         e = getenv("USER");
2636         if (e)
2637                 return strdup(e);
2638
2639         return lookup_uid(getuid());
2640 }
2641
2642 int getttyname_malloc(int fd, char **r) {
2643         char path[PATH_MAX], *c;
2644         int k;
2645
2646         assert(r);
2647
2648         k = ttyname_r(fd, path, sizeof(path));
2649         if (k > 0)
2650                 return -k;
2651
2652         char_array_0(path);
2653
2654         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2655         if (!c)
2656                 return -ENOMEM;
2657
2658         *r = c;
2659         return 0;
2660 }
2661
2662 int getttyname_harder(int fd, char **r) {
2663         int k;
2664         char *s;
2665
2666         k = getttyname_malloc(fd, &s);
2667         if (k < 0)
2668                 return k;
2669
2670         if (streq(s, "tty")) {
2671                 free(s);
2672                 return get_ctty(0, NULL, r);
2673         }
2674
2675         *r = s;
2676         return 0;
2677 }
2678
2679 int get_ctty_devnr(pid_t pid, dev_t *d) {
2680         int r;
2681         _cleanup_free_ char *line = NULL;
2682         const char *p;
2683         unsigned long ttynr;
2684
2685         assert(pid >= 0);
2686
2687         p = procfs_file_alloca(pid, "stat");
2688         r = read_one_line_file(p, &line);
2689         if (r < 0)
2690                 return r;
2691
2692         p = strrchr(line, ')');
2693         if (!p)
2694                 return -EIO;
2695
2696         p++;
2697
2698         if (sscanf(p, " "
2699                    "%*c "  /* state */
2700                    "%*d "  /* ppid */
2701                    "%*d "  /* pgrp */
2702                    "%*d "  /* session */
2703                    "%lu ", /* ttynr */
2704                    &ttynr) != 1)
2705                 return -EIO;
2706
2707         if (major(ttynr) == 0 && minor(ttynr) == 0)
2708                 return -ENOENT;
2709
2710         if (d)
2711                 *d = (dev_t) ttynr;
2712
2713         return 0;
2714 }
2715
2716 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2717         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2718         _cleanup_free_ char *s = NULL;
2719         const char *p;
2720         dev_t devnr;
2721         int k;
2722
2723         assert(r);
2724
2725         k = get_ctty_devnr(pid, &devnr);
2726         if (k < 0)
2727                 return k;
2728
2729         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2730
2731         k = readlink_malloc(fn, &s);
2732         if (k < 0) {
2733
2734                 if (k != -ENOENT)
2735                         return k;
2736
2737                 /* This is an ugly hack */
2738                 if (major(devnr) == 136) {
2739                         asprintf(&b, "pts/%u", minor(devnr));
2740                         goto finish;
2741                 }
2742
2743                 /* Probably something like the ptys which have no
2744                  * symlink in /dev/char. Let's return something
2745                  * vaguely useful. */
2746
2747                 b = strdup(fn + 5);
2748                 goto finish;
2749         }
2750
2751         if (startswith(s, "/dev/"))
2752                 p = s + 5;
2753         else if (startswith(s, "../"))
2754                 p = s + 3;
2755         else
2756                 p = s;
2757
2758         b = strdup(p);
2759
2760 finish:
2761         if (!b)
2762                 return -ENOMEM;
2763
2764         *r = b;
2765         if (_devnr)
2766                 *_devnr = devnr;
2767
2768         return 0;
2769 }
2770
2771 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2772         _cleanup_closedir_ DIR *d = NULL;
2773         int ret = 0;
2774
2775         assert(fd >= 0);
2776
2777         /* This returns the first error we run into, but nevertheless
2778          * tries to go on. This closes the passed fd. */
2779
2780         d = fdopendir(fd);
2781         if (!d) {
2782                 safe_close(fd);
2783
2784                 return errno == ENOENT ? 0 : -errno;
2785         }
2786
2787         for (;;) {
2788                 struct dirent *de;
2789                 bool is_dir, keep_around;
2790                 struct stat st;
2791                 int r;
2792
2793                 errno = 0;
2794                 de = readdir(d);
2795                 if (!de) {
2796                         if (errno != 0 && ret == 0)
2797                                 ret = -errno;
2798                         return ret;
2799                 }
2800
2801                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2802                         continue;
2803
2804                 if (de->d_type == DT_UNKNOWN ||
2805                     honour_sticky ||
2806                     (de->d_type == DT_DIR && root_dev)) {
2807                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2808                                 if (ret == 0 && errno != ENOENT)
2809                                         ret = -errno;
2810                                 continue;
2811                         }
2812
2813                         is_dir = S_ISDIR(st.st_mode);
2814                         keep_around =
2815                                 honour_sticky &&
2816                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2817                                 (st.st_mode & S_ISVTX);
2818                 } else {
2819                         is_dir = de->d_type == DT_DIR;
2820                         keep_around = false;
2821                 }
2822
2823                 if (is_dir) {
2824                         int subdir_fd;
2825
2826                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2827                         if (root_dev && st.st_dev != root_dev->st_dev)
2828                                 continue;
2829
2830                         subdir_fd = openat(fd, de->d_name,
2831                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2832                         if (subdir_fd < 0) {
2833                                 if (ret == 0 && errno != ENOENT)
2834                                         ret = -errno;
2835                                 continue;
2836                         }
2837
2838                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2839                         if (r < 0 && ret == 0)
2840                                 ret = r;
2841
2842                         if (!keep_around)
2843                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2844                                         if (ret == 0 && errno != ENOENT)
2845                                                 ret = -errno;
2846                                 }
2847
2848                 } else if (!only_dirs && !keep_around) {
2849
2850                         if (unlinkat(fd, de->d_name, 0) < 0) {
2851                                 if (ret == 0 && errno != ENOENT)
2852                                         ret = -errno;
2853                         }
2854                 }
2855         }
2856 }
2857
2858 _pure_ static int is_temporary_fs(struct statfs *s) {
2859         assert(s);
2860
2861         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2862                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2863 }
2864
2865 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2866         struct statfs s;
2867
2868         assert(fd >= 0);
2869
2870         if (fstatfs(fd, &s) < 0) {
2871                 safe_close(fd);
2872                 return -errno;
2873         }
2874
2875         /* We refuse to clean disk file systems with this call. This
2876          * is extra paranoia just to be sure we never ever remove
2877          * non-state data */
2878         if (!is_temporary_fs(&s)) {
2879                 log_error("Attempted to remove disk file system, and we can't allow that.");
2880                 safe_close(fd);
2881                 return -EPERM;
2882         }
2883
2884         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2885 }
2886
2887 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2888         int fd, r;
2889         struct statfs s;
2890
2891         assert(path);
2892
2893         /* We refuse to clean the root file system with this
2894          * call. This is extra paranoia to never cause a really
2895          * seriously broken system. */
2896         if (path_equal(path, "/")) {
2897                 log_error("Attempted to remove entire root file system, and we can't allow that.");
2898                 return -EPERM;
2899         }
2900
2901         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2902         if (fd < 0) {
2903
2904                 if (errno != ENOTDIR)
2905                         return -errno;
2906
2907                 if (!dangerous) {
2908                         if (statfs(path, &s) < 0)
2909                                 return -errno;
2910
2911                         if (!is_temporary_fs(&s)) {
2912                                 log_error("Attempted to remove disk file system, and we can't allow that.");
2913                                 return -EPERM;
2914                         }
2915                 }
2916
2917                 if (delete_root && !only_dirs)
2918                         if (unlink(path) < 0 && errno != ENOENT)
2919                                 return -errno;
2920
2921                 return 0;
2922         }
2923
2924         if (!dangerous) {
2925                 if (fstatfs(fd, &s) < 0) {
2926                         safe_close(fd);
2927                         return -errno;
2928                 }
2929
2930                 if (!is_temporary_fs(&s)) {
2931                         log_error("Attempted to remove disk file system, and we can't allow that.");
2932                         safe_close(fd);
2933                         return -EPERM;
2934                 }
2935         }
2936
2937         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2938         if (delete_root) {
2939
2940                 if (honour_sticky && file_is_priv_sticky(path) > 0)
2941                         return r;
2942
2943                 if (rmdir(path) < 0 && errno != ENOENT) {
2944                         if (r == 0)
2945                                 r = -errno;
2946                 }
2947         }
2948
2949         return r;
2950 }
2951
2952 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2953         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2954 }
2955
2956 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2957         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2958 }
2959
2960 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2961         assert(path);
2962
2963         /* Under the assumption that we are running privileged we
2964          * first change the access mode and only then hand out
2965          * ownership to avoid a window where access is too open. */
2966
2967         if (mode != (mode_t) -1)
2968                 if (chmod(path, mode) < 0)
2969                         return -errno;
2970
2971         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2972                 if (chown(path, uid, gid) < 0)
2973                         return -errno;
2974
2975         return 0;
2976 }
2977
2978 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2979         assert(fd >= 0);
2980
2981         /* Under the assumption that we are running privileged we
2982          * first change the access mode and only then hand out
2983          * ownership to avoid a window where access is too open. */
2984
2985         if (mode != (mode_t) -1)
2986                 if (fchmod(fd, mode) < 0)
2987                         return -errno;
2988
2989         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2990                 if (fchown(fd, uid, gid) < 0)
2991                         return -errno;
2992
2993         return 0;
2994 }
2995
2996 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2997         cpu_set_t *r;
2998         unsigned n = 1024;
2999
3000         /* Allocates the cpuset in the right size */
3001
3002         for (;;) {
3003                 if (!(r = CPU_ALLOC(n)))
3004                         return NULL;
3005
3006                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3007                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3008
3009                         if (ncpus)
3010                                 *ncpus = n;
3011
3012                         return r;
3013                 }
3014
3015                 CPU_FREE(r);
3016
3017                 if (errno != EINVAL)
3018                         return NULL;
3019
3020                 n *= 2;
3021         }
3022 }
3023
3024 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
3025         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3026         _cleanup_free_ char *s = NULL;
3027         _cleanup_close_ int fd = -1;
3028         struct iovec iovec[6] = {};
3029         int n = 0;
3030         static bool prev_ephemeral;
3031
3032         assert(format);
3033
3034         /* This is independent of logging, as status messages are
3035          * optional and go exclusively to the console. */
3036
3037         if (vasprintf(&s, format, ap) < 0)
3038                 return log_oom();
3039
3040         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3041         if (fd < 0)
3042                 return fd;
3043
3044         if (ellipse) {
3045                 char *e;
3046                 size_t emax, sl;
3047                 int c;
3048
3049                 c = fd_columns(fd);
3050                 if (c <= 0)
3051                         c = 80;
3052
3053                 sl = status ? sizeof(status_indent)-1 : 0;
3054
3055                 emax = c - sl - 1;
3056                 if (emax < 3)
3057                         emax = 3;
3058
3059                 e = ellipsize(s, emax, 75);
3060                 if (e) {
3061                         free(s);
3062                         s = e;
3063                 }
3064         }
3065
3066         if (prev_ephemeral)
3067                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3068         prev_ephemeral = ephemeral;
3069
3070         if (status) {
3071                 if (!isempty(status)) {
3072                         IOVEC_SET_STRING(iovec[n++], "[");
3073                         IOVEC_SET_STRING(iovec[n++], status);
3074                         IOVEC_SET_STRING(iovec[n++], "] ");
3075                 } else
3076                         IOVEC_SET_STRING(iovec[n++], status_indent);
3077         }
3078
3079         IOVEC_SET_STRING(iovec[n++], s);
3080         if (!ephemeral)
3081                 IOVEC_SET_STRING(iovec[n++], "\n");
3082
3083         if (writev(fd, iovec, n) < 0)
3084                 return -errno;
3085
3086         return 0;
3087 }
3088
3089 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3090         va_list ap;
3091         int r;
3092
3093         assert(format);
3094
3095         va_start(ap, format);
3096         r = status_vprintf(status, ellipse, ephemeral, format, ap);
3097         va_end(ap);
3098
3099         return r;
3100 }
3101
3102 char *replace_env(const char *format, char **env) {
3103         enum {
3104                 WORD,
3105                 CURLY,
3106                 VARIABLE
3107         } state = WORD;
3108
3109         const char *e, *word = format;
3110         char *r = NULL, *k;
3111
3112         assert(format);
3113
3114         for (e = format; *e; e ++) {
3115
3116                 switch (state) {
3117
3118                 case WORD:
3119                         if (*e == '$')
3120                                 state = CURLY;
3121                         break;
3122
3123                 case CURLY:
3124                         if (*e == '{') {
3125                                 if (!(k = strnappend(r, word, e-word-1)))
3126                                         goto fail;
3127
3128                                 free(r);
3129                                 r = k;
3130
3131                                 word = e-1;
3132                                 state = VARIABLE;
3133
3134                         } else if (*e == '$') {
3135                                 if (!(k = strnappend(r, word, e-word)))
3136                                         goto fail;
3137
3138                                 free(r);
3139                                 r = k;
3140
3141                                 word = e+1;
3142                                 state = WORD;
3143                         } else
3144                                 state = WORD;
3145                         break;
3146
3147                 case VARIABLE:
3148                         if (*e == '}') {
3149                                 const char *t;
3150
3151                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3152
3153                                 k = strappend(r, t);
3154                                 if (!k)
3155                                         goto fail;
3156
3157                                 free(r);
3158                                 r = k;
3159
3160                                 word = e+1;
3161                                 state = WORD;
3162                         }
3163                         break;
3164                 }
3165         }
3166
3167         if (!(k = strnappend(r, word, e-word)))
3168                 goto fail;
3169
3170         free(r);
3171         return k;
3172
3173 fail:
3174         free(r);
3175         return NULL;
3176 }
3177
3178 char **replace_env_argv(char **argv, char **env) {
3179         char **ret, **i;
3180         unsigned k = 0, l = 0;
3181
3182         l = strv_length(argv);
3183
3184         ret = new(char*, l+1);
3185         if (!ret)
3186                 return NULL;
3187
3188         STRV_FOREACH(i, argv) {
3189
3190                 /* If $FOO appears as single word, replace it by the split up variable */
3191                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3192                         char *e;
3193                         char **w, **m;
3194                         unsigned q;
3195
3196                         e = strv_env_get(env, *i+1);
3197                         if (e) {
3198                                 int r;
3199
3200                                 r = strv_split_quoted(&m, e);
3201                                 if (r < 0) {
3202                                         ret[k] = NULL;
3203                                         strv_free(ret);
3204                                         return NULL;
3205                                 }
3206                         } else
3207                                 m = NULL;
3208
3209                         q = strv_length(m);
3210                         l = l + q - 1;
3211
3212                         w = realloc(ret, sizeof(char*) * (l+1));
3213                         if (!w) {
3214                                 ret[k] = NULL;
3215                                 strv_free(ret);
3216                                 strv_free(m);
3217                                 return NULL;
3218                         }
3219
3220                         ret = w;
3221                         if (m) {
3222                                 memcpy(ret + k, m, q * sizeof(char*));
3223                                 free(m);
3224                         }
3225
3226                         k += q;
3227                         continue;
3228                 }
3229
3230                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3231                 ret[k] = replace_env(*i, env);
3232                 if (!ret[k]) {
3233                         strv_free(ret);
3234                         return NULL;
3235                 }
3236                 k++;
3237         }
3238
3239         ret[k] = NULL;
3240         return ret;
3241 }
3242
3243 int fd_columns(int fd) {
3244         struct winsize ws = {};
3245
3246         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3247                 return -errno;
3248
3249         if (ws.ws_col <= 0)
3250                 return -EIO;
3251
3252         return ws.ws_col;
3253 }
3254
3255 unsigned columns(void) {
3256         const char *e;
3257         int c;
3258
3259         if (_likely_(cached_columns > 0))
3260                 return cached_columns;
3261
3262         c = 0;
3263         e = getenv("COLUMNS");
3264         if (e)
3265                 safe_atoi(e, &c);
3266
3267         if (c <= 0)
3268                 c = fd_columns(STDOUT_FILENO);
3269
3270         if (c <= 0)
3271                 c = 80;
3272
3273         cached_columns = c;
3274         return c;
3275 }
3276
3277 int fd_lines(int fd) {
3278         struct winsize ws = {};
3279
3280         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3281                 return -errno;
3282
3283         if (ws.ws_row <= 0)
3284                 return -EIO;
3285
3286         return ws.ws_row;
3287 }
3288
3289 unsigned lines(void) {
3290         const char *e;
3291         unsigned l;
3292
3293         if (_likely_(cached_lines > 0))
3294                 return cached_lines;
3295
3296         l = 0;
3297         e = getenv("LINES");
3298         if (e)
3299                 safe_atou(e, &l);
3300
3301         if (l <= 0)
3302                 l = fd_lines(STDOUT_FILENO);
3303
3304         if (l <= 0)
3305                 l = 24;
3306
3307         cached_lines = l;
3308         return cached_lines;
3309 }
3310
3311 /* intended to be used as a SIGWINCH sighandler */
3312 void columns_lines_cache_reset(int signum) {
3313         cached_columns = 0;
3314         cached_lines = 0;
3315 }
3316
3317 bool on_tty(void) {
3318         static int cached_on_tty = -1;
3319
3320         if (_unlikely_(cached_on_tty < 0))
3321                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3322
3323         return cached_on_tty;
3324 }
3325
3326 int files_same(const char *filea, const char *fileb) {
3327         struct stat a, b;
3328
3329         if (stat(filea, &a) < 0)
3330                 return -errno;
3331
3332         if (stat(fileb, &b) < 0)
3333                 return -errno;
3334
3335         return a.st_dev == b.st_dev &&
3336                a.st_ino == b.st_ino;
3337 }
3338
3339 int running_in_chroot(void) {
3340         int ret;
3341
3342         ret = files_same("/proc/1/root", "/");
3343         if (ret < 0)
3344                 return ret;
3345
3346         return ret == 0;
3347 }
3348
3349 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3350         size_t x;
3351         char *r;
3352
3353         assert(s);
3354         assert(percent <= 100);
3355         assert(new_length >= 3);
3356
3357         if (old_length <= 3 || old_length <= new_length)
3358                 return strndup(s, old_length);
3359
3360         r = new0(char, new_length+1);
3361         if (!r)
3362                 return NULL;
3363
3364         x = (new_length * percent) / 100;
3365
3366         if (x > new_length - 3)
3367                 x = new_length - 3;
3368
3369         memcpy(r, s, x);
3370         r[x] = '.';
3371         r[x+1] = '.';
3372         r[x+2] = '.';
3373         memcpy(r + x + 3,
3374                s + old_length - (new_length - x - 3),
3375                new_length - x - 3);
3376
3377         return r;
3378 }
3379
3380 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3381         size_t x;
3382         char *e;
3383         const char *i, *j;
3384         unsigned k, len, len2;
3385
3386         assert(s);
3387         assert(percent <= 100);
3388         assert(new_length >= 3);
3389
3390         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3391         if (ascii_is_valid(s))
3392                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3393
3394         if (old_length <= 3 || old_length <= new_length)
3395                 return strndup(s, old_length);
3396
3397         x = (new_length * percent) / 100;
3398
3399         if (x > new_length - 3)
3400                 x = new_length - 3;
3401
3402         k = 0;
3403         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3404                 int c;
3405
3406                 c = utf8_encoded_to_unichar(i);
3407                 if (c < 0)
3408                         return NULL;
3409                 k += unichar_iswide(c) ? 2 : 1;
3410         }
3411
3412         if (k > x) /* last character was wide and went over quota */
3413                 x ++;
3414
3415         for (j = s + old_length; k < new_length && j > i; ) {
3416                 int c;
3417
3418                 j = utf8_prev_char(j);
3419                 c = utf8_encoded_to_unichar(j);
3420                 if (c < 0)
3421                         return NULL;
3422                 k += unichar_iswide(c) ? 2 : 1;
3423         }
3424         assert(i <= j);
3425
3426         /* we don't actually need to ellipsize */
3427         if (i == j)
3428                 return memdup(s, old_length + 1);
3429
3430         /* make space for ellipsis */
3431         j = utf8_next_char(j);
3432
3433         len = i - s;
3434         len2 = s + old_length - j;
3435         e = new(char, len + 3 + len2 + 1);
3436         if (!e)
3437                 return NULL;
3438
3439         /*
3440         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3441                old_length, new_length, x, len, len2, k);
3442         */
3443
3444         memcpy(e, s, len);
3445         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3446         e[len + 1] = 0x80;
3447         e[len + 2] = 0xa6;
3448
3449         memcpy(e + len + 3, j, len2 + 1);
3450
3451         return e;
3452 }
3453
3454 char *ellipsize(const char *s, size_t length, unsigned percent) {
3455         return ellipsize_mem(s, strlen(s), length, percent);
3456 }
3457
3458 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
3459         _cleanup_close_ int fd;
3460         int r;
3461
3462         assert(path);
3463
3464         if (parents)
3465                 mkdir_parents(path, 0755);
3466
3467         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3468         if (fd < 0)
3469                 return -errno;
3470
3471         if (mode > 0) {
3472                 r = fchmod(fd, mode);
3473                 if (r < 0)
3474                         return -errno;
3475         }
3476
3477         if (uid != (uid_t) -1 || gid != (gid_t) -1) {
3478                 r = fchown(fd, uid, gid);
3479                 if (r < 0)
3480                         return -errno;
3481         }
3482
3483         if (stamp != USEC_INFINITY) {
3484                 struct timespec ts[2];
3485
3486                 timespec_store(&ts[0], stamp);
3487                 ts[1] = ts[0];
3488                 r = futimens(fd, ts);
3489         } else
3490                 r = futimens(fd, NULL);
3491         if (r < 0)
3492                 return -errno;
3493
3494         return 0;
3495 }
3496
3497 int touch(const char *path) {
3498         return touch_file(path, false, USEC_INFINITY, (uid_t) -1, (gid_t) -1, 0);
3499 }
3500
3501 char *unquote(const char *s, const char* quotes) {
3502         size_t l;
3503         assert(s);
3504
3505         /* This is rather stupid, simply removes the heading and
3506          * trailing quotes if there is one. Doesn't care about
3507          * escaping or anything. We should make this smarter one
3508          * day...*/
3509
3510         l = strlen(s);
3511         if (l < 2)
3512                 return strdup(s);
3513
3514         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3515                 return strndup(s+1, l-2);
3516
3517         return strdup(s);
3518 }
3519
3520 char *normalize_env_assignment(const char *s) {
3521         _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3522         char *eq, *r;
3523
3524         eq = strchr(s, '=');
3525         if (!eq) {
3526                 char *t;
3527
3528                 r = strdup(s);
3529                 if (!r)
3530                         return NULL;
3531
3532                 t = strstrip(r);
3533                 if (t == r)
3534                         return r;
3535
3536                 memmove(r, t, strlen(t) + 1);
3537                 return r;
3538         }
3539
3540         name = strndup(s, eq - s);
3541         if (!name)
3542                 return NULL;
3543
3544         p = strdup(eq + 1);
3545         if (!p)
3546                 return NULL;
3547
3548         value = unquote(strstrip(p), QUOTES);
3549         if (!value)
3550                 return NULL;
3551
3552         if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3553                 r = NULL;
3554
3555         return r;
3556 }
3557
3558 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3559         siginfo_t dummy;
3560
3561         assert(pid >= 1);
3562
3563         if (!status)
3564                 status = &dummy;
3565
3566         for (;;) {
3567                 zero(*status);
3568
3569                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3570
3571                         if (errno == EINTR)
3572                                 continue;
3573
3574                         return -errno;
3575                 }
3576
3577                 return 0;
3578         }
3579 }
3580
3581 /*
3582  * Return values:
3583  * < 0 : wait_for_terminate() failed to get the state of the
3584  *       process, the process was terminated by a signal, or
3585  *       failed for an unknown reason.
3586  * >=0 : The process terminated normally, and its exit code is
3587  *       returned.
3588  *
3589  * That is, success is indicated by a return value of zero, and an
3590  * error is indicated by a non-zero value.
3591  */
3592 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3593         int r;
3594         siginfo_t status;
3595
3596         assert(name);
3597         assert(pid > 1);
3598
3599         r = wait_for_terminate(pid, &status);
3600         if (r < 0) {
3601                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3602                 return r;
3603         }
3604
3605         if (status.si_code == CLD_EXITED) {
3606                 if (status.si_status != 0) {
3607                         log_warning("%s failed with error code %i.", name, status.si_status);
3608                         return status.si_status;
3609                 }
3610
3611                 log_debug("%s succeeded.", name);
3612                 return 0;
3613
3614         } else if (status.si_code == CLD_KILLED ||
3615                    status.si_code == CLD_DUMPED) {
3616
3617                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3618                 return -EPROTO;
3619         }
3620
3621         log_warning("%s failed due to unknown reason.", name);
3622         return -EPROTO;
3623 }
3624
3625 noreturn void freeze(void) {
3626
3627         /* Make sure nobody waits for us on a socket anymore */
3628         close_all_fds(NULL, 0);
3629
3630         sync();
3631
3632         for (;;)
3633                 pause();
3634 }
3635
3636 bool null_or_empty(struct stat *st) {
3637         assert(st);
3638
3639         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3640                 return true;
3641
3642         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3643                 return true;
3644
3645         return false;
3646 }
3647
3648 int null_or_empty_path(const char *fn) {
3649         struct stat st;
3650
3651         assert(fn);
3652
3653         if (stat(fn, &st) < 0)
3654                 return -errno;
3655
3656         return null_or_empty(&st);
3657 }
3658
3659 int null_or_empty_fd(int fd) {
3660         struct stat st;
3661
3662         assert(fd >= 0);
3663
3664         if (fstat(fd, &st) < 0)
3665                 return -errno;
3666
3667         return null_or_empty(&st);
3668 }
3669
3670 DIR *xopendirat(int fd, const char *name, int flags) {
3671         int nfd;
3672         DIR *d;
3673
3674         assert(!(flags & O_CREAT));
3675
3676         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3677         if (nfd < 0)
3678                 return NULL;
3679
3680         d = fdopendir(nfd);
3681         if (!d) {
3682                 safe_close(nfd);
3683                 return NULL;
3684         }
3685
3686         return d;
3687 }
3688
3689 int signal_from_string_try_harder(const char *s) {
3690         int signo;
3691         assert(s);
3692
3693         signo = signal_from_string(s);
3694         if (signo <= 0)
3695                 if (startswith(s, "SIG"))
3696                         return signal_from_string(s+3);
3697
3698         return signo;
3699 }
3700
3701 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3702         _cleanup_free_ char *t = NULL, *u = NULL;
3703         size_t enc_len;
3704
3705         u = unquote(tagvalue, "\"\'");
3706         if (!u)
3707                 return NULL;
3708
3709         enc_len = strlen(u) * 4 + 1;
3710         t = new(char, enc_len);
3711         if (!t)
3712                 return NULL;
3713
3714         if (encode_devnode_name(u, t, enc_len) < 0)
3715                 return NULL;
3716
3717         return strjoin("/dev/disk/by-", by, "/", t, NULL);
3718 }
3719
3720 char *fstab_node_to_udev_node(const char *p) {
3721         assert(p);
3722
3723         if (startswith(p, "LABEL="))
3724                 return tag_to_udev_node(p+6, "label");
3725
3726         if (startswith(p, "UUID="))
3727                 return tag_to_udev_node(p+5, "uuid");
3728
3729         if (startswith(p, "PARTUUID="))
3730                 return tag_to_udev_node(p+9, "partuuid");
3731
3732         if (startswith(p, "PARTLABEL="))
3733                 return tag_to_udev_node(p+10, "partlabel");
3734
3735         return strdup(p);
3736 }
3737
3738 bool tty_is_vc(const char *tty) {
3739         assert(tty);
3740
3741         return vtnr_from_tty(tty) >= 0;
3742 }
3743
3744 bool tty_is_console(const char *tty) {
3745         assert(tty);
3746
3747         if (startswith(tty, "/dev/"))
3748                 tty += 5;
3749
3750         return streq(tty, "console");
3751 }
3752
3753 int vtnr_from_tty(const char *tty) {
3754         int i, r;
3755
3756         assert(tty);
3757
3758         if (startswith(tty, "/dev/"))
3759                 tty += 5;
3760
3761         if (!startswith(tty, "tty") )
3762                 return -EINVAL;
3763
3764         if (tty[3] < '0' || tty[3] > '9')
3765                 return -EINVAL;
3766
3767         r = safe_atoi(tty+3, &i);
3768         if (r < 0)
3769                 return r;
3770
3771         if (i < 0 || i > 63)
3772                 return -EINVAL;
3773
3774         return i;
3775 }
3776
3777 char *resolve_dev_console(char **active) {
3778         char *tty;
3779
3780         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3781          * (i.e. not read-only-mounted which is a sign for container setups) */
3782
3783         if (path_is_read_only_fs("/sys") > 0)
3784                 return NULL;
3785
3786         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3787                 return NULL;
3788
3789         /* If multiple log outputs are configured the last one is what
3790          * /dev/console points to */
3791         tty = strrchr(*active, ' ');
3792         if (tty)
3793                 tty++;
3794         else
3795                 tty = *active;
3796
3797         if (streq(tty, "tty0")) {
3798                 char *tmp;
3799
3800                 /* Get the active VC (e.g. tty1) */
3801                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3802                         free(*active);
3803                         tty = *active = tmp;
3804                 }
3805         }
3806
3807         return tty;
3808 }
3809
3810 bool tty_is_vc_resolve(const char *tty) {
3811         _cleanup_free_ char *active = NULL;
3812
3813         assert(tty);
3814
3815         if (startswith(tty, "/dev/"))
3816                 tty += 5;
3817
3818         if (streq(tty, "console")) {
3819                 tty = resolve_dev_console(&active);
3820                 if (!tty)
3821                         return false;
3822         }
3823
3824         return tty_is_vc(tty);
3825 }
3826
3827 const char *default_term_for_tty(const char *tty) {
3828         assert(tty);
3829
3830         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3831 }
3832
3833 bool dirent_is_file(const struct dirent *de) {
3834         assert(de);
3835
3836         if (ignore_file(de->d_name))
3837                 return false;
3838
3839         if (de->d_type != DT_REG &&
3840             de->d_type != DT_LNK &&
3841             de->d_type != DT_UNKNOWN)
3842                 return false;
3843
3844         return true;
3845 }
3846
3847 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3848         assert(de);
3849
3850         if (de->d_type != DT_REG &&
3851             de->d_type != DT_LNK &&
3852             de->d_type != DT_UNKNOWN)
3853                 return false;
3854
3855         if (ignore_file_allow_backup(de->d_name))
3856                 return false;
3857
3858         return endswith(de->d_name, suffix);
3859 }
3860
3861 void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {
3862         pid_t executor_pid;
3863         int r;
3864
3865         assert(directory);
3866
3867         /* Executes all binaries in a directory in parallel and waits
3868          * for them to finish. Optionally a timeout is applied. */
3869
3870         executor_pid = fork();
3871         if (executor_pid < 0) {
3872                 log_error("Failed to fork: %m");
3873                 return;
3874
3875         } else if (executor_pid == 0) {
3876                 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
3877                 _cleanup_closedir_ DIR *_d = NULL;
3878                 struct dirent *de;
3879                 sigset_t ss;
3880
3881                 /* We fork this all off from a child process so that
3882                  * we can somewhat cleanly make use of SIGALRM to set
3883                  * a time limit */
3884
3885                 reset_all_signal_handlers();
3886
3887                 assert_se(sigemptyset(&ss) == 0);
3888                 assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);
3889
3890                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3891
3892                 if (!d) {
3893                         d = _d = opendir(directory);
3894                         if (!d) {
3895                                 if (errno == ENOENT)
3896                                         _exit(EXIT_SUCCESS);
3897
3898                                 log_error("Failed to enumerate directory %s: %m", directory);
3899                                 _exit(EXIT_FAILURE);
3900                         }
3901                 }
3902
3903                 pids = hashmap_new(NULL, NULL);
3904                 if (!pids) {
3905                         log_oom();
3906                         _exit(EXIT_FAILURE);
3907                 }
3908
3909                 FOREACH_DIRENT(de, d, break) {
3910                         _cleanup_free_ char *path = NULL;
3911                         pid_t pid;
3912
3913                         if (!dirent_is_file(de))
3914                                 continue;
3915
3916                         path = strjoin(directory, "/", de->d_name, NULL);
3917                         if (!path) {
3918                                 log_oom();
3919                                 _exit(EXIT_FAILURE);
3920                         }
3921
3922                         pid = fork();
3923                         if (pid < 0) {
3924                                 log_error("Failed to fork: %m");
3925                                 continue;
3926                         } else if (pid == 0) {
3927                                 char *_argv[2];
3928
3929                                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3930
3931                                 if (!argv) {
3932                                         _argv[0] = path;
3933                                         _argv[1] = NULL;
3934                                         argv = _argv;
3935                                 } else
3936                                         argv[0] = path;
3937
3938                                 execv(path, argv);
3939                                 log_error("Failed to execute %s: %m", path);
3940                                 _exit(EXIT_FAILURE);
3941                         }
3942
3943
3944                         log_debug("Spawned %s as " PID_FMT ".", path, pid);
3945
3946                         r = hashmap_put(pids, UINT_TO_PTR(pid), path);
3947                         if (r < 0) {
3948                                 log_oom();
3949                                 _exit(EXIT_FAILURE);
3950                         }
3951
3952                         path = NULL;
3953                 }
3954
3955                 /* Abort execution of this process after the
3956                  * timout. We simply rely on SIGALRM as default action
3957                  * terminating the process, and turn on alarm(). */
3958