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