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