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