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