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