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