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