]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/shared/util.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
util: treat fuse.sshfs as a network filesystem
[thirdparty/systemd.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 bool first_word(const char *s, const char *word) {
144 size_t sl, wl;
145
146 assert(s);
147 assert(word);
148
149 sl = strlen(s);
150 wl = strlen(word);
151
152 if (sl < wl)
153 return false;
154
155 if (wl == 0)
156 return true;
157
158 if (memcmp(s, word, wl) != 0)
159 return false;
160
161 return s[wl] == 0 ||
162 strchr(WHITESPACE, s[wl]);
163 }
164
165 int close_nointr(int fd) {
166 int r;
167
168 assert(fd >= 0);
169 r = close(fd);
170 if (r >= 0)
171 return r;
172 else if (errno == EINTR)
173 /*
174 * Just ignore EINTR; a retry loop is the wrong
175 * thing to do on Linux.
176 *
177 * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
178 * https://bugzilla.gnome.org/show_bug.cgi?id=682819
179 * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
180 * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
181 */
182 return 0;
183 else
184 return -errno;
185 }
186
187 int safe_close(int fd) {
188
189 /*
190 * Like close_nointr() but cannot fail. Guarantees errno is
191 * unchanged. Is a NOP with negative fds passed, and returns
192 * -1, so that it can be used in this syntax:
193 *
194 * fd = safe_close(fd);
195 */
196
197 if (fd >= 0) {
198 PROTECT_ERRNO;
199
200 /* The kernel might return pretty much any error code
201 * via close(), but the fd will be closed anyway. The
202 * only condition we want to check for here is whether
203 * the fd was invalid at all... */
204
205 assert_se(close_nointr(fd) != -EBADF);
206 }
207
208 return -1;
209 }
210
211 void close_many(const int fds[], unsigned n_fd) {
212 unsigned i;
213
214 assert(fds || n_fd <= 0);
215
216 for (i = 0; i < n_fd; i++)
217 safe_close(fds[i]);
218 }
219
220 int unlink_noerrno(const char *path) {
221 PROTECT_ERRNO;
222 int r;
223
224 r = unlink(path);
225 if (r < 0)
226 return -errno;
227
228 return 0;
229 }
230
231 int parse_boolean(const char *v) {
232 assert(v);
233
234 if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || strcaseeq(v, "on"))
235 return 1;
236 else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || strcaseeq(v, "off"))
237 return 0;
238
239 return -EINVAL;
240 }
241
242 int parse_pid(const char *s, pid_t* ret_pid) {
243 unsigned long ul = 0;
244 pid_t pid;
245 int r;
246
247 assert(s);
248 assert(ret_pid);
249
250 r = safe_atolu(s, &ul);
251 if (r < 0)
252 return r;
253
254 pid = (pid_t) ul;
255
256 if ((unsigned long) pid != ul)
257 return -ERANGE;
258
259 if (pid <= 0)
260 return -ERANGE;
261
262 *ret_pid = pid;
263 return 0;
264 }
265
266 int parse_uid(const char *s, uid_t* ret_uid) {
267 unsigned long ul = 0;
268 uid_t uid;
269 int r;
270
271 assert(s);
272 assert(ret_uid);
273
274 r = safe_atolu(s, &ul);
275 if (r < 0)
276 return r;
277
278 uid = (uid_t) ul;
279
280 if ((unsigned long) uid != ul)
281 return -ERANGE;
282
283 *ret_uid = uid;
284 return 0;
285 }
286
287 int safe_atou(const char *s, unsigned *ret_u) {
288 char *x = NULL;
289 unsigned long l;
290
291 assert(s);
292 assert(ret_u);
293
294 errno = 0;
295 l = strtoul(s, &x, 0);
296
297 if (!x || x == s || *x || errno)
298 return errno > 0 ? -errno : -EINVAL;
299
300 if ((unsigned long) (unsigned) l != l)
301 return -ERANGE;
302
303 *ret_u = (unsigned) l;
304 return 0;
305 }
306
307 int safe_atoi(const char *s, int *ret_i) {
308 char *x = NULL;
309 long l;
310
311 assert(s);
312 assert(ret_i);
313
314 errno = 0;
315 l = strtol(s, &x, 0);
316
317 if (!x || x == s || *x || errno)
318 return errno > 0 ? -errno : -EINVAL;
319
320 if ((long) (int) l != l)
321 return -ERANGE;
322
323 *ret_i = (int) l;
324 return 0;
325 }
326
327 int safe_atollu(const char *s, long long unsigned *ret_llu) {
328 char *x = NULL;
329 unsigned long long l;
330
331 assert(s);
332 assert(ret_llu);
333
334 errno = 0;
335 l = strtoull(s, &x, 0);
336
337 if (!x || x == s || *x || errno)
338 return errno ? -errno : -EINVAL;
339
340 *ret_llu = l;
341 return 0;
342 }
343
344 int safe_atolli(const char *s, long long int *ret_lli) {
345 char *x = NULL;
346 long long l;
347
348 assert(s);
349 assert(ret_lli);
350
351 errno = 0;
352 l = strtoll(s, &x, 0);
353
354 if (!x || x == s || *x || errno)
355 return errno ? -errno : -EINVAL;
356
357 *ret_lli = l;
358 return 0;
359 }
360
361 int safe_atod(const char *s, double *ret_d) {
362 char *x = NULL;
363 double d = 0;
364
365 assert(s);
366 assert(ret_d);
367
368 RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
369 errno = 0;
370 d = strtod(s, &x);
371 }
372
373 if (!x || x == s || *x || errno)
374 return errno ? -errno : -EINVAL;
375
376 *ret_d = (double) d;
377 return 0;
378 }
379
380 static size_t strcspn_escaped(const char *s, const char *reject) {
381 bool escaped = false;
382 size_t n;
383
384 for (n=0; s[n]; n++) {
385 if (escaped)
386 escaped = false;
387 else if (s[n] == '\\')
388 escaped = true;
389 else if (strchr(reject, s[n]))
390 return n;
391 }
392 return n;
393 }
394
395 /* Split a string into words. */
396 char *split(const char *c, size_t *l, const char *separator, bool quoted, char **state) {
397 char *current;
398
399 current = *state ? *state : (char*) c;
400
401 if (!*current || *c == 0)
402 return NULL;
403
404 current += strspn(current, separator);
405 if (!*current)
406 return NULL;
407
408 if (quoted && strchr("\'\"", *current)) {
409 char quotechar = *(current++);
410 *l = strcspn_escaped(current, (char[]){quotechar, '\0'});
411 *state = current+*l+1;
412 } else if (quoted) {
413 *l = strcspn_escaped(current, separator);
414 *state = current+*l;
415 } else {
416 *l = strcspn(current, separator);
417 *state = current+*l;
418 }
419
420 return (char*) current;
421 }
422
423 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
424 int r;
425 _cleanup_free_ char *line = NULL;
426 long unsigned ppid;
427 const char *p;
428
429 assert(pid >= 0);
430 assert(_ppid);
431
432 if (pid == 0) {
433 *_ppid = getppid();
434 return 0;
435 }
436
437 p = procfs_file_alloca(pid, "stat");
438 r = read_one_line_file(p, &line);
439 if (r < 0)
440 return r;
441
442 /* Let's skip the pid and comm fields. The latter is enclosed
443 * in () but does not escape any () in its value, so let's
444 * skip over it manually */
445
446 p = strrchr(line, ')');
447 if (!p)
448 return -EIO;
449
450 p++;
451
452 if (sscanf(p, " "
453 "%*c " /* state */
454 "%lu ", /* ppid */
455 &ppid) != 1)
456 return -EIO;
457
458 if ((long unsigned) (pid_t) ppid != ppid)
459 return -ERANGE;
460
461 *_ppid = (pid_t) ppid;
462
463 return 0;
464 }
465
466 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
467 int r;
468 _cleanup_free_ char *line = NULL;
469 const char *p;
470
471 assert(pid >= 0);
472 assert(st);
473
474 p = procfs_file_alloca(pid, "stat");
475 r = read_one_line_file(p, &line);
476 if (r < 0)
477 return r;
478
479 /* Let's skip the pid and comm fields. The latter is enclosed
480 * in () but does not escape any () in its value, so let's
481 * skip over it manually */
482
483 p = strrchr(line, ')');
484 if (!p)
485 return -EIO;
486
487 p++;
488
489 if (sscanf(p, " "
490 "%*c " /* state */
491 "%*d " /* ppid */
492 "%*d " /* pgrp */
493 "%*d " /* session */
494 "%*d " /* tty_nr */
495 "%*d " /* tpgid */
496 "%*u " /* flags */
497 "%*u " /* minflt */
498 "%*u " /* cminflt */
499 "%*u " /* majflt */
500 "%*u " /* cmajflt */
501 "%*u " /* utime */
502 "%*u " /* stime */
503 "%*d " /* cutime */
504 "%*d " /* cstime */
505 "%*d " /* priority */
506 "%*d " /* nice */
507 "%*d " /* num_threads */
508 "%*d " /* itrealvalue */
509 "%llu " /* starttime */,
510 st) != 1)
511 return -EIO;
512
513 return 0;
514 }
515
516 int fchmod_umask(int fd, mode_t m) {
517 mode_t u;
518 int r;
519
520 u = umask(0777);
521 r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
522 umask(u);
523
524 return r;
525 }
526
527 char *truncate_nl(char *s) {
528 assert(s);
529
530 s[strcspn(s, NEWLINE)] = 0;
531 return s;
532 }
533
534 int get_process_state(pid_t pid) {
535 const char *p;
536 char state;
537 int r;
538 _cleanup_free_ char *line = NULL;
539
540 assert(pid >= 0);
541
542 p = procfs_file_alloca(pid, "stat");
543 r = read_one_line_file(p, &line);
544 if (r < 0)
545 return r;
546
547 p = strrchr(line, ')');
548 if (!p)
549 return -EIO;
550
551 p++;
552
553 if (sscanf(p, " %c", &state) != 1)
554 return -EIO;
555
556 return (unsigned char) state;
557 }
558
559 int get_process_comm(pid_t pid, char **name) {
560 const char *p;
561 int r;
562
563 assert(name);
564 assert(pid >= 0);
565
566 p = procfs_file_alloca(pid, "comm");
567
568 r = read_one_line_file(p, name);
569 if (r == -ENOENT)
570 return -ESRCH;
571
572 return r;
573 }
574
575 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
576 _cleanup_fclose_ FILE *f = NULL;
577 char *r = NULL, *k;
578 const char *p;
579 int c;
580
581 assert(line);
582 assert(pid >= 0);
583
584 p = procfs_file_alloca(pid, "cmdline");
585
586 f = fopen(p, "re");
587 if (!f)
588 return -errno;
589
590 if (max_length == 0) {
591 size_t len = 0, allocated = 0;
592
593 while ((c = getc(f)) != EOF) {
594
595 if (!GREEDY_REALLOC(r, allocated, len+2)) {
596 free(r);
597 return -ENOMEM;
598 }
599
600 r[len++] = isprint(c) ? c : ' ';
601 }
602
603 if (len > 0)
604 r[len-1] = 0;
605
606 } else {
607 bool space = false;
608 size_t left;
609
610 r = new(char, max_length);
611 if (!r)
612 return -ENOMEM;
613
614 k = r;
615 left = max_length;
616 while ((c = getc(f)) != EOF) {
617
618 if (isprint(c)) {
619 if (space) {
620 if (left <= 4)
621 break;
622
623 *(k++) = ' ';
624 left--;
625 space = false;
626 }
627
628 if (left <= 4)
629 break;
630
631 *(k++) = (char) c;
632 left--;
633 } else
634 space = true;
635 }
636
637 if (left <= 4) {
638 size_t n = MIN(left-1, 3U);
639 memcpy(k, "...", n);
640 k[n] = 0;
641 } else
642 *k = 0;
643 }
644
645 /* Kernel threads have no argv[] */
646 if (r == NULL || r[0] == 0) {
647 _cleanup_free_ char *t = NULL;
648 int h;
649
650 free(r);
651
652 if (!comm_fallback)
653 return -ENOENT;
654
655 h = get_process_comm(pid, &t);
656 if (h < 0)
657 return h;
658
659 r = strjoin("[", t, "]", NULL);
660 if (!r)
661 return -ENOMEM;
662 }
663
664 *line = r;
665 return 0;
666 }
667
668 int is_kernel_thread(pid_t pid) {
669 const char *p;
670 size_t count;
671 char c;
672 bool eof;
673 FILE *f;
674
675 if (pid == 0)
676 return 0;
677
678 assert(pid > 0);
679
680 p = procfs_file_alloca(pid, "cmdline");
681 f = fopen(p, "re");
682 if (!f)
683 return -errno;
684
685 count = fread(&c, 1, 1, f);
686 eof = feof(f);
687 fclose(f);
688
689 /* Kernel threads have an empty cmdline */
690
691 if (count <= 0)
692 return eof ? 1 : -errno;
693
694 return 0;
695 }
696
697 int get_process_capeff(pid_t pid, char **capeff) {
698 const char *p;
699
700 assert(capeff);
701 assert(pid >= 0);
702
703 p = procfs_file_alloca(pid, "status");
704
705 return get_status_field(p, "\nCapEff:", capeff);
706 }
707
708 int get_process_exe(pid_t pid, char **name) {
709 const char *p;
710 char *d;
711 int r;
712
713 assert(pid >= 0);
714 assert(name);
715
716 p = procfs_file_alloca(pid, "exe");
717
718 r = readlink_malloc(p, name);
719 if (r < 0)
720 return r == -ENOENT ? -ESRCH : r;
721
722 d = endswith(*name, " (deleted)");
723 if (d)
724 *d = '\0';
725
726 return 0;
727 }
728
729 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
730 _cleanup_fclose_ FILE *f = NULL;
731 char line[LINE_MAX];
732 const char *p;
733
734 assert(field);
735 assert(uid);
736
737 if (pid == 0)
738 return getuid();
739
740 p = procfs_file_alloca(pid, "status");
741 f = fopen(p, "re");
742 if (!f)
743 return -errno;
744
745 FOREACH_LINE(line, f, return -errno) {
746 char *l;
747
748 l = strstrip(line);
749
750 if (startswith(l, field)) {
751 l += strlen(field);
752 l += strspn(l, WHITESPACE);
753
754 l[strcspn(l, WHITESPACE)] = 0;
755
756 return parse_uid(l, uid);
757 }
758 }
759
760 return -EIO;
761 }
762
763 int get_process_uid(pid_t pid, uid_t *uid) {
764 return get_process_id(pid, "Uid:", uid);
765 }
766
767 int get_process_gid(pid_t pid, gid_t *gid) {
768 assert_cc(sizeof(uid_t) == sizeof(gid_t));
769 return get_process_id(pid, "Gid:", gid);
770 }
771
772 char *strnappend(const char *s, const char *suffix, size_t b) {
773 size_t a;
774 char *r;
775
776 if (!s && !suffix)
777 return strdup("");
778
779 if (!s)
780 return strndup(suffix, b);
781
782 if (!suffix)
783 return strdup(s);
784
785 assert(s);
786 assert(suffix);
787
788 a = strlen(s);
789 if (b > ((size_t) -1) - a)
790 return NULL;
791
792 r = new(char, a+b+1);
793 if (!r)
794 return NULL;
795
796 memcpy(r, s, a);
797 memcpy(r+a, suffix, b);
798 r[a+b] = 0;
799
800 return r;
801 }
802
803 char *strappend(const char *s, const char *suffix) {
804 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
805 }
806
807 int readlinkat_malloc(int fd, const char *p, char **ret) {
808 size_t l = 100;
809 int r;
810
811 assert(p);
812 assert(ret);
813
814 for (;;) {
815 char *c;
816 ssize_t n;
817
818 c = new(char, l);
819 if (!c)
820 return -ENOMEM;
821
822 n = readlinkat(fd, p, c, l-1);
823 if (n < 0) {
824 r = -errno;
825 free(c);
826 return r;
827 }
828
829 if ((size_t) n < l-1) {
830 c[n] = 0;
831 *ret = c;
832 return 0;
833 }
834
835 free(c);
836 l *= 2;
837 }
838 }
839
840 int readlink_malloc(const char *p, char **ret) {
841 return readlinkat_malloc(AT_FDCWD, p, ret);
842 }
843
844 int readlink_and_make_absolute(const char *p, char **r) {
845 _cleanup_free_ char *target = NULL;
846 char *k;
847 int j;
848
849 assert(p);
850 assert(r);
851
852 j = readlink_malloc(p, &target);
853 if (j < 0)
854 return j;
855
856 k = file_in_same_dir(p, target);
857 if (!k)
858 return -ENOMEM;
859
860 *r = k;
861 return 0;
862 }
863
864 int readlink_and_canonicalize(const char *p, char **r) {
865 char *t, *s;
866 int j;
867
868 assert(p);
869 assert(r);
870
871 j = readlink_and_make_absolute(p, &t);
872 if (j < 0)
873 return j;
874
875 s = canonicalize_file_name(t);
876 if (s) {
877 free(t);
878 *r = s;
879 } else
880 *r = t;
881
882 path_kill_slashes(*r);
883
884 return 0;
885 }
886
887 int reset_all_signal_handlers(void) {
888 int sig;
889
890 for (sig = 1; sig < _NSIG; sig++) {
891 struct sigaction sa = {
892 .sa_handler = SIG_DFL,
893 .sa_flags = SA_RESTART,
894 };
895
896 if (sig == SIGKILL || sig == SIGSTOP)
897 continue;
898
899 /* On Linux the first two RT signals are reserved by
900 * glibc, and sigaction() will return EINVAL for them. */
901 if ((sigaction(sig, &sa, NULL) < 0))
902 if (errno != EINVAL)
903 return -errno;
904 }
905
906 return 0;
907 }
908
909 char *strstrip(char *s) {
910 char *e;
911
912 /* Drops trailing whitespace. Modifies the string in
913 * place. Returns pointer to first non-space character */
914
915 s += strspn(s, WHITESPACE);
916
917 for (e = strchr(s, 0); e > s; e --)
918 if (!strchr(WHITESPACE, e[-1]))
919 break;
920
921 *e = 0;
922
923 return s;
924 }
925
926 char *delete_chars(char *s, const char *bad) {
927 char *f, *t;
928
929 /* Drops all whitespace, regardless where in the string */
930
931 for (f = s, t = s; *f; f++) {
932 if (strchr(bad, *f))
933 continue;
934
935 *(t++) = *f;
936 }
937
938 *t = 0;
939
940 return s;
941 }
942
943 char *file_in_same_dir(const char *path, const char *filename) {
944 char *e, *r;
945 size_t k;
946
947 assert(path);
948 assert(filename);
949
950 /* This removes the last component of path and appends
951 * filename, unless the latter is absolute anyway or the
952 * former isn't */
953
954 if (path_is_absolute(filename))
955 return strdup(filename);
956
957 if (!(e = strrchr(path, '/')))
958 return strdup(filename);
959
960 k = strlen(filename);
961 if (!(r = new(char, e-path+1+k+1)))
962 return NULL;
963
964 memcpy(r, path, e-path+1);
965 memcpy(r+(e-path)+1, filename, k+1);
966
967 return r;
968 }
969
970 int rmdir_parents(const char *path, const char *stop) {
971 size_t l;
972 int r = 0;
973
974 assert(path);
975 assert(stop);
976
977 l = strlen(path);
978
979 /* Skip trailing slashes */
980 while (l > 0 && path[l-1] == '/')
981 l--;
982
983 while (l > 0) {
984 char *t;
985
986 /* Skip last component */
987 while (l > 0 && path[l-1] != '/')
988 l--;
989
990 /* Skip trailing slashes */
991 while (l > 0 && path[l-1] == '/')
992 l--;
993
994 if (l <= 0)
995 break;
996
997 if (!(t = strndup(path, l)))
998 return -ENOMEM;
999
1000 if (path_startswith(stop, t)) {
1001 free(t);
1002 return 0;
1003 }
1004
1005 r = rmdir(t);
1006 free(t);
1007
1008 if (r < 0)
1009 if (errno != ENOENT)
1010 return -errno;
1011 }
1012
1013 return 0;
1014 }
1015
1016 char hexchar(int x) {
1017 static const char table[16] = "0123456789abcdef";
1018
1019 return table[x & 15];
1020 }
1021
1022 int unhexchar(char c) {
1023
1024 if (c >= '0' && c <= '9')
1025 return c - '0';
1026
1027 if (c >= 'a' && c <= 'f')
1028 return c - 'a' + 10;
1029
1030 if (c >= 'A' && c <= 'F')
1031 return c - 'A' + 10;
1032
1033 return -1;
1034 }
1035
1036 char *hexmem(const void *p, size_t l) {
1037 char *r, *z;
1038 const uint8_t *x;
1039
1040 z = r = malloc(l * 2 + 1);
1041 if (!r)
1042 return NULL;
1043
1044 for (x = p; x < (const uint8_t*) p + l; x++) {
1045 *(z++) = hexchar(*x >> 4);
1046 *(z++) = hexchar(*x & 15);
1047 }
1048
1049 *z = 0;
1050 return r;
1051 }
1052
1053 void *unhexmem(const char *p, size_t l) {
1054 uint8_t *r, *z;
1055 const char *x;
1056
1057 assert(p);
1058
1059 z = r = malloc((l + 1) / 2 + 1);
1060 if (!r)
1061 return NULL;
1062
1063 for (x = p; x < p + l; x += 2) {
1064 int a, b;
1065
1066 a = unhexchar(x[0]);
1067 if (x+1 < p + l)
1068 b = unhexchar(x[1]);
1069 else
1070 b = 0;
1071
1072 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1073 }
1074
1075 *z = 0;
1076 return r;
1077 }
1078
1079 char octchar(int x) {
1080 return '0' + (x & 7);
1081 }
1082
1083 int unoctchar(char c) {
1084
1085 if (c >= '0' && c <= '7')
1086 return c - '0';
1087
1088 return -1;
1089 }
1090
1091 char decchar(int x) {
1092 return '0' + (x % 10);
1093 }
1094
1095 int undecchar(char c) {
1096
1097 if (c >= '0' && c <= '9')
1098 return c - '0';
1099
1100 return -1;
1101 }
1102
1103 char *cescape(const char *s) {
1104 char *r, *t;
1105 const char *f;
1106
1107 assert(s);
1108
1109 /* Does C style string escaping. */
1110
1111 r = new(char, strlen(s)*4 + 1);
1112 if (!r)
1113 return NULL;
1114
1115 for (f = s, t = r; *f; f++)
1116
1117 switch (*f) {
1118
1119 case '\a':
1120 *(t++) = '\\';
1121 *(t++) = 'a';
1122 break;
1123 case '\b':
1124 *(t++) = '\\';
1125 *(t++) = 'b';
1126 break;
1127 case '\f':
1128 *(t++) = '\\';
1129 *(t++) = 'f';
1130 break;
1131 case '\n':
1132 *(t++) = '\\';
1133 *(t++) = 'n';
1134 break;
1135 case '\r':
1136 *(t++) = '\\';
1137 *(t++) = 'r';
1138 break;
1139 case '\t':
1140 *(t++) = '\\';
1141 *(t++) = 't';
1142 break;
1143 case '\v':
1144 *(t++) = '\\';
1145 *(t++) = 'v';
1146 break;
1147 case '\\':
1148 *(t++) = '\\';
1149 *(t++) = '\\';
1150 break;
1151 case '"':
1152 *(t++) = '\\';
1153 *(t++) = '"';
1154 break;
1155 case '\'':
1156 *(t++) = '\\';
1157 *(t++) = '\'';
1158 break;
1159
1160 default:
1161 /* For special chars we prefer octal over
1162 * hexadecimal encoding, simply because glib's
1163 * g_strescape() does the same */
1164 if ((*f < ' ') || (*f >= 127)) {
1165 *(t++) = '\\';
1166 *(t++) = octchar((unsigned char) *f >> 6);
1167 *(t++) = octchar((unsigned char) *f >> 3);
1168 *(t++) = octchar((unsigned char) *f);
1169 } else
1170 *(t++) = *f;
1171 break;
1172 }
1173
1174 *t = 0;
1175
1176 return r;
1177 }
1178
1179 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1180 char *r, *t;
1181 const char *f;
1182 size_t pl;
1183
1184 assert(s);
1185
1186 /* Undoes C style string escaping, and optionally prefixes it. */
1187
1188 pl = prefix ? strlen(prefix) : 0;
1189
1190 r = new(char, pl+length+1);
1191 if (!r)
1192 return r;
1193
1194 if (prefix)
1195 memcpy(r, prefix, pl);
1196
1197 for (f = s, t = r + pl; f < s + length; f++) {
1198
1199 if (*f != '\\') {
1200 *(t++) = *f;
1201 continue;
1202 }
1203
1204 f++;
1205
1206 switch (*f) {
1207
1208 case 'a':
1209 *(t++) = '\a';
1210 break;
1211 case 'b':
1212 *(t++) = '\b';
1213 break;
1214 case 'f':
1215 *(t++) = '\f';
1216 break;
1217 case 'n':
1218 *(t++) = '\n';
1219 break;
1220 case 'r':
1221 *(t++) = '\r';
1222 break;
1223 case 't':
1224 *(t++) = '\t';
1225 break;
1226 case 'v':
1227 *(t++) = '\v';
1228 break;
1229 case '\\':
1230 *(t++) = '\\';
1231 break;
1232 case '"':
1233 *(t++) = '"';
1234 break;
1235 case '\'':
1236 *(t++) = '\'';
1237 break;
1238
1239 case 's':
1240 /* This is an extension of the XDG syntax files */
1241 *(t++) = ' ';
1242 break;
1243
1244 case 'x': {
1245 /* hexadecimal encoding */
1246 int a, b;
1247
1248 a = unhexchar(f[1]);
1249 b = unhexchar(f[2]);
1250
1251 if (a < 0 || b < 0) {
1252 /* Invalid escape code, let's take it literal then */
1253 *(t++) = '\\';
1254 *(t++) = 'x';
1255 } else {
1256 *(t++) = (char) ((a << 4) | b);
1257 f += 2;
1258 }
1259
1260 break;
1261 }
1262
1263 case '0':
1264 case '1':
1265 case '2':
1266 case '3':
1267 case '4':
1268 case '5':
1269 case '6':
1270 case '7': {
1271 /* octal encoding */
1272 int a, b, c;
1273
1274 a = unoctchar(f[0]);
1275 b = unoctchar(f[1]);
1276 c = unoctchar(f[2]);
1277
1278 if (a < 0 || b < 0 || c < 0) {
1279 /* Invalid escape code, let's take it literal then */
1280 *(t++) = '\\';
1281 *(t++) = f[0];
1282 } else {
1283 *(t++) = (char) ((a << 6) | (b << 3) | c);
1284 f += 2;
1285 }
1286
1287 break;
1288 }
1289
1290 case 0:
1291 /* premature end of string.*/
1292 *(t++) = '\\';
1293 goto finish;
1294
1295 default:
1296 /* Invalid escape code, let's take it literal then */
1297 *(t++) = '\\';
1298 *(t++) = *f;
1299 break;
1300 }
1301 }
1302
1303 finish:
1304 *t = 0;
1305 return r;
1306 }
1307
1308 char *cunescape_length(const char *s, size_t length) {
1309 return cunescape_length_with_prefix(s, length, NULL);
1310 }
1311
1312 char *cunescape(const char *s) {
1313 assert(s);
1314
1315 return cunescape_length(s, strlen(s));
1316 }
1317
1318 char *xescape(const char *s, const char *bad) {
1319 char *r, *t;
1320 const char *f;
1321
1322 /* Escapes all chars in bad, in addition to \ and all special
1323 * chars, in \xFF style escaping. May be reversed with
1324 * cunescape. */
1325
1326 r = new(char, strlen(s) * 4 + 1);
1327 if (!r)
1328 return NULL;
1329
1330 for (f = s, t = r; *f; f++) {
1331
1332 if ((*f < ' ') || (*f >= 127) ||
1333 (*f == '\\') || strchr(bad, *f)) {
1334 *(t++) = '\\';
1335 *(t++) = 'x';
1336 *(t++) = hexchar(*f >> 4);
1337 *(t++) = hexchar(*f);
1338 } else
1339 *(t++) = *f;
1340 }
1341
1342 *t = 0;
1343
1344 return r;
1345 }
1346
1347 char *ascii_strlower(char *t) {
1348 char *p;
1349
1350 assert(t);
1351
1352 for (p = t; *p; p++)
1353 if (*p >= 'A' && *p <= 'Z')
1354 *p = *p - 'A' + 'a';
1355
1356 return t;
1357 }
1358
1359 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1360 assert(filename);
1361
1362 return
1363 filename[0] == '.' ||
1364 streq(filename, "lost+found") ||
1365 streq(filename, "aquota.user") ||
1366 streq(filename, "aquota.group") ||
1367 endswith(filename, ".rpmnew") ||
1368 endswith(filename, ".rpmsave") ||
1369 endswith(filename, ".rpmorig") ||
1370 endswith(filename, ".dpkg-old") ||
1371 endswith(filename, ".dpkg-new") ||
1372 endswith(filename, ".swp");
1373 }
1374
1375 bool ignore_file(const char *filename) {
1376 assert(filename);
1377
1378 if (endswith(filename, "~"))
1379 return true;
1380
1381 return ignore_file_allow_backup(filename);
1382 }
1383
1384 int fd_nonblock(int fd, bool nonblock) {
1385 int flags, nflags;
1386
1387 assert(fd >= 0);
1388
1389 flags = fcntl(fd, F_GETFL, 0);
1390 if (flags < 0)
1391 return -errno;
1392
1393 if (nonblock)
1394 nflags = flags | O_NONBLOCK;
1395 else
1396 nflags = flags & ~O_NONBLOCK;
1397
1398 if (nflags == flags)
1399 return 0;
1400
1401 if (fcntl(fd, F_SETFL, nflags) < 0)
1402 return -errno;
1403
1404 return 0;
1405 }
1406
1407 int fd_cloexec(int fd, bool cloexec) {
1408 int flags, nflags;
1409
1410 assert(fd >= 0);
1411
1412 flags = fcntl(fd, F_GETFD, 0);
1413 if (flags < 0)
1414 return -errno;
1415
1416 if (cloexec)
1417 nflags = flags | FD_CLOEXEC;
1418 else
1419 nflags = flags & ~FD_CLOEXEC;
1420
1421 if (nflags == flags)
1422 return 0;
1423
1424 if (fcntl(fd, F_SETFD, nflags) < 0)
1425 return -errno;
1426
1427 return 0;
1428 }
1429
1430 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1431 unsigned i;
1432
1433 assert(n_fdset == 0 || fdset);
1434
1435 for (i = 0; i < n_fdset; i++)
1436 if (fdset[i] == fd)
1437 return true;
1438
1439 return false;
1440 }
1441
1442 int close_all_fds(const int except[], unsigned n_except) {
1443 DIR *d;
1444 struct dirent *de;
1445 int r = 0;
1446
1447 assert(n_except == 0 || except);
1448
1449 d = opendir("/proc/self/fd");
1450 if (!d) {
1451 int fd;
1452 struct rlimit rl;
1453
1454 /* When /proc isn't available (for example in chroots)
1455 * the fallback is brute forcing through the fd
1456 * table */
1457
1458 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1459 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1460
1461 if (fd_in_set(fd, except, n_except))
1462 continue;
1463
1464 if (close_nointr(fd) < 0)
1465 if (errno != EBADF && r == 0)
1466 r = -errno;
1467 }
1468
1469 return r;
1470 }
1471
1472 while ((de = readdir(d))) {
1473 int fd = -1;
1474
1475 if (ignore_file(de->d_name))
1476 continue;
1477
1478 if (safe_atoi(de->d_name, &fd) < 0)
1479 /* Let's better ignore this, just in case */
1480 continue;
1481
1482 if (fd < 3)
1483 continue;
1484
1485 if (fd == dirfd(d))
1486 continue;
1487
1488 if (fd_in_set(fd, except, n_except))
1489 continue;
1490
1491 if (close_nointr(fd) < 0) {
1492 /* Valgrind has its own FD and doesn't want to have it closed */
1493 if (errno != EBADF && r == 0)
1494 r = -errno;
1495 }
1496 }
1497
1498 closedir(d);
1499 return r;
1500 }
1501
1502 bool chars_intersect(const char *a, const char *b) {
1503 const char *p;
1504
1505 /* Returns true if any of the chars in a are in b. */
1506 for (p = a; *p; p++)
1507 if (strchr(b, *p))
1508 return true;
1509
1510 return false;
1511 }
1512
1513 bool fstype_is_network(const char *fstype) {
1514 static const char table[] =
1515 "cifs\0"
1516 "smbfs\0"
1517 "sshfs\0"
1518 "ncpfs\0"
1519 "ncp\0"
1520 "nfs\0"
1521 "nfs4\0"
1522 "gfs\0"
1523 "gfs2\0"
1524 "glusterfs\0";
1525
1526 const char *x;
1527
1528 x = startswith(fstype, "fuse.");
1529 if (x)
1530 fstype = x;
1531
1532 return nulstr_contains(table, fstype);
1533 }
1534
1535 int chvt(int vt) {
1536 _cleanup_close_ int fd;
1537
1538 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1539 if (fd < 0)
1540 return -errno;
1541
1542 if (vt < 0) {
1543 int tiocl[2] = {
1544 TIOCL_GETKMSGREDIRECT,
1545 0
1546 };
1547
1548 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1549 return -errno;
1550
1551 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1552 }
1553
1554 if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1555 return -errno;
1556
1557 return 0;
1558 }
1559
1560 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1561 struct termios old_termios, new_termios;
1562 char c;
1563 char line[LINE_MAX];
1564
1565 assert(f);
1566 assert(ret);
1567
1568 if (tcgetattr(fileno(f), &old_termios) >= 0) {
1569 new_termios = old_termios;
1570
1571 new_termios.c_lflag &= ~ICANON;
1572 new_termios.c_cc[VMIN] = 1;
1573 new_termios.c_cc[VTIME] = 0;
1574
1575 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1576 size_t k;
1577
1578 if (t != (usec_t) -1) {
1579 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1580 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1581 return -ETIMEDOUT;
1582 }
1583 }
1584
1585 k = fread(&c, 1, 1, f);
1586
1587 tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1588
1589 if (k <= 0)
1590 return -EIO;
1591
1592 if (need_nl)
1593 *need_nl = c != '\n';
1594
1595 *ret = c;
1596 return 0;
1597 }
1598 }
1599
1600 if (t != (usec_t) -1)
1601 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1602 return -ETIMEDOUT;
1603
1604 if (!fgets(line, sizeof(line), f))
1605 return -EIO;
1606
1607 truncate_nl(line);
1608
1609 if (strlen(line) != 1)
1610 return -EBADMSG;
1611
1612 if (need_nl)
1613 *need_nl = false;
1614
1615 *ret = line[0];
1616 return 0;
1617 }
1618
1619 int ask(char *ret, const char *replies, const char *text, ...) {
1620
1621 assert(ret);
1622 assert(replies);
1623 assert(text);
1624
1625 for (;;) {
1626 va_list ap;
1627 char c;
1628 int r;
1629 bool need_nl = true;
1630
1631 if (on_tty())
1632 fputs(ANSI_HIGHLIGHT_ON, stdout);
1633
1634 va_start(ap, text);
1635 vprintf(text, ap);
1636 va_end(ap);
1637
1638 if (on_tty())
1639 fputs(ANSI_HIGHLIGHT_OFF, stdout);
1640
1641 fflush(stdout);
1642
1643 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
1644 if (r < 0) {
1645
1646 if (r == -EBADMSG) {
1647 puts("Bad input, please try again.");
1648 continue;
1649 }
1650
1651 putchar('\n');
1652 return r;
1653 }
1654
1655 if (need_nl)
1656 putchar('\n');
1657
1658 if (strchr(replies, c)) {
1659 *ret = c;
1660 return 0;
1661 }
1662
1663 puts("Read unexpected character, please try again.");
1664 }
1665 }
1666
1667 int reset_terminal_fd(int fd, bool switch_to_text) {
1668 struct termios termios;
1669 int r = 0;
1670
1671 /* Set terminal to some sane defaults */
1672
1673 assert(fd >= 0);
1674
1675 /* We leave locked terminal attributes untouched, so that
1676 * Plymouth may set whatever it wants to set, and we don't
1677 * interfere with that. */
1678
1679 /* Disable exclusive mode, just in case */
1680 ioctl(fd, TIOCNXCL);
1681
1682 /* Switch to text mode */
1683 if (switch_to_text)
1684 ioctl(fd, KDSETMODE, KD_TEXT);
1685
1686 /* Enable console unicode mode */
1687 ioctl(fd, KDSKBMODE, K_UNICODE);
1688
1689 if (tcgetattr(fd, &termios) < 0) {
1690 r = -errno;
1691 goto finish;
1692 }
1693
1694 /* We only reset the stuff that matters to the software. How
1695 * hardware is set up we don't touch assuming that somebody
1696 * else will do that for us */
1697
1698 termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1699 termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1700 termios.c_oflag |= ONLCR;
1701 termios.c_cflag |= CREAD;
1702 termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1703
1704 termios.c_cc[VINTR] = 03; /* ^C */
1705 termios.c_cc[VQUIT] = 034; /* ^\ */
1706 termios.c_cc[VERASE] = 0177;
1707 termios.c_cc[VKILL] = 025; /* ^X */
1708 termios.c_cc[VEOF] = 04; /* ^D */
1709 termios.c_cc[VSTART] = 021; /* ^Q */
1710 termios.c_cc[VSTOP] = 023; /* ^S */
1711 termios.c_cc[VSUSP] = 032; /* ^Z */
1712 termios.c_cc[VLNEXT] = 026; /* ^V */
1713 termios.c_cc[VWERASE] = 027; /* ^W */
1714 termios.c_cc[VREPRINT] = 022; /* ^R */
1715 termios.c_cc[VEOL] = 0;
1716 termios.c_cc[VEOL2] = 0;
1717
1718 termios.c_cc[VTIME] = 0;
1719 termios.c_cc[VMIN] = 1;
1720
1721 if (tcsetattr(fd, TCSANOW, &termios) < 0)
1722 r = -errno;
1723
1724 finish:
1725 /* Just in case, flush all crap out */
1726 tcflush(fd, TCIOFLUSH);
1727
1728 return r;
1729 }
1730
1731 int reset_terminal(const char *name) {
1732 _cleanup_close_ int fd = -1;
1733
1734 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1735 if (fd < 0)
1736 return fd;
1737
1738 return reset_terminal_fd(fd, true);
1739 }
1740
1741 int open_terminal(const char *name, int mode) {
1742 int fd, r;
1743 unsigned c = 0;
1744
1745 /*
1746 * If a TTY is in the process of being closed opening it might
1747 * cause EIO. This is horribly awful, but unlikely to be
1748 * changed in the kernel. Hence we work around this problem by
1749 * retrying a couple of times.
1750 *
1751 * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1752 */
1753
1754 assert(!(mode & O_CREAT));
1755
1756 for (;;) {
1757 fd = open(name, mode, 0);
1758 if (fd >= 0)
1759 break;
1760
1761 if (errno != EIO)
1762 return -errno;
1763
1764 /* Max 1s in total */
1765 if (c >= 20)
1766 return -errno;
1767
1768 usleep(50 * USEC_PER_MSEC);
1769 c++;
1770 }
1771
1772 if (fd < 0)
1773 return -errno;
1774
1775 r = isatty(fd);
1776 if (r < 0) {
1777 safe_close(fd);
1778 return -errno;
1779 }
1780
1781 if (!r) {
1782 safe_close(fd);
1783 return -ENOTTY;
1784 }
1785
1786 return fd;
1787 }
1788
1789 int flush_fd(int fd) {
1790 struct pollfd pollfd = {
1791 .fd = fd,
1792 .events = POLLIN,
1793 };
1794
1795 for (;;) {
1796 char buf[LINE_MAX];
1797 ssize_t l;
1798 int r;
1799
1800 r = poll(&pollfd, 1, 0);
1801 if (r < 0) {
1802 if (errno == EINTR)
1803 continue;
1804
1805 return -errno;
1806
1807 } else if (r == 0)
1808 return 0;
1809
1810 l = read(fd, buf, sizeof(buf));
1811 if (l < 0) {
1812
1813 if (errno == EINTR)
1814 continue;
1815
1816 if (errno == EAGAIN)
1817 return 0;
1818
1819 return -errno;
1820 } else if (l == 0)
1821 return 0;
1822 }
1823 }
1824
1825 int acquire_terminal(
1826 const char *name,
1827 bool fail,
1828 bool force,
1829 bool ignore_tiocstty_eperm,
1830 usec_t timeout) {
1831
1832 int fd = -1, notify = -1, r = 0, wd = -1;
1833 usec_t ts = 0;
1834
1835 assert(name);
1836
1837 /* We use inotify to be notified when the tty is closed. We
1838 * create the watch before checking if we can actually acquire
1839 * it, so that we don't lose any event.
1840 *
1841 * Note: strictly speaking this actually watches for the
1842 * device being closed, it does *not* really watch whether a
1843 * tty loses its controlling process. However, unless some
1844 * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1845 * its tty otherwise this will not become a problem. As long
1846 * as the administrator makes sure not configure any service
1847 * on the same tty as an untrusted user this should not be a
1848 * problem. (Which he probably should not do anyway.) */
1849
1850 if (timeout != (usec_t) -1)
1851 ts = now(CLOCK_MONOTONIC);
1852
1853 if (!fail && !force) {
1854 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
1855 if (notify < 0) {
1856 r = -errno;
1857 goto fail;
1858 }
1859
1860 wd = inotify_add_watch(notify, name, IN_CLOSE);
1861 if (wd < 0) {
1862 r = -errno;
1863 goto fail;
1864 }
1865 }
1866
1867 for (;;) {
1868 struct sigaction sa_old, sa_new = {
1869 .sa_handler = SIG_IGN,
1870 .sa_flags = SA_RESTART,
1871 };
1872
1873 if (notify >= 0) {
1874 r = flush_fd(notify);
1875 if (r < 0)
1876 goto fail;
1877 }
1878
1879 /* We pass here O_NOCTTY only so that we can check the return
1880 * value TIOCSCTTY and have a reliable way to figure out if we
1881 * successfully became the controlling process of the tty */
1882 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1883 if (fd < 0)
1884 return fd;
1885
1886 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1887 * if we already own the tty. */
1888 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1889
1890 /* First, try to get the tty */
1891 if (ioctl(fd, TIOCSCTTY, force) < 0)
1892 r = -errno;
1893
1894 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1895
1896 /* Sometimes it makes sense to ignore TIOCSCTTY
1897 * returning EPERM, i.e. when very likely we already
1898 * are have this controlling terminal. */
1899 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1900 r = 0;
1901
1902 if (r < 0 && (force || fail || r != -EPERM)) {
1903 goto fail;
1904 }
1905
1906 if (r >= 0)
1907 break;
1908
1909 assert(!fail);
1910 assert(!force);
1911 assert(notify >= 0);
1912
1913 for (;;) {
1914 uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1915 ssize_t l;
1916 struct inotify_event *e;
1917
1918 if (timeout != (usec_t) -1) {
1919 usec_t n;
1920
1921 n = now(CLOCK_MONOTONIC);
1922 if (ts + timeout < n) {
1923 r = -ETIMEDOUT;
1924 goto fail;
1925 }
1926
1927 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
1928 if (r < 0)
1929 goto fail;
1930
1931 if (r == 0) {
1932 r = -ETIMEDOUT;
1933 goto fail;
1934 }
1935 }
1936
1937 l = read(notify, inotify_buffer, sizeof(inotify_buffer));
1938 if (l < 0) {
1939
1940 if (errno == EINTR || errno == EAGAIN)
1941 continue;
1942
1943 r = -errno;
1944 goto fail;
1945 }
1946
1947 e = (struct inotify_event*) inotify_buffer;
1948
1949 while (l > 0) {
1950 size_t step;
1951
1952 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
1953 r = -EIO;
1954 goto fail;
1955 }
1956
1957 step = sizeof(struct inotify_event) + e->len;
1958 assert(step <= (size_t) l);
1959
1960 e = (struct inotify_event*) ((uint8_t*) e + step);
1961 l -= step;
1962 }
1963
1964 break;
1965 }
1966
1967 /* We close the tty fd here since if the old session
1968 * ended our handle will be dead. It's important that
1969 * we do this after sleeping, so that we don't enter
1970 * an endless loop. */
1971 safe_close(fd);
1972 }
1973
1974 safe_close(notify);
1975
1976 r = reset_terminal_fd(fd, true);
1977 if (r < 0)
1978 log_warning("Failed to reset terminal: %s", strerror(-r));
1979
1980 return fd;
1981
1982 fail:
1983 safe_close(fd);
1984 safe_close(notify);
1985
1986 return r;
1987 }
1988
1989 int release_terminal(void) {
1990 int r = 0;
1991 struct sigaction sa_old, sa_new = {
1992 .sa_handler = SIG_IGN,
1993 .sa_flags = SA_RESTART,
1994 };
1995 _cleanup_close_ int fd;
1996
1997 fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
1998 if (fd < 0)
1999 return -errno;
2000
2001 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2002 * by our own TIOCNOTTY */
2003 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2004
2005 if (ioctl(fd, TIOCNOTTY) < 0)
2006 r = -errno;
2007
2008 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2009
2010 return r;
2011 }
2012
2013 int sigaction_many(const struct sigaction *sa, ...) {
2014 va_list ap;
2015 int r = 0, sig;
2016
2017 va_start(ap, sa);
2018 while ((sig = va_arg(ap, int)) > 0)
2019 if (sigaction(sig, sa, NULL) < 0)
2020 r = -errno;
2021 va_end(ap);
2022
2023 return r;
2024 }
2025
2026 int ignore_signals(int sig, ...) {
2027 struct sigaction sa = {
2028 .sa_handler = SIG_IGN,
2029 .sa_flags = SA_RESTART,
2030 };
2031 va_list ap;
2032 int r = 0;
2033
2034 if (sigaction(sig, &sa, NULL) < 0)
2035 r = -errno;
2036
2037 va_start(ap, sig);
2038 while ((sig = va_arg(ap, int)) > 0)
2039 if (sigaction(sig, &sa, NULL) < 0)
2040 r = -errno;
2041 va_end(ap);
2042
2043 return r;
2044 }
2045
2046 int default_signals(int sig, ...) {
2047 struct sigaction sa = {
2048 .sa_handler = SIG_DFL,
2049 .sa_flags = SA_RESTART,
2050 };
2051 va_list ap;
2052 int r = 0;
2053
2054 if (sigaction(sig, &sa, NULL) < 0)
2055 r = -errno;
2056
2057 va_start(ap, sig);
2058 while ((sig = va_arg(ap, int)) > 0)
2059 if (sigaction(sig, &sa, NULL) < 0)
2060 r = -errno;
2061 va_end(ap);
2062
2063 return r;
2064 }
2065
2066 void safe_close_pair(int p[]) {
2067 assert(p);
2068
2069 if (p[0] == p[1]) {
2070 /* Special case pairs which use the same fd in both
2071 * directions... */
2072 p[0] = p[1] = safe_close(p[0]);
2073 return;
2074 }
2075
2076 p[0] = safe_close(p[0]);
2077 p[1] = safe_close(p[1]);
2078 }
2079
2080 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2081 uint8_t *p = buf;
2082 ssize_t n = 0;
2083
2084 assert(fd >= 0);
2085 assert(buf);
2086
2087 while (nbytes > 0) {
2088 ssize_t k;
2089
2090 k = read(fd, p, nbytes);
2091 if (k < 0 && errno == EINTR)
2092 continue;
2093
2094 if (k < 0 && errno == EAGAIN && do_poll) {
2095
2096 /* We knowingly ignore any return value here,
2097 * and expect that any error/EOF is reported
2098 * via read() */
2099
2100 fd_wait_for_event(fd, POLLIN, (usec_t) -1);
2101 continue;
2102 }
2103
2104 if (k <= 0)
2105 return n > 0 ? n : (k < 0 ? -errno : 0);
2106
2107 p += k;
2108 nbytes -= k;
2109 n += k;
2110 }
2111
2112 return n;
2113 }
2114
2115 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2116 const uint8_t *p = buf;
2117 ssize_t n = 0;
2118
2119 assert(fd >= 0);
2120 assert(buf);
2121
2122 while (nbytes > 0) {
2123 ssize_t k;
2124
2125 k = write(fd, p, nbytes);
2126 if (k < 0 && errno == EINTR)
2127 continue;
2128
2129 if (k < 0 && errno == EAGAIN && do_poll) {
2130
2131 /* We knowingly ignore any return value here,
2132 * and expect that any error/EOF is reported
2133 * via write() */
2134
2135 fd_wait_for_event(fd, POLLOUT, (usec_t) -1);
2136 continue;
2137 }
2138
2139 if (k <= 0)
2140 return n > 0 ? n : (k < 0 ? -errno : 0);
2141
2142 p += k;
2143 nbytes -= k;
2144 n += k;
2145 }
2146
2147 return n;
2148 }
2149
2150 int parse_size(const char *t, off_t base, off_t *size) {
2151
2152 /* Soo, sometimes we want to parse IEC binary suffxies, and
2153 * sometimes SI decimal suffixes. This function can parse
2154 * both. Which one is the right way depends on the
2155 * context. Wikipedia suggests that SI is customary for
2156 * hardrware metrics and network speeds, while IEC is
2157 * customary for most data sizes used by software and volatile
2158 * (RAM) memory. Hence be careful which one you pick!
2159 *
2160 * In either case we use just K, M, G as suffix, and not Ki,
2161 * Mi, Gi or so (as IEC would suggest). That's because that's
2162 * frickin' ugly. But this means you really need to make sure
2163 * to document which base you are parsing when you use this
2164 * call. */
2165
2166 struct table {
2167 const char *suffix;
2168 unsigned long long factor;
2169 };
2170
2171 static const struct table iec[] = {
2172 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2173 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2174 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2175 { "G", 1024ULL*1024ULL*1024ULL },
2176 { "M", 1024ULL*1024ULL },
2177 { "K", 1024ULL },
2178 { "B", 1 },
2179 { "", 1 },
2180 };
2181
2182 static const struct table si[] = {
2183 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2184 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2185 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2186 { "G", 1000ULL*1000ULL*1000ULL },
2187 { "M", 1000ULL*1000ULL },
2188 { "K", 1000ULL },
2189 { "B", 1 },
2190 { "", 1 },
2191 };
2192
2193 const struct table *table;
2194 const char *p;
2195 unsigned long long r = 0;
2196 unsigned n_entries, start_pos = 0;
2197
2198 assert(t);
2199 assert(base == 1000 || base == 1024);
2200 assert(size);
2201
2202 if (base == 1000) {
2203 table = si;
2204 n_entries = ELEMENTSOF(si);
2205 } else {
2206 table = iec;
2207 n_entries = ELEMENTSOF(iec);
2208 }
2209
2210 p = t;
2211 do {
2212 long long l;
2213 unsigned long long l2;
2214 double frac = 0;
2215 char *e;
2216 unsigned i;
2217
2218 errno = 0;
2219 l = strtoll(p, &e, 10);
2220
2221 if (errno > 0)
2222 return -errno;
2223
2224 if (l < 0)
2225 return -ERANGE;
2226
2227 if (e == p)
2228 return -EINVAL;
2229
2230 if (*e == '.') {
2231 e++;
2232 if (*e >= '0' && *e <= '9') {
2233 char *e2;
2234
2235 /* strotoull itself would accept space/+/- */
2236 l2 = strtoull(e, &e2, 10);
2237
2238 if (errno == ERANGE)
2239 return -errno;
2240
2241 /* Ignore failure. E.g. 10.M is valid */
2242 frac = l2;
2243 for (; e < e2; e++)
2244 frac /= 10;
2245 }
2246 }
2247
2248 e += strspn(e, WHITESPACE);
2249
2250 for (i = start_pos; i < n_entries; i++)
2251 if (startswith(e, table[i].suffix)) {
2252 unsigned long long tmp;
2253 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2254 return -ERANGE;
2255 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2256 if (tmp > ULLONG_MAX - r)
2257 return -ERANGE;
2258
2259 r += tmp;
2260 if ((unsigned long long) (off_t) r != r)
2261 return -ERANGE;
2262
2263 p = e + strlen(table[i].suffix);
2264
2265 start_pos = i + 1;
2266 break;
2267 }
2268
2269 if (i >= n_entries)
2270 return -EINVAL;
2271
2272 } while (*p);
2273
2274 *size = r;
2275
2276 return 0;
2277 }
2278
2279 int make_stdio(int fd) {
2280 int r, s, t;
2281
2282 assert(fd >= 0);
2283
2284 r = dup3(fd, STDIN_FILENO, 0);
2285 s = dup3(fd, STDOUT_FILENO, 0);
2286 t = dup3(fd, STDERR_FILENO, 0);
2287
2288 if (fd >= 3)
2289 safe_close(fd);
2290
2291 if (r < 0 || s < 0 || t < 0)
2292 return -errno;
2293
2294 /* We rely here that the new fd has O_CLOEXEC not set */
2295
2296 return 0;
2297 }
2298
2299 int make_null_stdio(void) {
2300 int null_fd;
2301
2302 null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2303 if (null_fd < 0)
2304 return -errno;
2305
2306 return make_stdio(null_fd);
2307 }
2308
2309 bool is_device_path(const char *path) {
2310
2311 /* Returns true on paths that refer to a device, either in
2312 * sysfs or in /dev */
2313
2314 return
2315 path_startswith(path, "/dev/") ||
2316 path_startswith(path, "/sys/");
2317 }
2318
2319 int dir_is_empty(const char *path) {
2320 _cleanup_closedir_ DIR *d;
2321
2322 d = opendir(path);
2323 if (!d)
2324 return -errno;
2325
2326 for (;;) {
2327 struct dirent *de;
2328
2329 errno = 0;
2330 de = readdir(d);
2331 if (!de && errno != 0)
2332 return -errno;
2333
2334 if (!de)
2335 return 1;
2336
2337 if (!ignore_file(de->d_name))
2338 return 0;
2339 }
2340 }
2341
2342 char* dirname_malloc(const char *path) {
2343 char *d, *dir, *dir2;
2344
2345 d = strdup(path);
2346 if (!d)
2347 return NULL;
2348 dir = dirname(d);
2349 assert(dir);
2350
2351 if (dir != d) {
2352 dir2 = strdup(dir);
2353 free(d);
2354 return dir2;
2355 }
2356
2357 return dir;
2358 }
2359
2360 int dev_urandom(void *p, size_t n) {
2361 _cleanup_close_ int fd;
2362 ssize_t k;
2363
2364 fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2365 if (fd < 0)
2366 return errno == ENOENT ? -ENOSYS : -errno;
2367
2368 k = loop_read(fd, p, n, true);
2369 if (k < 0)
2370 return (int) k;
2371 if ((size_t) k != n)
2372 return -EIO;
2373
2374 return 0;
2375 }
2376
2377 void random_bytes(void *p, size_t n) {
2378 static bool srand_called = false;
2379 uint8_t *q;
2380 int r;
2381
2382 r = dev_urandom(p, n);
2383 if (r >= 0)
2384 return;
2385
2386 /* If some idiot made /dev/urandom unavailable to us, he'll
2387 * get a PRNG instead. */
2388
2389 if (!srand_called) {
2390 unsigned x = 0;
2391
2392 #ifdef HAVE_SYS_AUXV_H
2393 /* The kernel provides us with a bit of entropy in
2394 * auxv, so let's try to make use of that to seed the
2395 * pseudo-random generator. It's better than
2396 * nothing... */
2397
2398 void *auxv;
2399
2400 auxv = (void*) getauxval(AT_RANDOM);
2401 if (auxv)
2402 x ^= *(unsigned*) auxv;
2403 #endif
2404
2405 x ^= (unsigned) now(CLOCK_REALTIME);
2406 x ^= (unsigned) gettid();
2407
2408 srand(x);
2409 srand_called = true;
2410 }
2411
2412 for (q = p; q < (uint8_t*) p + n; q ++)
2413 *q = rand();
2414 }
2415
2416 void rename_process(const char name[8]) {
2417 assert(name);
2418
2419 /* This is a like a poor man's setproctitle(). It changes the
2420 * comm field, argv[0], and also the glibc's internally used
2421 * name of the process. For the first one a limit of 16 chars
2422 * applies, to the second one usually one of 10 (i.e. length
2423 * of "/sbin/init"), to the third one one of 7 (i.e. length of
2424 * "systemd"). If you pass a longer string it will be
2425 * truncated */
2426
2427 prctl(PR_SET_NAME, name);
2428
2429 if (program_invocation_name)
2430 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2431
2432 if (saved_argc > 0) {
2433 int i;
2434
2435 if (saved_argv[0])
2436 strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2437
2438 for (i = 1; i < saved_argc; i++) {
2439 if (!saved_argv[i])
2440 break;
2441
2442 memzero(saved_argv[i], strlen(saved_argv[i]));
2443 }
2444 }
2445 }
2446
2447 void sigset_add_many(sigset_t *ss, ...) {
2448 va_list ap;
2449 int sig;
2450
2451 assert(ss);
2452
2453 va_start(ap, ss);
2454 while ((sig = va_arg(ap, int)) > 0)
2455 assert_se(sigaddset(ss, sig) == 0);
2456 va_end(ap);
2457 }
2458
2459 int sigprocmask_many(int how, ...) {
2460 va_list ap;
2461 sigset_t ss;
2462 int sig;
2463
2464 assert_se(sigemptyset(&ss) == 0);
2465
2466 va_start(ap, how);
2467 while ((sig = va_arg(ap, int)) > 0)
2468 assert_se(sigaddset(&ss, sig) == 0);
2469 va_end(ap);
2470
2471 if (sigprocmask(how, &ss, NULL) < 0)
2472 return -errno;
2473
2474 return 0;
2475 }
2476
2477 char* gethostname_malloc(void) {
2478 struct utsname u;
2479
2480 assert_se(uname(&u) >= 0);
2481
2482 if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2483 return strdup(u.nodename);
2484
2485 return strdup(u.sysname);
2486 }
2487
2488 bool hostname_is_set(void) {
2489 struct utsname u;
2490
2491 assert_se(uname(&u) >= 0);
2492
2493 return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2494 }
2495
2496 static char *lookup_uid(uid_t uid) {
2497 long bufsize;
2498 char *name;
2499 _cleanup_free_ char *buf = NULL;
2500 struct passwd pwbuf, *pw = NULL;
2501
2502 /* Shortcut things to avoid NSS lookups */
2503 if (uid == 0)
2504 return strdup("root");
2505
2506 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2507 if (bufsize <= 0)
2508 bufsize = 4096;
2509
2510 buf = malloc(bufsize);
2511 if (!buf)
2512 return NULL;
2513
2514 if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2515 return strdup(pw->pw_name);
2516
2517 if (asprintf(&name, UID_FMT, uid) < 0)
2518 return NULL;
2519
2520 return name;
2521 }
2522
2523 char* getlogname_malloc(void) {
2524 uid_t uid;
2525 struct stat st;
2526
2527 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2528 uid = st.st_uid;
2529 else
2530 uid = getuid();
2531
2532 return lookup_uid(uid);
2533 }
2534
2535 char *getusername_malloc(void) {
2536 const char *e;
2537
2538 e = getenv("USER");
2539 if (e)
2540 return strdup(e);
2541
2542 return lookup_uid(getuid());
2543 }
2544
2545 int getttyname_malloc(int fd, char **r) {
2546 char path[PATH_MAX], *c;
2547 int k;
2548
2549 assert(r);
2550
2551 k = ttyname_r(fd, path, sizeof(path));
2552 if (k > 0)
2553 return -k;
2554
2555 char_array_0(path);
2556
2557 c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2558 if (!c)
2559 return -ENOMEM;
2560
2561 *r = c;
2562 return 0;
2563 }
2564
2565 int getttyname_harder(int fd, char **r) {
2566 int k;
2567 char *s;
2568
2569 k = getttyname_malloc(fd, &s);
2570 if (k < 0)
2571 return k;
2572
2573 if (streq(s, "tty")) {
2574 free(s);
2575 return get_ctty(0, NULL, r);
2576 }
2577
2578 *r = s;
2579 return 0;
2580 }
2581
2582 int get_ctty_devnr(pid_t pid, dev_t *d) {
2583 int r;
2584 _cleanup_free_ char *line = NULL;
2585 const char *p;
2586 unsigned long ttynr;
2587
2588 assert(pid >= 0);
2589
2590 p = procfs_file_alloca(pid, "stat");
2591 r = read_one_line_file(p, &line);
2592 if (r < 0)
2593 return r;
2594
2595 p = strrchr(line, ')');
2596 if (!p)
2597 return -EIO;
2598
2599 p++;
2600
2601 if (sscanf(p, " "
2602 "%*c " /* state */
2603 "%*d " /* ppid */
2604 "%*d " /* pgrp */
2605 "%*d " /* session */
2606 "%lu ", /* ttynr */
2607 &ttynr) != 1)
2608 return -EIO;
2609
2610 if (major(ttynr) == 0 && minor(ttynr) == 0)
2611 return -ENOENT;
2612
2613 if (d)
2614 *d = (dev_t) ttynr;
2615
2616 return 0;
2617 }
2618
2619 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2620 char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2621 _cleanup_free_ char *s = NULL;
2622 const char *p;
2623 dev_t devnr;
2624 int k;
2625
2626 assert(r);
2627
2628 k = get_ctty_devnr(pid, &devnr);
2629 if (k < 0)
2630 return k;
2631
2632 snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2633
2634 k = readlink_malloc(fn, &s);
2635 if (k < 0) {
2636
2637 if (k != -ENOENT)
2638 return k;
2639
2640 /* This is an ugly hack */
2641 if (major(devnr) == 136) {
2642 asprintf(&b, "pts/%u", minor(devnr));
2643 goto finish;
2644 }
2645
2646 /* Probably something like the ptys which have no
2647 * symlink in /dev/char. Let's return something
2648 * vaguely useful. */
2649
2650 b = strdup(fn + 5);
2651 goto finish;
2652 }
2653
2654 if (startswith(s, "/dev/"))
2655 p = s + 5;
2656 else if (startswith(s, "../"))
2657 p = s + 3;
2658 else
2659 p = s;
2660
2661 b = strdup(p);
2662
2663 finish:
2664 if (!b)
2665 return -ENOMEM;
2666
2667 *r = b;
2668 if (_devnr)
2669 *_devnr = devnr;
2670
2671 return 0;
2672 }
2673
2674 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2675 _cleanup_closedir_ DIR *d = NULL;
2676 int ret = 0;
2677
2678 assert(fd >= 0);
2679
2680 /* This returns the first error we run into, but nevertheless
2681 * tries to go on. This closes the passed fd. */
2682
2683 d = fdopendir(fd);
2684 if (!d) {
2685 safe_close(fd);
2686
2687 return errno == ENOENT ? 0 : -errno;
2688 }
2689
2690 for (;;) {
2691 struct dirent *de;
2692 bool is_dir, keep_around;
2693 struct stat st;
2694 int r;
2695
2696 errno = 0;
2697 de = readdir(d);
2698 if (!de) {
2699 if (errno != 0 && ret == 0)
2700 ret = -errno;
2701 return ret;
2702 }
2703
2704 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2705 continue;
2706
2707 if (de->d_type == DT_UNKNOWN ||
2708 honour_sticky ||
2709 (de->d_type == DT_DIR && root_dev)) {
2710 if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2711 if (ret == 0 && errno != ENOENT)
2712 ret = -errno;
2713 continue;
2714 }
2715
2716 is_dir = S_ISDIR(st.st_mode);
2717 keep_around =
2718 honour_sticky &&
2719 (st.st_uid == 0 || st.st_uid == getuid()) &&
2720 (st.st_mode & S_ISVTX);
2721 } else {
2722 is_dir = de->d_type == DT_DIR;
2723 keep_around = false;
2724 }
2725
2726 if (is_dir) {
2727 int subdir_fd;
2728
2729 /* if root_dev is set, remove subdirectories only, if device is same as dir */
2730 if (root_dev && st.st_dev != root_dev->st_dev)
2731 continue;
2732
2733 subdir_fd = openat(fd, de->d_name,
2734 O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2735 if (subdir_fd < 0) {
2736 if (ret == 0 && errno != ENOENT)
2737 ret = -errno;
2738 continue;
2739 }
2740
2741 r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2742 if (r < 0 && ret == 0)
2743 ret = r;
2744
2745 if (!keep_around)
2746 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2747 if (ret == 0 && errno != ENOENT)
2748 ret = -errno;
2749 }
2750
2751 } else if (!only_dirs && !keep_around) {
2752
2753 if (unlinkat(fd, de->d_name, 0) < 0) {
2754 if (ret == 0 && errno != ENOENT)
2755 ret = -errno;
2756 }
2757 }
2758 }
2759 }
2760
2761 _pure_ static int is_temporary_fs(struct statfs *s) {
2762 assert(s);
2763
2764 return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2765 F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2766 }
2767
2768 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2769 struct statfs s;
2770
2771 assert(fd >= 0);
2772
2773 if (fstatfs(fd, &s) < 0) {
2774 safe_close(fd);
2775 return -errno;
2776 }
2777
2778 /* We refuse to clean disk file systems with this call. This
2779 * is extra paranoia just to be sure we never ever remove
2780 * non-state data */
2781 if (!is_temporary_fs(&s)) {
2782 log_error("Attempted to remove disk file system, and we can't allow that.");
2783 safe_close(fd);
2784 return -EPERM;
2785 }
2786
2787 return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2788 }
2789
2790 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2791 int fd, r;
2792 struct statfs s;
2793
2794 assert(path);
2795
2796 /* We refuse to clean the root file system with this
2797 * call. This is extra paranoia to never cause a really
2798 * seriously broken system. */
2799 if (path_equal(path, "/")) {
2800 log_error("Attempted to remove entire root file system, and we can't allow that.");
2801 return -EPERM;
2802 }
2803
2804 fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2805 if (fd < 0) {
2806
2807 if (errno != ENOTDIR)
2808 return -errno;
2809
2810 if (!dangerous) {
2811 if (statfs(path, &s) < 0)
2812 return -errno;
2813
2814 if (!is_temporary_fs(&s)) {
2815 log_error("Attempted to remove disk file system, and we can't allow that.");
2816 return -EPERM;
2817 }
2818 }
2819
2820 if (delete_root && !only_dirs)
2821 if (unlink(path) < 0 && errno != ENOENT)
2822 return -errno;
2823
2824 return 0;
2825 }
2826
2827 if (!dangerous) {
2828 if (fstatfs(fd, &s) < 0) {
2829 safe_close(fd);
2830 return -errno;
2831 }
2832
2833 if (!is_temporary_fs(&s)) {
2834 log_error("Attempted to remove disk file system, and we can't allow that.");
2835 safe_close(fd);
2836 return -EPERM;
2837 }
2838 }
2839
2840 r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2841 if (delete_root) {
2842
2843 if (honour_sticky && file_is_priv_sticky(path) > 0)
2844 return r;
2845
2846 if (rmdir(path) < 0 && errno != ENOENT) {
2847 if (r == 0)
2848 r = -errno;
2849 }
2850 }
2851
2852 return r;
2853 }
2854
2855 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2856 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2857 }
2858
2859 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2860 return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2861 }
2862
2863 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2864 assert(path);
2865
2866 /* Under the assumption that we are running privileged we
2867 * first change the access mode and only then hand out
2868 * ownership to avoid a window where access is too open. */
2869
2870 if (mode != (mode_t) -1)
2871 if (chmod(path, mode) < 0)
2872 return -errno;
2873
2874 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2875 if (chown(path, uid, gid) < 0)
2876 return -errno;
2877
2878 return 0;
2879 }
2880
2881 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2882 assert(fd >= 0);
2883
2884 /* Under the assumption that we are running privileged we
2885 * first change the access mode and only then hand out
2886 * ownership to avoid a window where access is too open. */
2887
2888 if (mode != (mode_t) -1)
2889 if (fchmod(fd, mode) < 0)
2890 return -errno;
2891
2892 if (uid != (uid_t) -1 || gid != (gid_t) -1)
2893 if (fchown(fd, uid, gid) < 0)
2894 return -errno;
2895
2896 return 0;
2897 }
2898
2899 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2900 cpu_set_t *r;
2901 unsigned n = 1024;
2902
2903 /* Allocates the cpuset in the right size */
2904
2905 for (;;) {
2906 if (!(r = CPU_ALLOC(n)))
2907 return NULL;
2908
2909 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2910 CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2911
2912 if (ncpus)
2913 *ncpus = n;
2914
2915 return r;
2916 }
2917
2918 CPU_FREE(r);
2919
2920 if (errno != EINVAL)
2921 return NULL;
2922
2923 n *= 2;
2924 }
2925 }
2926
2927 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2928 static const char status_indent[] = " "; /* "[" STATUS "] " */
2929 _cleanup_free_ char *s = NULL;
2930 _cleanup_close_ int fd = -1;
2931 struct iovec iovec[6] = {};
2932 int n = 0;
2933 static bool prev_ephemeral;
2934
2935 assert(format);
2936
2937 /* This is independent of logging, as status messages are
2938 * optional and go exclusively to the console. */
2939
2940 if (vasprintf(&s, format, ap) < 0)
2941 return log_oom();
2942
2943 fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2944 if (fd < 0)
2945 return fd;
2946
2947 if (ellipse) {
2948 char *e;
2949 size_t emax, sl;
2950 int c;
2951
2952 c = fd_columns(fd);
2953 if (c <= 0)
2954 c = 80;
2955
2956 sl = status ? sizeof(status_indent)-1 : 0;
2957
2958 emax = c - sl - 1;
2959 if (emax < 3)
2960 emax = 3;
2961
2962 e = ellipsize(s, emax, 75);
2963 if (e) {
2964 free(s);
2965 s = e;
2966 }
2967 }
2968
2969 if (prev_ephemeral)
2970 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2971 prev_ephemeral = ephemeral;
2972
2973 if (status) {
2974 if (!isempty(status)) {
2975 IOVEC_SET_STRING(iovec[n++], "[");
2976 IOVEC_SET_STRING(iovec[n++], status);
2977 IOVEC_SET_STRING(iovec[n++], "] ");
2978 } else
2979 IOVEC_SET_STRING(iovec[n++], status_indent);
2980 }
2981
2982 IOVEC_SET_STRING(iovec[n++], s);
2983 if (!ephemeral)
2984 IOVEC_SET_STRING(iovec[n++], "\n");
2985
2986 if (writev(fd, iovec, n) < 0)
2987 return -errno;
2988
2989 return 0;
2990 }
2991
2992 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
2993 va_list ap;
2994 int r;
2995
2996 assert(format);
2997
2998 va_start(ap, format);
2999 r = status_vprintf(status, ellipse, ephemeral, format, ap);
3000 va_end(ap);
3001
3002 return r;
3003 }
3004
3005 char *replace_env(const char *format, char **env) {
3006 enum {
3007 WORD,
3008 CURLY,
3009 VARIABLE
3010 } state = WORD;
3011
3012 const char *e, *word = format;
3013 char *r = NULL, *k;
3014
3015 assert(format);
3016
3017 for (e = format; *e; e ++) {
3018
3019 switch (state) {
3020
3021 case WORD:
3022 if (*e == '$')
3023 state = CURLY;
3024 break;
3025
3026 case CURLY:
3027 if (*e == '{') {
3028 if (!(k = strnappend(r, word, e-word-1)))
3029 goto fail;
3030
3031 free(r);
3032 r = k;
3033
3034 word = e-1;
3035 state = VARIABLE;
3036
3037 } else if (*e == '$') {
3038 if (!(k = strnappend(r, word, e-word)))
3039 goto fail;
3040
3041 free(r);
3042 r = k;
3043
3044 word = e+1;
3045 state = WORD;
3046 } else
3047 state = WORD;
3048 break;
3049
3050 case VARIABLE:
3051 if (*e == '}') {
3052 const char *t;
3053
3054 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3055
3056 k = strappend(r, t);
3057 if (!k)
3058 goto fail;
3059
3060 free(r);
3061 r = k;
3062
3063 word = e+1;
3064 state = WORD;
3065 }
3066 break;
3067 }
3068 }
3069
3070 if (!(k = strnappend(r, word, e-word)))
3071 goto fail;
3072
3073 free(r);
3074 return k;
3075
3076 fail:
3077 free(r);
3078 return NULL;
3079 }
3080
3081 char **replace_env_argv(char **argv, char **env) {
3082 char **r, **i;
3083 unsigned k = 0, l = 0;
3084
3085 l = strv_length(argv);
3086
3087 if (!(r = new(char*, l+1)))
3088 return NULL;
3089
3090 STRV_FOREACH(i, argv) {
3091
3092 /* If $FOO appears as single word, replace it by the split up variable */
3093 if ((*i)[0] == '$' && (*i)[1] != '{') {
3094 char *e;
3095 char **w, **m;
3096 unsigned q;
3097
3098 e = strv_env_get(env, *i+1);
3099 if (e) {
3100
3101 if (!(m = strv_split_quoted(e))) {
3102 r[k] = NULL;
3103 strv_free(r);
3104 return NULL;
3105 }
3106 } else
3107 m = NULL;
3108
3109 q = strv_length(m);
3110 l = l + q - 1;
3111
3112 if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3113 r[k] = NULL;
3114 strv_free(r);
3115 strv_free(m);
3116 return NULL;
3117 }
3118
3119 r = w;
3120 if (m) {
3121 memcpy(r + k, m, q * sizeof(char*));
3122 free(m);
3123 }
3124
3125 k += q;
3126 continue;
3127 }
3128
3129 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3130 if (!(r[k++] = replace_env(*i, env))) {
3131 strv_free(r);
3132 return NULL;
3133 }
3134 }
3135
3136 r[k] = NULL;
3137 return r;
3138 }
3139
3140 int fd_columns(int fd) {
3141 struct winsize ws = {};
3142
3143 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3144 return -errno;
3145
3146 if (ws.ws_col <= 0)
3147 return -EIO;
3148
3149 return ws.ws_col;
3150 }
3151
3152 unsigned columns(void) {
3153 const char *e;
3154 int c;
3155
3156 if (_likely_(cached_columns > 0))
3157 return cached_columns;
3158
3159 c = 0;
3160 e = getenv("COLUMNS");
3161 if (e)
3162 safe_atoi(e, &c);
3163
3164 if (c <= 0)
3165 c = fd_columns(STDOUT_FILENO);
3166
3167 if (c <= 0)
3168 c = 80;
3169
3170 cached_columns = c;
3171 return c;
3172 }
3173
3174 int fd_lines(int fd) {
3175 struct winsize ws = {};
3176
3177 if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3178 return -errno;
3179
3180 if (ws.ws_row <= 0)
3181 return -EIO;
3182
3183 return ws.ws_row;
3184 }
3185
3186 unsigned lines(void) {
3187 const char *e;
3188 unsigned l;
3189
3190 if (_likely_(cached_lines > 0))
3191 return cached_lines;
3192
3193 l = 0;
3194 e = getenv("LINES");
3195 if (e)
3196 safe_atou(e, &l);
3197
3198 if (l <= 0)
3199 l = fd_lines(STDOUT_FILENO);
3200
3201 if (l <= 0)
3202 l = 24;
3203
3204 cached_lines = l;
3205 return cached_lines;
3206 }
3207
3208 /* intended to be used as a SIGWINCH sighandler */
3209 void columns_lines_cache_reset(int signum) {
3210 cached_columns = 0;
3211 cached_lines = 0;
3212 }
3213
3214 bool on_tty(void) {
3215 static int cached_on_tty = -1;
3216
3217 if (_unlikely_(cached_on_tty < 0))
3218 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3219
3220 return cached_on_tty;
3221 }
3222
3223 int files_same(const char *filea, const char *fileb) {
3224 struct stat a, b;
3225
3226 if (stat(filea, &a) < 0)
3227 return -errno;
3228
3229 if (stat(fileb, &b) < 0)
3230 return -errno;
3231
3232 return a.st_dev == b.st_dev &&
3233 a.st_ino == b.st_ino;
3234 }
3235
3236 int running_in_chroot(void) {
3237 int ret;
3238
3239 ret = files_same("/proc/1/root", "/");
3240 if (ret < 0)
3241 return ret;
3242
3243 return ret == 0;
3244 }
3245
3246 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3247 size_t x;
3248 char *r;
3249
3250 assert(s);
3251 assert(percent <= 100);
3252 assert(new_length >= 3);
3253
3254 if (old_length <= 3 || old_length <= new_length)
3255 return strndup(s, old_length);
3256
3257 r = new0(char, new_length+1);
3258 if (!r)
3259 return NULL;
3260
3261 x = (new_length * percent) / 100;
3262
3263 if (x > new_length - 3)
3264 x = new_length - 3;
3265
3266 memcpy(r, s, x);
3267 r[x] = '.';
3268 r[x+1] = '.';
3269 r[x+2] = '.';
3270 memcpy(r + x + 3,
3271 s + old_length - (new_length - x - 3),
3272 new_length - x - 3);
3273
3274 return r;
3275 }
3276
3277 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3278 size_t x;
3279 char *e;
3280 const char *i, *j;
3281 unsigned k, len, len2;
3282
3283 assert(s);
3284 assert(percent <= 100);
3285 assert(new_length >= 3);
3286
3287 /* if no multibyte characters use ascii_ellipsize_mem for speed */
3288 if (ascii_is_valid(s))
3289 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3290
3291 if (old_length <= 3 || old_length <= new_length)
3292 return strndup(s, old_length);
3293
3294 x = (new_length * percent) / 100;
3295
3296 if (x > new_length - 3)
3297 x = new_length - 3;
3298
3299 k = 0;
3300 for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3301 int c;
3302
3303 c = utf8_encoded_to_unichar(i);
3304 if (c < 0)
3305 return NULL;
3306 k += unichar_iswide(c) ? 2 : 1;
3307 }
3308
3309 if (k > x) /* last character was wide and went over quota */
3310 x ++;
3311
3312 for (j = s + old_length; k < new_length && j > i; ) {
3313 int c;
3314
3315 j = utf8_prev_char(j);
3316 c = utf8_encoded_to_unichar(j);
3317 if (c < 0)
3318 return NULL;
3319 k += unichar_iswide(c) ? 2 : 1;
3320 }
3321 assert(i <= j);
3322
3323 /* we don't actually need to ellipsize */
3324 if (i == j)
3325 return memdup(s, old_length + 1);
3326
3327 /* make space for ellipsis */
3328 j = utf8_next_char(j);
3329
3330 len = i - s;
3331 len2 = s + old_length - j;
3332 e = new(char, len + 3 + len2 + 1);
3333 if (!e)
3334 return NULL;
3335
3336 /*
3337 printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3338 old_length, new_length, x, len, len2, k);
3339 */
3340
3341 memcpy(e, s, len);
3342 e[len] = 0xe2; /* tri-dot ellipsis: … */
3343 e[len + 1] = 0x80;
3344 e[len + 2] = 0xa6;
3345
3346 memcpy(e + len + 3, j, len2 + 1);
3347
3348 return e;
3349 }
3350
3351 char *ellipsize(const char *s, size_t length, unsigned percent) {
3352 return ellipsize_mem(s, strlen(s), length, percent);
3353 }
3354
3355 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
3356 _cleanup_close_ int fd;
3357 int r;
3358
3359 assert(path);
3360
3361 if (parents)
3362 mkdir_parents(path, 0755);
3363
3364 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3365 if (fd < 0)
3366 return -errno;
3367
3368 if (mode > 0) {
3369 r = fchmod(fd, mode);
3370 if (r < 0)
3371 return -errno;
3372 }
3373
3374 if (uid != (uid_t) -1 || gid != (gid_t) -1) {
3375 r = fchown(fd, uid, gid);
3376 if (r < 0)
3377 return -errno;
3378 }
3379
3380 if (stamp != (usec_t) -1) {
3381 struct timespec ts[2];
3382
3383 timespec_store(&ts[0], stamp);
3384 ts[1] = ts[0];
3385 r = futimens(fd, ts);
3386 } else
3387 r = futimens(fd, NULL);
3388 if (r < 0)
3389 return -errno;
3390
3391 return 0;
3392 }
3393
3394 int touch(const char *path) {
3395 return touch_file(path, false, (usec_t) -1, (uid_t) -1, (gid_t) -1, 0);
3396 }
3397
3398 char *unquote(const char *s, const char* quotes) {
3399 size_t l;
3400 assert(s);
3401
3402 /* This is rather stupid, simply removes the heading and
3403 * trailing quotes if there is one. Doesn't care about
3404 * escaping or anything. We should make this smarter one
3405 * day...*/
3406
3407 l = strlen(s);
3408 if (l < 2)
3409 return strdup(s);
3410
3411 if (strchr(quotes, s[0]) && s[l-1] == s[0])
3412 return strndup(s+1, l-2);
3413
3414 return strdup(s);
3415 }
3416
3417 char *normalize_env_assignment(const char *s) {
3418 _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3419 char *eq, *r;
3420
3421 eq = strchr(s, '=');
3422 if (!eq) {
3423 char *t;
3424
3425 r = strdup(s);
3426 if (!r)
3427 return NULL;
3428
3429 t = strstrip(r);
3430 if (t == r)
3431 return r;
3432
3433 memmove(r, t, strlen(t) + 1);
3434 return r;
3435 }
3436
3437 name = strndup(s, eq - s);
3438 if (!name)
3439 return NULL;
3440
3441 p = strdup(eq + 1);
3442 if (!p)
3443 return NULL;
3444
3445 value = unquote(strstrip(p), QUOTES);
3446 if (!value)
3447 return NULL;
3448
3449 if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3450 r = NULL;
3451
3452 return r;
3453 }
3454
3455 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3456 siginfo_t dummy;
3457
3458 assert(pid >= 1);
3459
3460 if (!status)
3461 status = &dummy;
3462
3463 for (;;) {
3464 zero(*status);
3465
3466 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3467
3468 if (errno == EINTR)
3469 continue;
3470
3471 return -errno;
3472 }
3473
3474 return 0;
3475 }
3476 }
3477
3478 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3479 int r;
3480 siginfo_t status;
3481
3482 assert(name);
3483 assert(pid > 1);
3484
3485 r = wait_for_terminate(pid, &status);
3486 if (r < 0) {
3487 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3488 return r;
3489 }
3490
3491 if (status.si_code == CLD_EXITED) {
3492 if (status.si_status != 0) {
3493 log_warning("%s failed with error code %i.", name, status.si_status);
3494 return status.si_status;
3495 }
3496
3497 log_debug("%s succeeded.", name);
3498 return 0;
3499
3500 } else if (status.si_code == CLD_KILLED ||
3501 status.si_code == CLD_DUMPED) {
3502
3503 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3504 return -EPROTO;
3505 }
3506
3507 log_warning("%s failed due to unknown reason.", name);
3508 return -EPROTO;
3509 }
3510
3511 noreturn void freeze(void) {
3512
3513 /* Make sure nobody waits for us on a socket anymore */
3514 close_all_fds(NULL, 0);
3515
3516 sync();
3517
3518 for (;;)
3519 pause();
3520 }
3521
3522 bool null_or_empty(struct stat *st) {
3523 assert(st);
3524
3525 if (S_ISREG(st->st_mode) && st->st_size <= 0)
3526 return true;
3527
3528 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3529 return true;
3530
3531 return false;
3532 }
3533
3534 int null_or_empty_path(const char *fn) {
3535 struct stat st;
3536
3537 assert(fn);
3538
3539 if (stat(fn, &st) < 0)
3540 return -errno;
3541
3542 return null_or_empty(&st);
3543 }
3544
3545 DIR *xopendirat(int fd, const char *name, int flags) {
3546 int nfd;
3547 DIR *d;
3548
3549 assert(!(flags & O_CREAT));
3550
3551 nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3552 if (nfd < 0)
3553 return NULL;
3554
3555 d = fdopendir(nfd);
3556 if (!d) {
3557 safe_close(nfd);
3558 return NULL;
3559 }
3560
3561 return d;
3562 }
3563
3564 int signal_from_string_try_harder(const char *s) {
3565 int signo;
3566 assert(s);
3567
3568 signo = signal_from_string(s);
3569 if (signo <= 0)
3570 if (startswith(s, "SIG"))
3571 return signal_from_string(s+3);
3572
3573 return signo;
3574 }
3575
3576 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3577 _cleanup_free_ char *t = NULL, *u = NULL;
3578 size_t enc_len;
3579
3580 u = unquote(tagvalue, "\"\'");
3581 if (!u)
3582 return NULL;
3583
3584 enc_len = strlen(u) * 4 + 1;
3585 t = new(char, enc_len);
3586 if (!t)
3587 return NULL;
3588
3589 if (encode_devnode_name(u, t, enc_len) < 0)
3590 return NULL;
3591
3592 return strjoin("/dev/disk/by-", by, "/", t, NULL);
3593 }
3594
3595 char *fstab_node_to_udev_node(const char *p) {
3596 assert(p);
3597
3598 if (startswith(p, "LABEL="))
3599 return tag_to_udev_node(p+6, "label");
3600
3601 if (startswith(p, "UUID="))
3602 return tag_to_udev_node(p+5, "uuid");
3603
3604 if (startswith(p, "PARTUUID="))
3605 return tag_to_udev_node(p+9, "partuuid");
3606
3607 if (startswith(p, "PARTLABEL="))
3608 return tag_to_udev_node(p+10, "partlabel");
3609
3610 return strdup(p);
3611 }
3612
3613 bool tty_is_vc(const char *tty) {
3614 assert(tty);
3615
3616 return vtnr_from_tty(tty) >= 0;
3617 }
3618
3619 bool tty_is_console(const char *tty) {
3620 assert(tty);
3621
3622 if (startswith(tty, "/dev/"))
3623 tty += 5;
3624
3625 return streq(tty, "console");
3626 }
3627
3628 int vtnr_from_tty(const char *tty) {
3629 int i, r;
3630
3631 assert(tty);
3632
3633 if (startswith(tty, "/dev/"))
3634 tty += 5;
3635
3636 if (!startswith(tty, "tty") )
3637 return -EINVAL;
3638
3639 if (tty[3] < '0' || tty[3] > '9')
3640 return -EINVAL;
3641
3642 r = safe_atoi(tty+3, &i);
3643 if (r < 0)
3644 return r;
3645
3646 if (i < 0 || i > 63)
3647 return -EINVAL;
3648
3649 return i;
3650 }
3651
3652 char *resolve_dev_console(char **active) {
3653 char *tty;
3654
3655 /* Resolve where /dev/console is pointing to, if /sys is actually ours
3656 * (i.e. not read-only-mounted which is a sign for container setups) */
3657
3658 if (path_is_read_only_fs("/sys") > 0)
3659 return NULL;
3660
3661 if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3662 return NULL;
3663
3664 /* If multiple log outputs are configured the last one is what
3665 * /dev/console points to */
3666 tty = strrchr(*active, ' ');
3667 if (tty)
3668 tty++;
3669 else
3670 tty = *active;
3671
3672 if (streq(tty, "tty0")) {
3673 char *tmp;
3674
3675 /* Get the active VC (e.g. tty1) */
3676 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3677 free(*active);
3678 tty = *active = tmp;
3679 }
3680 }
3681
3682 return tty;
3683 }
3684
3685 bool tty_is_vc_resolve(const char *tty) {
3686 _cleanup_free_ char *active = NULL;
3687
3688 assert(tty);
3689
3690 if (startswith(tty, "/dev/"))
3691 tty += 5;
3692
3693 if (streq(tty, "console")) {
3694 tty = resolve_dev_console(&active);
3695 if (!tty)
3696 return false;
3697 }
3698
3699 return tty_is_vc(tty);
3700 }
3701
3702 const char *default_term_for_tty(const char *tty) {
3703 assert(tty);
3704
3705 return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3706 }
3707
3708 bool dirent_is_file(const struct dirent *de) {
3709 assert(de);
3710
3711 if (ignore_file(de->d_name))
3712 return false;
3713
3714 if (de->d_type != DT_REG &&
3715 de->d_type != DT_LNK &&
3716 de->d_type != DT_UNKNOWN)
3717 return false;
3718
3719 return true;
3720 }
3721
3722 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3723 assert(de);
3724
3725 if (de->d_type != DT_REG &&
3726 de->d_type != DT_LNK &&
3727 de->d_type != DT_UNKNOWN)
3728 return false;
3729
3730 if (ignore_file_allow_backup(de->d_name))
3731 return false;
3732
3733 return endswith(de->d_name, suffix);
3734 }
3735
3736 void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {
3737 pid_t executor_pid;
3738 int r;
3739
3740 assert(directory);
3741
3742 /* Executes all binaries in a directory in parallel and waits
3743 * for them to finish. Optionally a timeout is applied. */
3744
3745 executor_pid = fork();
3746 if (executor_pid < 0) {
3747 log_error("Failed to fork: %m");
3748 return;
3749
3750 } else if (executor_pid == 0) {
3751 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
3752 _cleanup_closedir_ DIR *_d = NULL;
3753 struct dirent *de;
3754 sigset_t ss;
3755
3756 /* We fork this all off from a child process so that
3757 * we can somewhat cleanly make use of SIGALRM to set
3758 * a time limit */
3759
3760 reset_all_signal_handlers();
3761
3762 assert_se(sigemptyset(&ss) == 0);
3763 assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);
3764
3765 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3766
3767 if (!d) {
3768 d = _d = opendir(directory);
3769 if (!d) {
3770 if (errno == ENOENT)
3771 _exit(EXIT_SUCCESS);
3772
3773 log_error("Failed to enumerate directory %s: %m", directory);
3774 _exit(EXIT_FAILURE);
3775 }
3776 }
3777
3778 pids = hashmap_new(NULL, NULL);
3779 if (!pids) {
3780 log_oom();
3781 _exit(EXIT_FAILURE);
3782 }
3783
3784 FOREACH_DIRENT(de, d, break) {
3785 _cleanup_free_ char *path = NULL;
3786 pid_t pid;
3787
3788 if (!dirent_is_file(de))
3789 continue;
3790
3791 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
3792 log_oom();
3793 _exit(EXIT_FAILURE);
3794 }
3795
3796 pid = fork();
3797 if (pid < 0) {
3798 log_error("Failed to fork: %m");
3799 continue;
3800 } else if (pid == 0) {
3801 char *_argv[2];
3802
3803 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3804
3805 if (!argv) {
3806 _argv[0] = path;
3807 _argv[1] = NULL;
3808 argv = _argv;
3809 } else
3810 argv[0] = path;
3811
3812 execv(path, argv);
3813 log_error("Failed to execute %s: %m", path);
3814 _exit(EXIT_FAILURE);
3815 }
3816
3817
3818 log_debug("Spawned %s as " PID_FMT ".", path, pid);
3819
3820 r = hashmap_put(pids, UINT_TO_PTR(pid), path);
3821 if (r < 0) {
3822 log_oom();
3823 _exit(EXIT_FAILURE);
3824 }
3825
3826 path = NULL;
3827 }
3828
3829 /* Abort execution of this process after the
3830 * timout. We simply rely on SIGALRM as default action
3831 * terminating the process, and turn on alarm(). */
3832
3833 if (timeout != (usec_t) -1)
3834 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
3835
3836 while (!hashmap_isempty(pids)) {
3837 _cleanup_free_ char *path = NULL;
3838 pid_t pid;
3839
3840 pid = PTR_TO_UINT(hashmap_first_key(pids));
3841 assert(pid > 0);
3842
3843 path = hashmap_remove(pids, UINT_TO_PTR(pid));
3844 assert(path);
3845
3846 wait_for_terminate_and_warn(path, pid);
3847 }
3848
3849 _exit(EXIT_SUCCESS);
3850 }
3851
3852 wait_for_terminate_and_warn(directory, executor_pid);
3853 }
3854
3855 int kill_and_sigcont(pid_t pid, int sig) {
3856 int r;
3857
3858 r = kill(pid, sig) < 0 ? -errno : 0;
3859
3860 if (r >= 0)
3861 kill(pid, SIGCONT);
3862
3863 return r;
3864 }
3865
3866 bool nulstr_contains(const char*nulstr, const char *needle) {
3867 const char *i;
3868
3869 if (!nulstr)
3870 return false;
3871
3872 NULSTR_FOREACH(i, nulstr)
3873 if (streq(i, needle))
3874 return true;
3875
3876 return false;
3877 }
3878
3879 bool plymouth_running(void) {
3880 return access("/run/plymouth/pid", F_OK) >= 0;
3881 }
3882
3883 char* strshorten(char *s, size_t l) {
3884 assert(s);
3885
3886 if (l < strlen(s))
3887 s[l] = 0;
3888
3889 return s;
3890 }
3891
3892 static bool hostname_valid_char(char c) {
3893 return
3894 (c >= 'a' && c <= 'z') ||
3895 (c >= 'A' && c <= 'Z') ||
3896 (c >= '0' && c <= '9') ||
3897 c == '-' ||
3898 c == '_' ||
3899 c == '.';
3900 }
3901
3902 bool hostname_is_valid(const char *s) {
3903 const char *p;
3904 bool dot;
3905
3906 if (isempty(s))
3907 return false;
3908
3909 for (p = s, dot = true; *p; p++) {
3910 if (*p == '.') {
3911 if (dot)
3912 return false;
3913
3914 dot = true;
3915 } else {
3916 if (!hostname_valid_char(*p))
3917 return false;
3918
3919 dot = false;
3920 }
3921 }
3922
3923 if (dot)
3924 return false;
3925
3926 if (p-s > HOST_NAME_MAX)
3927 return false;
3928
3929 return true;
3930 }
3931
3932 char* hostname_cleanup(char *s, bool lowercase) {
3933 char *p, *d;
3934 bool dot;
3935
3936 for (p = s, d = s, dot = true; *p; p++) {
3937 if (*p == '.') {
3938 if (dot)
3939 continue;
3940
3941 *(d++) = '.';
3942 dot = true;
3943 } else if (hostname_valid_char(*p)) {
3944 *(d++) = lowercase ? tolower(*p) : *p;
3945 dot = false;
3946 }
3947
3948 }
3949
3950 if (dot && d > s)
3951 d[-1] = 0;
3952 else
3953 *d = 0;
3954
3955 strshorten(s, HOST_NAME_MAX);
3956
3957 return s;
3958 }
3959
3960 int pipe_eof(int fd) {
3961 struct pollfd pollfd = {
3962 .fd = fd,
3963 .events = POLLIN|POLLHUP,
3964 };
3965
3966 int r;
3967
3968 r = poll(&pollfd, 1, 0);
3969 if (r < 0)
3970 return -errno;
3971
3972 if (r == 0)
3973 return 0;
3974
3975 return pollfd.revents & POLLHUP;
3976 }
3977
3978 int fd_wait_for_event(int fd, int event, usec_t t) {
3979
3980 struct pollfd pollfd = {
3981 .fd = fd,
3982 .events = event,
3983 };
3984
3985 struct timespec ts;
3986 int r;
3987
3988 r = ppoll(&pollfd, 1, t == (usec_t) -1 ? NULL : timespec_store(&ts, t), NULL);
3989 if (r < 0)
3990 return -errno;
3991
3992 if (r == 0)
3993 return 0;
3994
3995 return pollfd.revents;
3996 }
3997
3998 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
3999 FILE *f;
4000 char *t;
4001 int fd;
4002
4003 assert(path);
4004 assert(_f);
4005 assert(_temp_path);
4006
4007 t = tempfn_xxxxxx(path);
4008 if (!t)
4009 return -ENOMEM;
4010
4011 fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
4012 if (fd < 0) {
4013 free(t);
4014 return -errno;
4015 }
4016
4017 f = fdopen(fd, "we");
4018 if (!f) {
4019 unlink(t);
4020 free(t);
4021 return -errno;
4022 }
4023
4024 *_f = f;
4025 *_temp_path = t;
4026
4027 return 0;
4028 }
4029
4030 int terminal_vhangup_fd(int fd) {
4031 assert(fd >= 0);
4032
4033 if (ioctl(fd, TIOCVHANGUP) < 0)
4034 return -errno;
4035
4036 return 0;
4037 }
4038
4039 int terminal_vhangup(const char *name) {
4040 _cleanup_close_ int fd;
4041
4042 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4043 if (fd < 0)
4044 return fd;
4045
4046 return terminal_vhangup_fd(fd);
4047 }
4048
4049 int vt_disallocate(const char *name) {
4050 int fd, r;
4051 unsigned u;
4052
4053 /* Deallocate the VT if possible. If not possible
4054 * (i.e. because it is the active one), at least clear it
4055 * entirely (including the scrollback buffer) */
4056
4057 if (!startswith(name, "/dev/"))
4058 return -EINVAL;
4059
4060 if (!tty_is_vc(name)) {
4061 /* So this is not a VT. I guess we cannot deallocate
4062 * it then. But let's at least clear the screen */
4063
4064 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4065 if (fd < 0)
4066 return fd;
4067
4068 loop_write(fd,
4069 "\033[r" /* clear scrolling region */
4070 "\033[H" /* move home */
4071 "\033[2J", /* clear screen */
4072 10, false);
4073 safe_close(fd);
4074
4075 return 0;
4076 }
4077
4078 if (!startswith(name, "/dev/tty"))
4079 return -EINVAL;
4080
4081 r = safe_atou(name+8, &u);
4082 if (r < 0)
4083 return r;
4084
4085 if (u <= 0)
4086 return -EINVAL;
4087
4088 /* Try to deallocate */
4089 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4090 if (fd < 0)
4091 return fd;
4092
4093 r = ioctl(fd, VT_DISALLOCATE, u);
4094 safe_close(fd);
4095
4096 if (r >= 0)
4097 return 0;
4098
4099 if (errno != EBUSY)
4100 return -errno;
4101
4102 /* Couldn't deallocate, so let's clear it fully with
4103 * scrollback */
4104 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4105 if (fd < 0)
4106 return fd;
4107
4108 loop_write(fd,
4109 "\033[r" /* clear scrolling region */
4110 "\033[H" /* move home */
4111 "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4112 10, false);
4113 safe_close(fd);
4114
4115 return 0;
4116 }
4117
4118 int symlink_atomic(const char *from, const char *to) {
4119 _cleanup_free_ char *t = NULL;
4120
4121 assert(from);
4122 assert(to);
4123
4124 t = tempfn_random(to);
4125 if (!t)
4126 return -ENOMEM;
4127
4128 if (symlink(from, t) < 0)
4129 return -errno;
4130
4131 if (rename(t, to) < 0) {
4132 unlink_noerrno(t);
4133 return -errno;
4134 }
4135
4136 return 0;
4137 }
4138
4139 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
4140 _cleanup_free_ char *t = NULL;
4141
4142 assert(path);
4143
4144 t = tempfn_random(path);
4145 if (!t)
4146 return -ENOMEM;
4147
4148 if (mknod(t, mode, dev) < 0)
4149 return -errno;
4150
4151 if (rename(t, path) < 0) {
4152 unlink_noerrno(t);
4153 return -errno;
4154 }
4155
4156 return 0;
4157 }
4158
4159 int mkfifo_atomic(const char *path, mode_t mode) {
4160 _cleanup_free_ char *t = NULL;
4161
4162 assert(path);
4163
4164 t = tempfn_random(path);
4165 if (!t)
4166 return -ENOMEM;
4167
4168 if (mkfifo(t, mode) < 0)
4169 return -errno;
4170
4171 if (rename(t, path) < 0) {
4172 unlink_noerrno(t);
4173 return -errno;
4174 }
4175
4176 return 0;
4177 }
4178
4179 bool display_is_local(const char *display) {
4180 assert(display);
4181
4182 return
4183 display[0] == ':' &&
4184 display[1] >= '0' &&
4185 display[1] <= '9';
4186 }
4187
4188 int socket_from_display(const char *display, char **path) {
4189 size_t k;
4190 char *f, *c;
4191
4192 assert(display);
4193 assert(path);
4194
4195 if (!display_is_local(display))
4196 return -EINVAL;
4197
4198 k = strspn(display+1, "0123456789");
4199
4200 f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
4201 if (!f)
4202 return -ENOMEM;
4203
4204 c = stpcpy(f, "/tmp/.X11-unix/X");
4205 memcpy(c, display+1, k);
4206 c[k] = 0;
4207
4208 *path = f;
4209
4210 return 0;
4211 }
4212
4213 int get_user_creds(
4214 const char **username,
4215 uid_t *uid, gid_t *gid,
4216 const char **home,
4217 const char **shell) {
4218
4219 struct passwd *p;
4220 uid_t u;
4221
4222 assert(username);
4223 assert(*username);
4224
4225 /* We enforce some special rules for uid=0: in order to avoid
4226 * NSS lookups for root we hardcode its data. */
4227
4228 if (streq(*username, "root") || streq(*username, "0")) {
4229 *username = "root";
4230
4231 if (uid)
4232 *uid = 0;
4233
4234 if (gid)
4235 *gid = 0;
4236
4237 if (home)
4238 *home = "/root";
4239
4240 if (shell)
4241 *shell = "/bin/sh";
4242
4243 return 0;
4244 }
4245
4246 if (parse_uid(*username, &u) >= 0) {
4247 errno = 0;
4248 p = getpwuid(u);
4249
4250 /* If there are multiple users with the same id, make
4251 * sure to leave $USER to the configured value instead
4252 * of the first occurrence in the database. However if
4253 * the uid was configured by a numeric uid, then let's
4254 * pick the real username from /etc/passwd. */
4255 if (p)
4256 *username = p->pw_name;
4257 } else {
4258 errno = 0;
4259 p = getpwnam(*username);
4260 }
4261
4262 if (!p)
4263 return errno > 0 ? -errno : -ESRCH;
4264
4265 if (uid)
4266 *uid = p->pw_uid;
4267
4268 if (gid)
4269 *gid = p->pw_gid;
4270
4271 if (home)
4272 *home = p->pw_dir;
4273
4274 if (shell)
4275 *shell = p->pw_shell;
4276
4277 return 0;
4278 }
4279
4280 char* uid_to_name(uid_t uid) {
4281 struct passwd *p;
4282 char *r;
4283
4284 if (uid == 0)
4285 return strdup("root");
4286
4287 p = getpwuid(uid);
4288 if (p)
4289 return strdup(p->pw_name);
4290
4291 if (asprintf(&r, UID_FMT, uid) < 0)
4292 return NULL;
4293
4294 return r;
4295 }
4296
4297 char* gid_to_name(gid_t gid) {
4298 struct group *p;
4299 char *r;
4300
4301 if (gid == 0)
4302 return strdup("root");
4303
4304 p = getgrgid(gid);
4305 if (p)
4306 return strdup(p->gr_name);
4307
4308 if (asprintf(&r, GID_FMT, gid) < 0)
4309 return NULL;
4310
4311 return r;
4312 }
4313
4314 int get_group_creds(const char **groupname, gid_t *gid) {
4315 struct group *g;
4316 gid_t id;
4317
4318 assert(groupname);
4319
4320 /* We enforce some special rules for gid=0: in order to avoid
4321 * NSS lookups for root we hardcode its data. */
4322
4323 if (streq(*groupname, "root") || streq(*groupname, "0")) {
4324 *groupname = "root";
4325
4326 if (gid)
4327 *gid = 0;
4328
4329 return 0;
4330 }
4331
4332 if (parse_gid(*groupname, &id) >= 0) {
4333 errno = 0;
4334 g = getgrgid(id);
4335
4336 if (g)
4337 *groupname = g->gr_name;
4338 } else {
4339 errno = 0;
4340 g = getgrnam(*groupname);
4341 }
4342
4343 if (!g)
4344 return errno > 0 ? -errno : -ESRCH;
4345
4346 if (gid)
4347 *gid = g->gr_gid;
4348
4349 return 0;
4350 }
4351
4352 int in_gid(gid_t gid) {
4353 gid_t *gids;
4354 int ngroups_max, r, i;
4355
4356 if (getgid() == gid)
4357 return 1;
4358
4359 if (getegid() == gid)
4360 return 1;
4361
4362 ngroups_max = sysconf(_SC_NGROUPS_MAX);
4363 assert(ngroups_max > 0);
4364
4365 gids = alloca(sizeof(gid_t) * ngroups_max);
4366
4367 r = getgroups(ngroups_max, gids);
4368 if (r < 0)
4369 return -errno;
4370
4371 for (i = 0; i < r; i++)
4372 if (gids[i] == gid)
4373 return 1;
4374
4375 return 0;
4376 }
4377
4378 int in_group(const char *name) {
4379 int r;
4380 gid_t gid;
4381
4382 r = get_group_creds(&name, &gid);
4383 if (r < 0)
4384 return r;
4385
4386 return in_gid(gid);
4387 }
4388
4389 int glob_exists(const char *path) {
4390 _cleanup_globfree_ glob_t g = {};
4391 int k;
4392
4393 assert(path);
4394
4395 errno = 0;
4396 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4397
4398 if (k == GLOB_NOMATCH)
4399 return 0;
4400 else if (k == GLOB_NOSPACE)
4401 return -ENOMEM;
4402 else if (k == 0)
4403 return !strv_isempty(g.gl_pathv);
4404 else
4405 return errno ? -errno : -EIO;
4406 }
4407
4408 int glob_extend(char ***strv, const char *path) {
4409 _cleanup_globfree_ glob_t g = {};
4410 int k;
4411 char **p;
4412
4413 errno = 0;
4414 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4415
4416 if (k == GLOB_NOMATCH)
4417 return -ENOENT;
4418 else if (k == GLOB_NOSPACE)
4419 return -ENOMEM;
4420 else if (k != 0 || strv_isempty(g.gl_pathv))
4421 return errno ? -errno : -EIO;
4422
4423 STRV_FOREACH(p, g.gl_pathv) {
4424 k = strv_extend(strv, *p);
4425 if (k < 0)
4426 break;
4427 }
4428
4429 return k;
4430 }
4431
4432 int dirent_ensure_type(DIR *d, struct dirent *de) {
4433 struct stat st;
4434
4435 assert(d);
4436 assert(de);
4437
4438 if (de->d_type != DT_UNKNOWN)
4439 return 0;
4440
4441 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4442 return -errno;
4443
4444 de->d_type =
4445 S_ISREG(st.st_mode) ? DT_REG :
4446 S_ISDIR(st.st_mode) ? DT_DIR :
4447 S_ISLNK(st.st_mode) ? DT_LNK :
4448 S_ISFIFO(st.st_mode) ? DT_FIFO :
4449 S_ISSOCK(st.st_mode) ? DT_SOCK :
4450 S_ISCHR(st.st_mode) ? DT_CHR :
4451 S_ISBLK(st.st_mode) ? DT_BLK :
4452 DT_UNKNOWN;
4453
4454 return 0;
4455 }
4456
4457 int get_files_in_directory(const char *path, char ***list) {
4458 _cleanup_closedir_ DIR *d = NULL;
4459 size_t bufsize = 0, n = 0;
4460 _cleanup_strv_free_ char **l = NULL;
4461
4462 assert(path);
4463
4464 /* Returns all files in a directory in *list, and the number
4465 * of files as return value. If list is NULL returns only the
4466 * number. */
4467
4468 d = opendir(path);
4469 if (!d)
4470 return -errno;
4471
4472 for (;;) {
4473 struct dirent *de;
4474
4475 errno = 0;
4476 de = readdir(d);
4477 if (!de && errno != 0)
4478 return -errno;
4479 if (!de)
4480 break;
4481
4482 dirent_ensure_type(d, de);
4483
4484 if (!dirent_is_file(de))
4485 continue;
4486
4487 if (list) {
4488 /* one extra slot is needed for the terminating NULL */
4489 if (!GREEDY_REALLOC(l, bufsize, n + 2))
4490 return -ENOMEM;
4491
4492 l[n] = strdup(de->d_name);
4493 if (!l[n])
4494 return -ENOMEM;
4495
4496 l[++n] = NULL;
4497 } else
4498 n++;
4499 }
4500
4501 if (list) {
4502 *list = l;
4503 l = NULL; /* avoid freeing */
4504 }
4505
4506 return n;
4507 }
4508
4509 char *strjoin(const char *x, ...) {
4510 va_list ap;
4511 size_t l;
4512 char *r, *p;
4513
4514 va_start(ap, x);
4515
4516 if (x) {
4517 l = strlen(x);
4518
4519 for (;;) {
4520 const char *t;
4521 size_t n;
4522
4523 t = va_arg(ap, const char *);
4524 if (!t)
4525 break;
4526
4527 n = strlen(t);
4528 if (n > ((size_t) -1) - l) {
4529 va_end(ap);
4530 return NULL;
4531 }
4532
4533 l += n;
4534 }
4535 } else
4536 l = 0;
4537
4538 va_end(ap);
4539
4540 r = new(char, l+1);
4541 if (!r)
4542 return NULL;
4543
4544 if (x) {
4545 p = stpcpy(r, x);
4546
4547 va_start(ap, x);
4548
4549 for (;;) {
4550 const char *t;
4551
4552 t = va_arg(ap, const char *);
4553 if (!t)
4554 break;
4555
4556 p = stpcpy(p, t);
4557 }
4558
4559 va_end(ap);
4560 } else
4561 r[0] = 0;
4562
4563 return r;
4564 }
4565
4566 bool is_main_thread(void) {
4567 static thread_local int cached = 0;
4568
4569 if (_unlikely_(cached == 0))
4570 cached = getpid() == gettid() ? 1 : -1;
4571
4572 return cached > 0;
4573 }
4574
4575 int block_get_whole_disk(dev_t d, dev_t *ret) {
4576 char *p, *s;
4577 int r;
4578 unsigned n, m;
4579
4580 assert(ret);
4581
4582 /* If it has a queue this is good enough for us */
4583 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4584 return -ENOMEM;
4585
4586 r = access(p, F_OK);
4587 free(p);
4588
4589 if (r >= 0) {
4590 *ret = d;
4591 return 0;
4592 }
4593
4594 /* If it is a partition find the originating device */
4595 if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4596 return -ENOMEM;
4597
4598 r = access(p, F_OK);
4599 free(p);
4600
4601 if (r < 0)
4602 return -ENOENT;
4603
4604 /* Get parent dev_t */
4605 if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4606 return -ENOMEM;
4607
4608 r = read_one_line_file(p, &s);
4609 free(p);
4610
4611 if (r < 0)
4612 return r;
4613
4614 r = sscanf(s, "%u:%u", &m, &n);
4615 free(s);
4616
4617 if (r != 2)
4618 return -EINVAL;
4619
4620 /* Only return this if it is really good enough for us. */
4621 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4622 return -ENOMEM;
4623
4624 r = access(p, F_OK);
4625 free(p);
4626
4627 if (r >= 0) {
4628 *ret = makedev(m, n);
4629 return 0;
4630 }
4631
4632 return -ENOENT;
4633 }
4634
4635 int file_is_priv_sticky(const char *p) {
4636 struct stat st;
4637
4638 assert(p);
4639
4640 if (lstat(p, &st) < 0)
4641 return -errno;
4642
4643 return
4644 (st.st_uid == 0 || st.st_uid == getuid()) &&
4645 (st.st_mode & S_ISVTX);
4646 }
4647
4648 static const char *const ioprio_class_table[] = {
4649 [IOPRIO_CLASS_NONE] = "none",
4650 [IOPRIO_CLASS_RT] = "realtime",
4651 [IOPRIO_CLASS_BE] = "best-effort",
4652 [IOPRIO_CLASS_IDLE] = "idle"
4653 };
4654
4655 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4656
4657 static const char *const sigchld_code_table[] = {
4658 [CLD_EXITED] = "exited",
4659 [CLD_KILLED] = "killed",
4660 [CLD_DUMPED] = "dumped",
4661 [CLD_TRAPPED] = "trapped",
4662 [CLD_STOPPED] = "stopped",
4663 [CLD_CONTINUED] = "continued",
4664 };
4665
4666 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4667
4668 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4669 [LOG_FAC(LOG_KERN)] = "kern",
4670 [LOG_FAC(LOG_USER)] = "user",
4671 [LOG_FAC(LOG_MAIL)] = "mail",
4672 [LOG_FAC(LOG_DAEMON)] = "daemon",
4673 [LOG_FAC(LOG_AUTH)] = "auth",
4674 [LOG_FAC(LOG_SYSLOG)] = "syslog",
4675 [LOG_FAC(LOG_LPR)] = "lpr",
4676 [LOG_FAC(LOG_NEWS)] = "news",
4677 [LOG_FAC(LOG_UUCP)] = "uucp",
4678 [LOG_FAC(LOG_CRON)] = "cron",
4679 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
4680 [LOG_FAC(LOG_FTP)] = "ftp",
4681 [LOG_FAC(LOG_LOCAL0)] = "local0",
4682 [LOG_FAC(LOG_LOCAL1)] = "local1",
4683 [LOG_FAC(LOG_LOCAL2)] = "local2",
4684 [LOG_FAC(LOG_LOCAL3)] = "local3",
4685 [LOG_FAC(LOG_LOCAL4)] = "local4",
4686 [LOG_FAC(LOG_LOCAL5)] = "local5",
4687 [LOG_FAC(LOG_LOCAL6)] = "local6",
4688 [LOG_FAC(LOG_LOCAL7)] = "local7"
4689 };
4690
4691 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
4692
4693 static const char *const log_level_table[] = {
4694 [LOG_EMERG] = "emerg",
4695 [LOG_ALERT] = "alert",
4696 [LOG_CRIT] = "crit",
4697 [LOG_ERR] = "err",
4698 [LOG_WARNING] = "warning",
4699 [LOG_NOTICE] = "notice",
4700 [LOG_INFO] = "info",
4701 [LOG_DEBUG] = "debug"
4702 };
4703
4704 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
4705
4706 static const char* const sched_policy_table[] = {
4707 [SCHED_OTHER] = "other",
4708 [SCHED_BATCH] = "batch",
4709 [SCHED_IDLE] = "idle",
4710 [SCHED_FIFO] = "fifo",
4711 [SCHED_RR] = "rr"
4712 };
4713
4714 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
4715
4716 static const char* const rlimit_table[_RLIMIT_MAX] = {
4717 [RLIMIT_CPU] = "LimitCPU",
4718 [RLIMIT_FSIZE] = "LimitFSIZE",
4719 [RLIMIT_DATA] = "LimitDATA",
4720 [RLIMIT_STACK] = "LimitSTACK",
4721 [RLIMIT_CORE] = "LimitCORE",
4722 [RLIMIT_RSS] = "LimitRSS",
4723 [RLIMIT_NOFILE] = "LimitNOFILE",
4724 [RLIMIT_AS] = "LimitAS",
4725 [RLIMIT_NPROC] = "LimitNPROC",
4726 [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
4727 [RLIMIT_LOCKS] = "LimitLOCKS",
4728 [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
4729 [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
4730 [RLIMIT_NICE] = "LimitNICE",
4731 [RLIMIT_RTPRIO] = "LimitRTPRIO",
4732 [RLIMIT_RTTIME] = "LimitRTTIME"
4733 };
4734
4735 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
4736
4737 static const char* const ip_tos_table[] = {
4738 [IPTOS_LOWDELAY] = "low-delay",
4739 [IPTOS_THROUGHPUT] = "throughput",
4740 [IPTOS_RELIABILITY] = "reliability",
4741 [IPTOS_LOWCOST] = "low-cost",
4742 };
4743
4744 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
4745
4746 static const char *const __signal_table[] = {
4747 [SIGHUP] = "HUP",
4748 [SIGINT] = "INT",
4749 [SIGQUIT] = "QUIT",
4750 [SIGILL] = "ILL",
4751 [SIGTRAP] = "TRAP",
4752 [SIGABRT] = "ABRT",
4753 [SIGBUS] = "BUS",
4754 [SIGFPE] = "FPE",
4755 [SIGKILL] = "KILL",
4756 [SIGUSR1] = "USR1",
4757 [SIGSEGV] = "SEGV",
4758 [SIGUSR2] = "USR2",
4759 [SIGPIPE] = "PIPE",
4760 [SIGALRM] = "ALRM",
4761 [SIGTERM] = "TERM",
4762 #ifdef SIGSTKFLT
4763 [SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
4764 #endif
4765 [SIGCHLD] = "CHLD",
4766 [SIGCONT] = "CONT",
4767 [SIGSTOP] = "STOP",
4768 [SIGTSTP] = "TSTP",
4769 [SIGTTIN] = "TTIN",
4770 [SIGTTOU] = "TTOU",
4771 [SIGURG] = "URG",
4772 [SIGXCPU] = "XCPU",
4773 [SIGXFSZ] = "XFSZ",
4774 [SIGVTALRM] = "VTALRM",
4775 [SIGPROF] = "PROF",
4776 [SIGWINCH] = "WINCH",
4777 [SIGIO] = "IO",
4778 [SIGPWR] = "PWR",
4779 [SIGSYS] = "SYS"
4780 };
4781
4782 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
4783
4784 const char *signal_to_string(int signo) {
4785 static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
4786 const char *name;
4787
4788 name = __signal_to_string(signo);
4789 if (name)
4790 return name;
4791
4792 if (signo >= SIGRTMIN && signo <= SIGRTMAX)
4793 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
4794 else
4795 snprintf(buf, sizeof(buf), "%d", signo);
4796
4797 return buf;
4798 }
4799
4800 int signal_from_string(const char *s) {
4801 int signo;
4802 int offset = 0;
4803 unsigned u;
4804
4805 signo = __signal_from_string(s);
4806 if (signo > 0)
4807 return signo;
4808
4809 if (startswith(s, "RTMIN+")) {
4810 s += 6;
4811 offset = SIGRTMIN;
4812 }
4813 if (safe_atou(s, &u) >= 0) {
4814 signo = (int) u + offset;
4815 if (signo > 0 && signo < _NSIG)
4816 return signo;
4817 }
4818 return -1;
4819 }
4820
4821 bool kexec_loaded(void) {
4822 bool loaded = false;
4823 char *s;
4824
4825 if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
4826 if (s[0] == '1')
4827 loaded = true;
4828 free(s);
4829 }
4830 return loaded;
4831 }
4832
4833 int strdup_or_null(const char *a, char **b) {
4834 char *c;
4835
4836 assert(b);
4837
4838 if (!a) {
4839 *b = NULL;
4840 return 0;
4841 }
4842
4843 c = strdup(a);
4844 if (!c)
4845 return -ENOMEM;
4846
4847 *b = c;
4848 return 0;
4849 }
4850
4851 int prot_from_flags(int flags) {
4852
4853 switch (flags & O_ACCMODE) {
4854
4855 case O_RDONLY:
4856 return PROT_READ;
4857
4858 case O_WRONLY:
4859 return PROT_WRITE;
4860
4861 case O_RDWR:
4862 return PROT_READ|PROT_WRITE;
4863
4864 default:
4865 return -EINVAL;
4866 }
4867 }
4868
4869 char *format_bytes(char *buf, size_t l, off_t t) {
4870 unsigned i;
4871
4872 static const struct {
4873 const char *suffix;
4874 off_t factor;
4875 } table[] = {
4876 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4877 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4878 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
4879 { "G", 1024ULL*1024ULL*1024ULL },
4880 { "M", 1024ULL*1024ULL },
4881 { "K", 1024ULL },
4882 };
4883
4884 for (i = 0; i < ELEMENTSOF(table); i++) {
4885
4886 if (t >= table[i].factor) {
4887 snprintf(buf, l,
4888 "%llu.%llu%s",
4889 (unsigned long long) (t / table[i].factor),
4890 (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
4891 table[i].suffix);
4892
4893 goto finish;
4894 }
4895 }
4896
4897 snprintf(buf, l, "%lluB", (unsigned long long) t);
4898
4899 finish:
4900 buf[l-1] = 0;
4901 return buf;
4902
4903 }
4904
4905 void* memdup(const void *p, size_t l) {
4906 void *r;
4907
4908 assert(p);
4909
4910 r = malloc(l);
4911 if (!r)
4912 return NULL;
4913
4914 memcpy(r, p, l);
4915 return r;
4916 }
4917
4918 int fd_inc_sndbuf(int fd, size_t n) {
4919 int r, value;
4920 socklen_t l = sizeof(value);
4921
4922 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
4923 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
4924 return 0;
4925
4926 /* If we have the privileges we will ignore the kernel limit. */
4927
4928 value = (int) n;
4929 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
4930 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
4931 return -errno;
4932
4933 return 1;
4934 }
4935
4936 int fd_inc_rcvbuf(int fd, size_t n) {
4937 int r, value;
4938 socklen_t l = sizeof(value);
4939
4940 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
4941 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
4942 return 0;
4943
4944 /* If we have the privileges we will ignore the kernel limit. */
4945
4946 value = (int) n;
4947 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
4948 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
4949 return -errno;
4950 return 1;
4951 }
4952
4953 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
4954 pid_t parent_pid, agent_pid;
4955 int fd;
4956 bool stdout_is_tty, stderr_is_tty;
4957 unsigned n, i;
4958 va_list ap;
4959 char **l;
4960
4961 assert(pid);
4962 assert(path);
4963
4964 parent_pid = getpid();
4965
4966 /* Spawns a temporary TTY agent, making sure it goes away when
4967 * we go away */
4968
4969 agent_pid = fork();
4970 if (agent_pid < 0)
4971 return -errno;
4972
4973 if (agent_pid != 0) {
4974 *pid = agent_pid;
4975 return 0;
4976 }
4977
4978 /* In the child:
4979 *
4980 * Make sure the agent goes away when the parent dies */
4981 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
4982 _exit(EXIT_FAILURE);
4983
4984 /* Check whether our parent died before we were able
4985 * to set the death signal */
4986 if (getppid() != parent_pid)
4987 _exit(EXIT_SUCCESS);
4988
4989 /* Don't leak fds to the agent */
4990 close_all_fds(except, n_except);
4991
4992 stdout_is_tty = isatty(STDOUT_FILENO);
4993 stderr_is_tty = isatty(STDERR_FILENO);
4994
4995 if (!stdout_is_tty || !stderr_is_tty) {
4996 /* Detach from stdout/stderr. and reopen
4997 * /dev/tty for them. This is important to
4998 * ensure that when systemctl is started via
4999 * popen() or a similar call that expects to
5000 * read EOF we actually do generate EOF and
5001 * not delay this indefinitely by because we
5002 * keep an unused copy of stdin around. */
5003 fd = open("/dev/tty", O_WRONLY);
5004 if (fd < 0) {
5005 log_error("Failed to open /dev/tty: %m");
5006 _exit(EXIT_FAILURE);
5007 }
5008
5009 if (!stdout_is_tty)
5010 dup2(fd, STDOUT_FILENO);
5011
5012 if (!stderr_is_tty)
5013 dup2(fd, STDERR_FILENO);
5014
5015 if (fd > 2)
5016 close(fd);
5017 }
5018
5019 /* Count arguments */
5020 va_start(ap, path);
5021 for (n = 0; va_arg(ap, char*); n++)
5022 ;
5023 va_end(ap);
5024
5025 /* Allocate strv */
5026 l = alloca(sizeof(char *) * (n + 1));
5027
5028 /* Fill in arguments */
5029 va_start(ap, path);
5030 for (i = 0; i <= n; i++)
5031 l[i] = va_arg(ap, char*);
5032 va_end(ap);
5033
5034 execv(path, l);
5035 _exit(EXIT_FAILURE);
5036 }
5037
5038 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5039 struct rlimit highest, fixed;
5040
5041 assert(rlim);
5042
5043 if (setrlimit(resource, rlim) >= 0)
5044 return 0;
5045
5046 if (errno != EPERM)
5047 return -errno;
5048
5049 /* So we failed to set the desired setrlimit, then let's try
5050 * to get as close as we can */
5051 assert_se(getrlimit(resource, &highest) == 0);
5052
5053 fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5054 fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5055
5056 if (setrlimit(resource, &fixed) < 0)
5057 return -errno;
5058
5059 return 0;
5060 }
5061
5062 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5063 _cleanup_fclose_ FILE *f = NULL;
5064 char *value = NULL;
5065 int r;
5066 bool done = false;
5067 size_t l;
5068 const char *path;
5069
5070 assert(pid >= 0);
5071 assert(field);
5072 assert(_value);
5073
5074 path = procfs_file_alloca(pid, "environ");
5075
5076 f = fopen(path, "re");
5077 if (!f)
5078 return -errno;
5079
5080 l = strlen(field);
5081 r = 0;
5082
5083 do {
5084 char line[LINE_MAX];
5085 unsigned i;
5086
5087 for (i = 0; i < sizeof(line)-1; i++) {
5088 int c;
5089
5090 c = getc(f);
5091 if (_unlikely_(c == EOF)) {
5092 done = true;
5093 break;
5094 } else if (c == 0)
5095 break;
5096
5097 line[i] = c;
5098 }
5099 line[i] = 0;
5100
5101 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5102 value = strdup(line + l + 1);
5103 if (!value)
5104 return -ENOMEM;
5105
5106 r = 1;
5107 break;
5108 }
5109
5110 } while (!done);
5111
5112 *_value = value;
5113 return r;
5114 }
5115
5116 bool is_valid_documentation_url(const char *url) {
5117 assert(url);
5118
5119 if (startswith(url, "http://") && url[7])
5120 return true;
5121
5122 if (startswith(url, "https://") && url[8])
5123 return true;
5124
5125 if (startswith(url, "file:") && url[5])
5126 return true;
5127
5128 if (startswith(url, "info:") && url[5])
5129 return true;
5130
5131 if (startswith(url, "man:") && url[4])
5132 return true;
5133
5134 return false;
5135 }
5136
5137 bool in_initrd(void) {
5138 static int saved = -1;
5139 struct statfs s;
5140
5141 if (saved >= 0)
5142 return saved;
5143
5144 /* We make two checks here:
5145 *
5146 * 1. the flag file /etc/initrd-release must exist
5147 * 2. the root file system must be a memory file system
5148 *
5149 * The second check is extra paranoia, since misdetecting an
5150 * initrd can have bad bad consequences due the initrd
5151 * emptying when transititioning to the main systemd.
5152 */
5153
5154 saved = access("/etc/initrd-release", F_OK) >= 0 &&
5155 statfs("/", &s) >= 0 &&
5156 is_temporary_fs(&s);
5157
5158 return saved;
5159 }
5160
5161 void warn_melody(void) {
5162 _cleanup_close_ int fd = -1;
5163
5164 fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5165 if (fd < 0)
5166 return;
5167
5168 /* Yeah, this is synchronous. Kinda sucks. But well... */
5169
5170 ioctl(fd, KIOCSOUND, (int)(1193180/440));
5171 usleep(125*USEC_PER_MSEC);
5172
5173 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5174 usleep(125*USEC_PER_MSEC);
5175
5176 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5177 usleep(125*USEC_PER_MSEC);
5178
5179 ioctl(fd, KIOCSOUND, 0);
5180 }
5181
5182 int make_console_stdio(void) {
5183 int fd, r;
5184
5185 /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5186
5187 fd = acquire_terminal("/dev/console", false, true, true, (usec_t) -1);
5188 if (fd < 0) {
5189 log_error("Failed to acquire terminal: %s", strerror(-fd));
5190 return fd;
5191 }
5192
5193 r = make_stdio(fd);
5194 if (r < 0) {
5195 log_error("Failed to duplicate terminal fd: %s", strerror(-r));
5196 return r;
5197 }
5198
5199 return 0;
5200 }
5201
5202 int get_home_dir(char **_h) {
5203 struct passwd *p;
5204 const char *e;
5205 char *h;
5206 uid_t u;
5207
5208 assert(_h);
5209
5210 /* Take the user specified one */
5211 e = getenv("HOME");
5212 if (e) {
5213 h = strdup(e);
5214 if (!h)
5215 return -ENOMEM;
5216
5217 *_h = h;
5218 return 0;
5219 }
5220
5221 /* Hardcode home directory for root to avoid NSS */
5222 u = getuid();
5223 if (u == 0) {
5224 h = strdup("/root");
5225 if (!h)
5226 return -ENOMEM;
5227
5228 *_h = h;
5229 return 0;
5230 }
5231
5232 /* Check the database... */
5233 errno = 0;
5234 p = getpwuid(u);
5235 if (!p)
5236 return errno > 0 ? -errno : -ESRCH;
5237
5238 if (!path_is_absolute(p->pw_dir))
5239 return -EINVAL;
5240
5241 h = strdup(p->pw_dir);
5242 if (!h)
5243 return -ENOMEM;
5244
5245 *_h = h;
5246 return 0;
5247 }
5248
5249 int get_shell(char **_s) {
5250 struct passwd *p;
5251 const char *e;
5252 char *s;
5253 uid_t u;
5254
5255 assert(_s);
5256
5257 /* Take the user specified one */
5258 e = getenv("SHELL");
5259 if (e) {
5260 s = strdup(e);
5261 if (!s)
5262 return -ENOMEM;
5263
5264 *_s = s;
5265 return 0;
5266 }
5267
5268 /* Hardcode home directory for root to avoid NSS */
5269 u = getuid();
5270 if (u == 0) {
5271 s = strdup("/bin/sh");
5272 if (!s)
5273 return -ENOMEM;
5274
5275 *_s = s;
5276 return 0;
5277 }
5278
5279 /* Check the database... */
5280 errno = 0;
5281 p = getpwuid(u);
5282 if (!p)
5283 return errno > 0 ? -errno : -ESRCH;
5284
5285 if (!path_is_absolute(p->pw_shell))
5286 return -EINVAL;
5287
5288 s = strdup(p->pw_shell);
5289 if (!s)
5290 return -ENOMEM;
5291
5292 *_s = s;
5293 return 0;
5294 }
5295
5296 bool filename_is_safe(const char *p) {
5297
5298 if (isempty(p))
5299 return false;
5300
5301 if (strchr(p, '/'))
5302 return false;
5303
5304 if (streq(p, "."))
5305 return false;
5306
5307 if (streq(p, ".."))
5308 return false;
5309
5310 if (strlen(p) > FILENAME_MAX)
5311 return false;
5312
5313 return true;
5314 }
5315
5316 bool string_is_safe(const char *p) {
5317 const char *t;
5318
5319 assert(p);
5320
5321 for (t = p; *t; t++) {
5322 if (*t > 0 && *t < ' ')
5323 return false;
5324
5325 if (strchr("\\\"\'", *t))
5326 return false;
5327 }
5328
5329 return true;
5330 }
5331
5332 /**
5333 * Check if a string contains control characters.
5334 * Spaces and tabs are not considered control characters.
5335 */
5336 bool string_has_cc(const char *p) {
5337 const char *t;
5338
5339 assert(p);
5340
5341 for (t = p; *t; t++)
5342 if (*t > 0 && *t < ' ' && *t != '\t')
5343 return true;
5344
5345 return false;
5346 }
5347
5348 bool path_is_safe(const char *p) {
5349
5350 if (isempty(p))
5351 return false;
5352
5353 if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5354 return false;
5355
5356 if (strlen(p) > PATH_MAX)
5357 return false;
5358
5359 /* The following two checks are not really dangerous, but hey, they still are confusing */
5360 if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5361 return false;
5362
5363 if (strstr(p, "//"))
5364 return false;
5365
5366 return true;
5367 }
5368
5369 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5370 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5371 int (*compar) (const void *, const void *, void *), void *arg) {
5372 size_t l, u, idx;
5373 const void *p;
5374 int comparison;
5375
5376 l = 0;
5377 u = nmemb;
5378 while (l < u) {
5379 idx = (l + u) / 2;
5380 p = (void *)(((const char *) base) + (idx * size));
5381 comparison = compar(key, p, arg);
5382 if (comparison < 0)
5383 u = idx;
5384 else if (comparison > 0)
5385 l = idx + 1;
5386 else
5387 return (void *)p;
5388 }
5389 return NULL;
5390 }
5391
5392 bool is_locale_utf8(void) {
5393 const char *set;
5394 static int cached_answer = -1;
5395
5396 if (cached_answer >= 0)
5397 goto out;
5398
5399 if (!setlocale(LC_ALL, "")) {
5400 cached_answer = true;
5401 goto out;
5402 }
5403
5404 set = nl_langinfo(CODESET);
5405 if (!set) {
5406 cached_answer = true;
5407 goto out;
5408 }
5409
5410 if (streq(set, "UTF-8")) {
5411 cached_answer = true;
5412 goto out;
5413 }
5414
5415 /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5416 * unset and everything can do to UTF-8 nowadays. */
5417 set = setlocale(LC_CTYPE, NULL);
5418 if (!set) {
5419 cached_answer = true;
5420 goto out;
5421 }
5422
5423 /* Check result, but ignore the result if C was set
5424 * explicitly. */
5425 cached_answer =
5426 streq(set, "C") &&
5427 !getenv("LC_ALL") &&
5428 !getenv("LC_CTYPE") &&
5429 !getenv("LANG");
5430
5431 out:
5432 return (bool) cached_answer;
5433 }
5434
5435 const char *draw_special_char(DrawSpecialChar ch) {
5436 static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5437
5438 /* UTF-8 */ {
5439 [DRAW_TREE_VERTICAL] = "\342\224\202 ", /* │ */
5440 [DRAW_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
5441 [DRAW_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
5442 [DRAW_TREE_SPACE] = " ", /* */
5443 [DRAW_TRIANGULAR_BULLET] = "\342\200\243", /* ‣ */
5444 [DRAW_BLACK_CIRCLE] = "\342\227\217", /* ● */
5445 [DRAW_ARROW] = "\342\206\222", /* → */
5446 [DRAW_DASH] = "\342\200\223", /* – */
5447 },
5448
5449 /* ASCII fallback */ {
5450 [DRAW_TREE_VERTICAL] = "| ",
5451 [DRAW_TREE_BRANCH] = "|-",
5452 [DRAW_TREE_RIGHT] = "`-",
5453 [DRAW_TREE_SPACE] = " ",
5454 [DRAW_TRIANGULAR_BULLET] = ">",
5455 [DRAW_BLACK_CIRCLE] = "*",
5456 [DRAW_ARROW] = "->",
5457 [DRAW_DASH] = "-",
5458 }
5459 };
5460
5461 return draw_table[!is_locale_utf8()][ch];
5462 }
5463
5464 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5465 const char *f;
5466 char *t, *r;
5467 size_t l, old_len, new_len;
5468
5469 assert(text);
5470 assert(old_string);
5471 assert(new_string);
5472
5473 old_len = strlen(old_string);
5474 new_len = strlen(new_string);
5475
5476 l = strlen(text);
5477 r = new(char, l+1);
5478 if (!r)
5479 return NULL;
5480
5481 f = text;
5482 t = r;
5483 while (*f) {
5484 char *a;
5485 size_t d, nl;
5486
5487 if (!startswith(f, old_string)) {
5488 *(t++) = *(f++);
5489 continue;
5490 }
5491
5492 d = t - r;
5493 nl = l - old_len + new_len;
5494 a = realloc(r, nl + 1);
5495 if (!a)
5496 goto oom;
5497
5498 l = nl;
5499 r = a;
5500 t = r + d;
5501
5502 t = stpcpy(t, new_string);
5503 f += old_len;
5504 }
5505
5506 *t = 0;
5507 return r;
5508
5509 oom:
5510 free(r);
5511 return NULL;
5512 }
5513
5514 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5515 const char *i, *begin = NULL;
5516 enum {
5517 STATE_OTHER,
5518 STATE_ESCAPE,
5519 STATE_BRACKET
5520 } state = STATE_OTHER;
5521 char *obuf = NULL;
5522 size_t osz = 0, isz;
5523 FILE *f;
5524
5525 assert(ibuf);
5526 assert(*ibuf);
5527
5528 /* Strips ANSI color and replaces TABs by 8 spaces */
5529
5530 isz = _isz ? *_isz : strlen(*ibuf);
5531
5532 f = open_memstream(&obuf, &osz);
5533 if (!f)
5534 return NULL;
5535
5536 for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5537
5538 switch (state) {
5539
5540 case STATE_OTHER:
5541 if (i >= *ibuf + isz) /* EOT */
5542 break;
5543 else if (*i == '\x1B')
5544 state = STATE_ESCAPE;
5545 else if (*i == '\t')
5546 fputs(" ", f);
5547 else
5548 fputc(*i, f);
5549 break;
5550
5551 case STATE_ESCAPE:
5552 if (i >= *ibuf + isz) { /* EOT */
5553 fputc('\x1B', f);
5554 break;
5555 } else if (*i == '[') {
5556 state = STATE_BRACKET;
5557 begin = i + 1;
5558 } else {
5559 fputc('\x1B', f);
5560 fputc(*i, f);
5561 state = STATE_OTHER;
5562 }
5563
5564 break;
5565
5566 case STATE_BRACKET:
5567
5568 if (i >= *ibuf + isz || /* EOT */
5569 (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5570 fputc('\x1B', f);
5571 fputc('[', f);
5572 state = STATE_OTHER;
5573 i = begin-1;
5574 } else if (*i == 'm')
5575 state = STATE_OTHER;
5576 break;
5577 }
5578 }
5579
5580 if (ferror(f)) {
5581 fclose(f);
5582 free(obuf);
5583 return NULL;
5584 }
5585
5586 fclose(f);
5587
5588 free(*ibuf);
5589 *ibuf = obuf;
5590
5591 if (_isz)
5592 *_isz = osz;
5593
5594 return obuf;
5595 }
5596
5597 int on_ac_power(void) {
5598 bool found_offline = false, found_online = false;
5599 _cleanup_closedir_ DIR *d = NULL;
5600
5601 d = opendir("/sys/class/power_supply");
5602 if (!d)
5603 return -errno;
5604
5605 for (;;) {
5606 struct dirent *de;
5607 _cleanup_close_ int fd = -1, device = -1;
5608 char contents[6];
5609 ssize_t n;
5610
5611 errno = 0;
5612 de = readdir(d);
5613 if (!de && errno != 0)
5614 return -errno;
5615
5616 if (!de)
5617 break;
5618
5619 if (ignore_file(de->d_name))
5620 continue;
5621
5622 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5623 if (device < 0) {
5624 if (errno == ENOENT || errno == ENOTDIR)
5625 continue;
5626
5627 return -errno;
5628 }
5629
5630 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5631 if (fd < 0) {
5632 if (errno == ENOENT)
5633 continue;
5634
5635 return -errno;
5636 }
5637
5638 n = read(fd, contents, sizeof(contents));
5639 if (n < 0)
5640 return -errno;
5641
5642 if (n != 6 || memcmp(contents, "Mains\n", 6))
5643 continue;
5644
5645 safe_close(fd);
5646 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5647 if (fd < 0) {
5648 if (errno == ENOENT)
5649 continue;
5650
5651 return -errno;
5652 }
5653
5654 n = read(fd, contents, sizeof(contents));
5655 if (n < 0)
5656 return -errno;
5657
5658 if (n != 2 || contents[1] != '\n')
5659 return -EIO;
5660
5661 if (contents[0] == '1') {
5662 found_online = true;
5663 break;
5664 } else if (contents[0] == '0')
5665 found_offline = true;
5666 else
5667 return -EIO;
5668 }
5669
5670 return found_online || !found_offline;
5671 }
5672
5673 static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
5674 char **i;
5675
5676 assert(path);
5677 assert(mode);
5678 assert(_f);
5679
5680 if (!path_strv_resolve_uniq(search, root))
5681 return -ENOMEM;
5682
5683 STRV_FOREACH(i, search) {
5684 _cleanup_free_ char *p = NULL;
5685 FILE *f;
5686
5687 if (root)
5688 p = strjoin(root, *i, "/", path, NULL);
5689 else
5690 p = strjoin(*i, "/", path, NULL);
5691 if (!p)
5692 return -ENOMEM;
5693
5694 f = fopen(p, mode);
5695 if (f) {
5696 *_f = f;
5697 return 0;
5698 }
5699
5700 if (errno != ENOENT)
5701 return -errno;
5702 }
5703
5704 return -ENOENT;
5705 }
5706
5707 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
5708 _cleanup_strv_free_ char **copy = NULL;
5709
5710 assert(path);
5711 assert(mode);
5712 assert(_f);
5713
5714 if (path_is_absolute(path)) {
5715 FILE *f;
5716
5717 f = fopen(path, mode);
5718 if (f) {
5719 *_f = f;
5720 return 0;
5721 }
5722
5723 return -errno;
5724 }
5725
5726 copy = strv_copy((char**) search);
5727 if (!copy)
5728 return -ENOMEM;
5729
5730 return search_and_fopen_internal(path, mode, root, copy, _f);
5731 }
5732
5733 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
5734 _cleanup_strv_free_ char **s = NULL;
5735
5736 if (path_is_absolute(path)) {
5737 FILE *f;
5738
5739 f = fopen(path, mode);
5740 if (f) {
5741 *_f = f;
5742 return 0;
5743 }
5744
5745 return -errno;
5746 }
5747
5748 s = strv_split_nulstr(search);
5749 if (!s)
5750 return -ENOMEM;
5751
5752 return search_and_fopen_internal(path, mode, root, s, _f);
5753 }
5754
5755 char *strextend(char **x, ...) {
5756 va_list ap;
5757 size_t f, l;
5758 char *r, *p;
5759
5760 assert(x);
5761
5762 l = f = *x ? strlen(*x) : 0;
5763
5764 va_start(ap, x);
5765 for (;;) {
5766 const char *t;
5767 size_t n;
5768
5769 t = va_arg(ap, const char *);
5770 if (!t)
5771 break;
5772
5773 n = strlen(t);
5774 if (n > ((size_t) -1) - l) {
5775 va_end(ap);
5776 return NULL;
5777 }
5778
5779 l += n;
5780 }
5781 va_end(ap);
5782
5783 r = realloc(*x, l+1);
5784 if (!r)
5785 return NULL;
5786
5787 p = r + f;
5788
5789 va_start(ap, x);
5790 for (;;) {
5791 const char *t;
5792
5793 t = va_arg(ap, const char *);
5794 if (!t)
5795 break;
5796
5797 p = stpcpy(p, t);
5798 }
5799 va_end(ap);
5800
5801 *p = 0;
5802 *x = r;
5803
5804 return r + l;
5805 }
5806
5807 char *strrep(const char *s, unsigned n) {
5808 size_t l;
5809 char *r, *p;
5810 unsigned i;
5811
5812 assert(s);
5813
5814 l = strlen(s);
5815 p = r = malloc(l * n + 1);
5816 if (!r)
5817 return NULL;
5818
5819 for (i = 0; i < n; i++)
5820 p = stpcpy(p, s);
5821
5822 *p = 0;
5823 return r;
5824 }
5825
5826 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
5827 size_t a, newalloc;
5828 void *q;
5829
5830 assert(p);
5831 assert(allocated);
5832
5833 if (*allocated >= need)
5834 return *p;
5835
5836 newalloc = MAX(need * 2, 64u / size);
5837 a = newalloc * size;
5838
5839 /* check for overflows */
5840 if (a < size * need)
5841 return NULL;
5842
5843 q = realloc(*p, a);
5844 if (!q)
5845 return NULL;
5846
5847 *p = q;
5848 *allocated = newalloc;
5849 return q;
5850 }
5851
5852 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
5853 size_t prev;
5854 uint8_t *q;
5855
5856 assert(p);
5857 assert(allocated);
5858
5859 prev = *allocated;
5860
5861 q = greedy_realloc(p, allocated, need, size);
5862 if (!q)
5863 return NULL;
5864
5865 if (*allocated > prev)
5866 memzero(q + prev * size, (*allocated - prev) * size);
5867
5868 return q;
5869 }
5870
5871 bool id128_is_valid(const char *s) {
5872 size_t i, l;
5873
5874 l = strlen(s);
5875 if (l == 32) {
5876
5877 /* Simple formatted 128bit hex string */
5878
5879 for (i = 0; i < l; i++) {
5880 char c = s[i];
5881
5882 if (!(c >= '0' && c <= '9') &&
5883 !(c >= 'a' && c <= 'z') &&
5884 !(c >= 'A' && c <= 'Z'))
5885 return false;
5886 }
5887
5888 } else if (l == 36) {
5889
5890 /* Formatted UUID */
5891
5892 for (i = 0; i < l; i++) {
5893 char c = s[i];
5894
5895 if ((i == 8 || i == 13 || i == 18 || i == 23)) {
5896 if (c != '-')
5897 return false;
5898 } else {
5899 if (!(c >= '0' && c <= '9') &&
5900 !(c >= 'a' && c <= 'z') &&
5901 !(c >= 'A' && c <= 'Z'))
5902 return false;
5903 }
5904 }
5905
5906 } else
5907 return false;
5908
5909 return true;
5910 }
5911
5912 int split_pair(const char *s, const char *sep, char **l, char **r) {
5913 char *x, *a, *b;
5914
5915 assert(s);
5916 assert(sep);
5917 assert(l);
5918 assert(r);
5919
5920 if (isempty(sep))
5921 return -EINVAL;
5922
5923 x = strstr(s, sep);
5924 if (!x)
5925 return -EINVAL;
5926
5927 a = strndup(s, x - s);
5928 if (!a)
5929 return -ENOMEM;
5930
5931 b = strdup(x + strlen(sep));
5932 if (!b) {
5933 free(a);
5934 return -ENOMEM;
5935 }
5936
5937 *l = a;
5938 *r = b;
5939
5940 return 0;
5941 }
5942
5943 int shall_restore_state(void) {
5944 _cleanup_free_ char *line = NULL;
5945 char *w, *state;
5946 size_t l;
5947 int r;
5948
5949 r = proc_cmdline(&line);
5950 if (r < 0)
5951 return r;
5952 if (r == 0) /* Container ... */
5953 return 1;
5954
5955 r = 1;
5956
5957 FOREACH_WORD_QUOTED(w, l, line, state) {
5958 const char *e;
5959 char n[l+1];
5960 int k;
5961
5962 memcpy(n, w, l);
5963 n[l] = 0;
5964
5965 e = startswith(n, "systemd.restore_state=");
5966 if (!e)
5967 continue;
5968
5969 k = parse_boolean(e);
5970 if (k >= 0)
5971 r = k;
5972 }
5973
5974 return r;
5975 }
5976
5977 int proc_cmdline(char **ret) {
5978 int r;
5979
5980 if (detect_container(NULL) > 0) {
5981 char *buf = NULL, *p;
5982 size_t sz = 0;
5983
5984 r = read_full_file("/proc/1/cmdline", &buf, &sz);
5985 if (r < 0)
5986 return r;
5987
5988 for (p = buf; p + 1 < buf + sz; p++)
5989 if (*p == 0)
5990 *p = ' ';
5991
5992 *p = 0;
5993 *ret = buf;
5994 return 1;
5995 }
5996
5997 r = read_one_line_file("/proc/cmdline", ret);
5998 if (r < 0)
5999 return r;
6000
6001 return 1;
6002 }
6003
6004 int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
6005 _cleanup_free_ char *line = NULL;
6006 char *w, *state;
6007 size_t l;
6008 int r;
6009
6010 assert(parse_item);
6011
6012 r = proc_cmdline(&line);
6013 if (r < 0)
6014 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
6015 if (r <= 0)
6016 return 0;
6017
6018 FOREACH_WORD_QUOTED(w, l, line, state) {
6019 char word[l+1], *value;
6020
6021 memcpy(word, w, l);
6022 word[l] = 0;
6023
6024 /* Filter out arguments that are intended only for the
6025 * initrd */
6026 if (!in_initrd() && startswith(word, "rd."))
6027 continue;
6028
6029 value = strchr(word, '=');
6030 if (value)
6031 *(value++) = 0;
6032
6033 r = parse_item(word, value);
6034 if (r < 0)
6035 return r;
6036 }
6037
6038 return 0;
6039 }
6040
6041 int container_get_leader(const char *machine, pid_t *pid) {
6042 _cleanup_free_ char *s = NULL, *class = NULL;
6043 const char *p;
6044 pid_t leader;
6045 int r;
6046
6047 assert(machine);
6048 assert(pid);
6049
6050 p = strappenda("/run/systemd/machines/", machine);
6051 r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
6052 if (r == -ENOENT)
6053 return -EHOSTDOWN;
6054 if (r < 0)
6055 return r;
6056 if (!s)
6057 return -EIO;
6058
6059 if (!streq_ptr(class, "container"))
6060 return -EIO;
6061
6062 r = parse_pid(s, &leader);
6063 if (r < 0)
6064 return r;
6065 if (leader <= 1)
6066 return -EIO;
6067
6068 *pid = leader;
6069 return 0;
6070 }
6071
6072 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *root_fd) {
6073 _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, netnsfd = -1;
6074 int rfd = -1;
6075
6076 assert(pid >= 0);
6077
6078 if (mntns_fd) {
6079 const char *mntns;
6080
6081 mntns = procfs_file_alloca(pid, "ns/mnt");
6082 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6083 if (mntnsfd < 0)
6084 return -errno;
6085 }
6086
6087 if (pidns_fd) {
6088 const char *pidns;
6089
6090 pidns = procfs_file_alloca(pid, "ns/pid");
6091 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6092 if (pidnsfd < 0)
6093 return -errno;
6094 }
6095
6096 if (netns_fd) {
6097 const char *netns;
6098
6099 netns = procfs_file_alloca(pid, "ns/net");
6100 netnsfd = open(netns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6101 if (netnsfd < 0)
6102 return -errno;
6103 }
6104
6105 if (root_fd) {
6106 const char *root;
6107
6108 root = procfs_file_alloca(pid, "root");
6109 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6110 if (rfd < 0)
6111 return -errno;
6112 }
6113
6114 if (pidns_fd)
6115 *pidns_fd = pidnsfd;
6116
6117 if (mntns_fd)
6118 *mntns_fd = mntnsfd;
6119
6120 if (netns_fd)
6121 *netns_fd = netnsfd;
6122
6123 if (root_fd)
6124 *root_fd = rfd;
6125
6126 pidnsfd = mntnsfd = netnsfd = -1;
6127
6128 return 0;
6129 }
6130
6131 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int root_fd) {
6132
6133 if (pidns_fd >= 0)
6134 if (setns(pidns_fd, CLONE_NEWPID) < 0)
6135 return -errno;
6136
6137 if (mntns_fd >= 0)
6138 if (setns(mntns_fd, CLONE_NEWNS) < 0)
6139 return -errno;
6140
6141 if (netns_fd >= 0)
6142 if (setns(netns_fd, CLONE_NEWNET) < 0)
6143 return -errno;
6144
6145 if (root_fd >= 0) {
6146 if (fchdir(root_fd) < 0)
6147 return -errno;
6148
6149 if (chroot(".") < 0)
6150 return -errno;
6151 }
6152
6153 if (setresgid(0, 0, 0) < 0)
6154 return -errno;
6155
6156 if (setgroups(0, NULL) < 0)
6157 return -errno;
6158
6159 if (setresuid(0, 0, 0) < 0)
6160 return -errno;
6161
6162 return 0;
6163 }
6164
6165 bool pid_is_unwaited(pid_t pid) {
6166 /* Checks whether a PID is still valid at all, including a zombie */
6167
6168 if (pid <= 0)
6169 return false;
6170
6171 if (kill(pid, 0) >= 0)
6172 return true;
6173
6174 return errno != ESRCH;
6175 }
6176
6177 bool pid_is_alive(pid_t pid) {
6178 int r;
6179
6180 /* Checks whether a PID is still valid and not a zombie */
6181
6182 if (pid <= 0)
6183 return false;
6184
6185 r = get_process_state(pid);
6186 if (r == -ENOENT || r == 'Z')
6187 return false;
6188
6189 return true;
6190 }
6191
6192 int getpeercred(int fd, struct ucred *ucred) {
6193 socklen_t n = sizeof(struct ucred);
6194 struct ucred u;
6195 int r;
6196
6197 assert(fd >= 0);
6198 assert(ucred);
6199
6200 r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
6201 if (r < 0)
6202 return -errno;
6203
6204 if (n != sizeof(struct ucred))
6205 return -EIO;
6206
6207 /* Check if the data is actually useful and not suppressed due
6208 * to namespacing issues */
6209 if (u.pid <= 0)
6210 return -ENODATA;
6211
6212 *ucred = u;
6213 return 0;
6214 }
6215
6216 int getpeersec(int fd, char **ret) {
6217 socklen_t n = 64;
6218 char *s;
6219 int r;
6220
6221 assert(fd >= 0);
6222 assert(ret);
6223
6224 s = new0(char, n);
6225 if (!s)
6226 return -ENOMEM;
6227
6228 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6229 if (r < 0) {
6230 free(s);
6231
6232 if (errno != ERANGE)
6233 return -errno;
6234
6235 s = new0(char, n);
6236 if (!s)
6237 return -ENOMEM;
6238
6239 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6240 if (r < 0) {
6241 free(s);
6242 return -errno;
6243 }
6244 }
6245
6246 if (isempty(s)) {
6247 free(s);
6248 return -ENOTSUP;
6249 }
6250
6251 *ret = s;
6252 return 0;
6253 }
6254
6255 /* This is much like like mkostemp() but is subject to umask(). */
6256 int mkostemp_safe(char *pattern, int flags) {
6257 _cleanup_umask_ mode_t u;
6258 int fd;
6259
6260 assert(pattern);
6261
6262 u = umask(077);
6263
6264 fd = mkostemp(pattern, flags);
6265 if (fd < 0)
6266 return -errno;
6267
6268 return fd;
6269 }
6270
6271 int open_tmpfile(const char *path, int flags) {
6272 char *p;
6273 int fd;
6274
6275 assert(path);
6276
6277 #ifdef O_TMPFILE
6278 /* Try O_TMPFILE first, if it is supported */
6279 fd = open(path, flags|O_TMPFILE, S_IRUSR|S_IWUSR);
6280 if (fd >= 0)
6281 return fd;
6282 #endif
6283
6284 /* Fall back to unguessable name + unlinking */
6285 p = strappenda(path, "/systemd-tmp-XXXXXX");
6286
6287 fd = mkostemp_safe(p, flags);
6288 if (fd < 0)
6289 return fd;
6290
6291 unlink(p);
6292 return fd;
6293 }
6294
6295 int fd_warn_permissions(const char *path, int fd) {
6296 struct stat st;
6297
6298 if (fstat(fd, &st) < 0)
6299 return -errno;
6300
6301 if (st.st_mode & 0111)
6302 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
6303
6304 if (st.st_mode & 0002)
6305 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
6306
6307 if (getpid() == 1 && (st.st_mode & 0044) != 0044)
6308 log_warning("Configuration file %s is marked world-inaccessible. This has no effect as configuration data is accessible via APIs without restrictions. Proceeding anyway.", path);
6309
6310 return 0;
6311 }
6312
6313 unsigned long personality_from_string(const char *p) {
6314
6315 /* Parse a personality specifier. We introduce our own
6316 * identifiers that indicate specific ABIs, rather than just
6317 * hints regarding the register size, since we want to keep
6318 * things open for multiple locally supported ABIs for the
6319 * same register size. We try to reuse the ABI identifiers
6320 * used by libseccomp. */
6321
6322 #if defined(__x86_64__)
6323
6324 if (streq(p, "x86"))
6325 return PER_LINUX32;
6326
6327 if (streq(p, "x86-64"))
6328 return PER_LINUX;
6329
6330 #elif defined(__i386__)
6331
6332 if (streq(p, "x86"))
6333 return PER_LINUX;
6334 #endif
6335
6336 /* personality(7) documents that 0xffffffffUL is used for
6337 * querying the current personality, hence let's use that here
6338 * as error indicator. */
6339 return 0xffffffffUL;
6340 }
6341
6342 const char* personality_to_string(unsigned long p) {
6343
6344 #if defined(__x86_64__)
6345
6346 if (p == PER_LINUX32)
6347 return "x86";
6348
6349 if (p == PER_LINUX)
6350 return "x86-64";
6351
6352 #elif defined(__i386__)
6353
6354 if (p == PER_LINUX)
6355 return "x86";
6356 #endif
6357
6358 return NULL;
6359 }
6360
6361 uint64_t physical_memory(void) {
6362 long mem;
6363
6364 /* We return this as uint64_t in case we are running as 32bit
6365 * process on a 64bit kernel with huge amounts of memory */
6366
6367 mem = sysconf(_SC_PHYS_PAGES);
6368 assert(mem > 0);
6369
6370 return (uint64_t) mem * (uint64_t) page_size();
6371 }
6372
6373 char* mount_test_option(const char *haystack, const char *needle) {
6374
6375 struct mntent me = {
6376 .mnt_opts = (char*) haystack
6377 };
6378
6379 assert(needle);
6380
6381 /* Like glibc's hasmntopt(), but works on a string, not a
6382 * struct mntent */
6383
6384 if (!haystack)
6385 return NULL;
6386
6387 return hasmntopt(&me, needle);
6388 }
6389
6390 void hexdump(FILE *f, const void *p, size_t s) {
6391 const uint8_t *b = p;
6392 unsigned n = 0;
6393
6394 assert(s == 0 || b);
6395
6396 while (s > 0) {
6397 size_t i;
6398
6399 fprintf(f, "%04x ", n);
6400
6401 for (i = 0; i < 16; i++) {
6402
6403 if (i >= s)
6404 fputs(" ", f);
6405 else
6406 fprintf(f, "%02x ", b[i]);
6407
6408 if (i == 7)
6409 fputc(' ', f);
6410 }
6411
6412 fputc(' ', f);
6413
6414 for (i = 0; i < 16; i++) {
6415
6416 if (i >= s)
6417 fputc(' ', f);
6418 else
6419 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
6420 }
6421
6422 fputc('\n', f);
6423
6424 if (s < 16)
6425 break;
6426
6427 n += 16;
6428 b += 16;
6429 s -= 16;
6430 }
6431 }
6432
6433 int update_reboot_param_file(const char *param) {
6434 int r = 0;
6435
6436 if (param) {
6437
6438 r = write_string_file(REBOOT_PARAM_FILE, param);
6439 if (r < 0)
6440 log_error("Failed to write reboot param to "
6441 REBOOT_PARAM_FILE": %s", strerror(-r));
6442 } else
6443 unlink(REBOOT_PARAM_FILE);
6444
6445 return r;
6446 }
6447
6448 int umount_recursive(const char *prefix, int flags) {
6449 bool again;
6450 int n = 0, r;
6451
6452 /* Try to umount everything recursively below a
6453 * directory. Also, take care of stacked mounts, and keep
6454 * unmounting them until they are gone. */
6455
6456 do {
6457 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6458
6459 again = false;
6460 r = 0;
6461
6462 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6463 if (!proc_self_mountinfo)
6464 return -errno;
6465
6466 for (;;) {
6467 _cleanup_free_ char *path = NULL, *p = NULL;
6468 int k;
6469
6470 k = fscanf(proc_self_mountinfo,
6471 "%*s " /* (1) mount id */
6472 "%*s " /* (2) parent id */
6473 "%*s " /* (3) major:minor */
6474 "%*s " /* (4) root */
6475 "%ms " /* (5) mount point */
6476 "%*s" /* (6) mount options */
6477 "%*[^-]" /* (7) optional fields */
6478 "- " /* (8) separator */
6479 "%*s " /* (9) file system type */
6480 "%*s" /* (10) mount source */
6481 "%*s" /* (11) mount options 2 */
6482 "%*[^\n]", /* some rubbish at the end */
6483 &path);
6484 if (k != 1) {
6485 if (k == EOF)
6486 break;
6487
6488 continue;
6489 }
6490
6491 p = cunescape(path);
6492 if (!p)
6493 return -ENOMEM;
6494
6495 if (!path_startswith(p, prefix))
6496 continue;
6497
6498 if (umount2(p, flags) < 0) {
6499 r = -errno;
6500 continue;
6501 }
6502
6503 again = true;
6504 n++;
6505
6506 break;
6507 }
6508
6509 } while (again);
6510
6511 return r ? r : n;
6512 }
6513
6514 int bind_remount_recursive(const char *prefix, bool ro) {
6515 _cleanup_set_free_free_ Set *done = NULL;
6516 _cleanup_free_ char *cleaned = NULL;
6517 int r;
6518
6519 /* Recursively remount a directory (and all its submounts)
6520 * read-only or read-write. If the directory is already
6521 * mounted, we reuse the mount and simply mark it
6522 * MS_BIND|MS_RDONLY (or remove the MS_RDONLY for read-write
6523 * operation). If it isn't we first make it one. Afterwards we
6524 * apply MS_BIND|MS_RDONLY (or remove MS_RDONLY) to all
6525 * submounts we can access, too. When mounts are stacked on
6526 * the same mount point we only care for each individual
6527 * "top-level" mount on each point, as we cannot
6528 * influence/access the underlying mounts anyway. We do not
6529 * have any effect on future submounts that might get
6530 * propagated, they migt be writable. This includes future
6531 * submounts that have been triggered via autofs. */
6532
6533 cleaned = strdup(prefix);
6534 if (!cleaned)
6535 return -ENOMEM;
6536
6537 path_kill_slashes(cleaned);
6538
6539 done = set_new(string_hash_func, string_compare_func);
6540 if (!done)
6541 return -ENOMEM;
6542
6543 for (;;) {
6544 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6545 _cleanup_set_free_free_ Set *todo = NULL;
6546 bool top_autofs = false;
6547 char *x;
6548
6549 todo = set_new(string_hash_func, string_compare_func);
6550 if (!todo)
6551 return -ENOMEM;
6552
6553 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6554 if (!proc_self_mountinfo)
6555 return -errno;
6556
6557 for (;;) {
6558 _cleanup_free_ char *path = NULL, *p = NULL, *type = NULL;
6559 int k;
6560
6561 k = fscanf(proc_self_mountinfo,
6562 "%*s " /* (1) mount id */
6563 "%*s " /* (2) parent id */
6564 "%*s " /* (3) major:minor */
6565 "%*s " /* (4) root */
6566 "%ms " /* (5) mount point */
6567 "%*s" /* (6) mount options (superblock) */
6568 "%*[^-]" /* (7) optional fields */
6569 "- " /* (8) separator */
6570 "%ms " /* (9) file system type */
6571 "%*s" /* (10) mount source */
6572 "%*s" /* (11) mount options (bind mount) */
6573 "%*[^\n]", /* some rubbish at the end */
6574 &path,
6575 &type);
6576 if (k != 2) {
6577 if (k == EOF)
6578 break;
6579
6580 continue;
6581 }
6582
6583 p = cunescape(path);
6584 if (!p)
6585 return -ENOMEM;
6586
6587 /* Let's ignore autofs mounts. If they aren't
6588 * triggered yet, we want to avoid triggering
6589 * them, as we don't make any guarantees for
6590 * future submounts anyway. If they are
6591 * already triggered, then we will find
6592 * another entry for this. */
6593 if (streq(type, "autofs")) {
6594 top_autofs = top_autofs || path_equal(cleaned, p);
6595 continue;
6596 }
6597
6598 if (path_startswith(p, cleaned) &&
6599 !set_contains(done, p)) {
6600
6601 r = set_consume(todo, p);
6602 p = NULL;
6603
6604 if (r == -EEXIST)
6605 continue;
6606 if (r < 0)
6607 return r;
6608 }
6609 }
6610
6611 /* If we have no submounts to process anymore and if
6612 * the root is either already done, or an autofs, we
6613 * are done */
6614 if (set_isempty(todo) &&
6615 (top_autofs || set_contains(done, cleaned)))
6616 return 0;
6617
6618 if (!set_contains(done, cleaned) &&
6619 !set_contains(todo, cleaned)) {
6620 /* The prefix directory itself is not yet a
6621 * mount, make it one. */
6622 if (mount(cleaned, cleaned, NULL, MS_BIND|MS_REC, NULL) < 0)
6623 return -errno;
6624
6625 if (mount(NULL, prefix, NULL, MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
6626 return -errno;
6627
6628 x = strdup(cleaned);
6629 if (!x)
6630 return -ENOMEM;
6631
6632 r = set_consume(done, x);
6633 if (r < 0)
6634 return r;
6635 }
6636
6637 while ((x = set_steal_first(todo))) {
6638
6639 r = set_consume(done, x);
6640 if (r == -EEXIST)
6641 continue;
6642 if (r < 0)
6643 return r;
6644
6645 if (mount(NULL, x, NULL, MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0) {
6646
6647 /* Deal with mount points that are
6648 * obstructed by a later mount */
6649
6650 if (errno != ENOENT)
6651 return -errno;
6652 }
6653
6654 }
6655 }
6656 }
6657
6658 int fflush_and_check(FILE *f) {
6659 assert(f);
6660
6661 errno = 0;
6662 fflush(f);
6663
6664 if (ferror(f))
6665 return errno ? -errno : -EIO;
6666
6667 return 0;
6668 }
6669
6670 char *tempfn_xxxxxx(const char *p) {
6671 const char *fn;
6672 char *t;
6673 size_t k;
6674
6675 assert(p);
6676
6677 t = new(char, strlen(p) + 1 + 6 + 1);
6678 if (!t)
6679 return NULL;
6680
6681 fn = basename(p);
6682 k = fn - p;
6683
6684 strcpy(stpcpy(stpcpy(mempcpy(t, p, k), "."), fn), "XXXXXX");
6685
6686 return t;
6687 }
6688
6689 char *tempfn_random(const char *p) {
6690 const char *fn;
6691 char *t, *x;
6692 uint64_t u;
6693 size_t k;
6694 unsigned i;
6695
6696 assert(p);
6697
6698 t = new(char, strlen(p) + 1 + 16 + 1);
6699 if (!t)
6700 return NULL;
6701
6702 fn = basename(p);
6703 k = fn - p;
6704
6705 x = stpcpy(stpcpy(mempcpy(t, p, k), "."), fn);
6706
6707 u = random_u64();
6708 for (i = 0; i < 16; i++) {
6709 *(x++) = hexchar(u & 0xF);
6710 u >>= 4;
6711 }
6712
6713 *x = 0;
6714
6715 return t;
6716 }
Unnamed repository; edit this file 'description' to name the repository.