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