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