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