]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/shared/util.c
projects / thirdparty / systemd.git / blob
? search:


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