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