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