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