]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/shared/util.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
treewide: use log_*_errno whenever %m is in the format string
[thirdparty/systemd.git] / src / shared / util.c
... / ...
CommitLineData
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
89int saved_argc = 0;
90char **saved_argv = NULL;
91
92static volatile unsigned cached_columns = 0;
93static volatile unsigned cached_lines = 0;
94
95size_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
109bool 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
122char* 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
143char* 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
177static 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
240int 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
261int 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
285void 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
294int 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
305int 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
316int 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
340int 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
369int 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
389int 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
409int 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
429int 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
449int 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
469int 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
486int 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
503int 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
522static 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. */
539const 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
578int 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
621int 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
671int 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
682char *truncate_nl(char *s) {
683 assert(s);
684
685 s[strcspn(s, NEWLINE)] = 0;
686 return s;
687}
688
689int 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
714int 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
730int 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
823int 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
852int 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
863static 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
876int 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
895static 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
929int get_process_uid(pid_t pid, uid_t *uid) {
930 return get_process_id(pid, "Uid:", uid);
931}
932
933int 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
938int 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
948int 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
958int 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
991char *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
1022char *strappend(const char *s, const char *suffix) {
1023 return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
1024}
1025
1026int 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
1059int readlink_malloc(const char *p, char **ret) {
1060 return readlinkat_malloc(AT_FDCWD, p, ret);
1061}
1062
1063int 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
1085int 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
1105int 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
1128int 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
1151int 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
1163char *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
1180char *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
1197char *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
1224int 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
1270char hexchar(int x) {
1271 static const char table[16] = "0123456789abcdef";
1272
1273 return table[x & 15];
1274}
1275
1276int 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
1290char *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
1307void *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
1333char octchar(int x) {
1334 return '0' + (x & 7);
1335}
1336
1337int unoctchar(char c) {
1338
1339 if (c >= '0' && c <= '7')
1340 return c - '0';
1341
1342 return -EINVAL;
1343}
1344
1345char decchar(int x) {
1346 return '0' + (x % 10);
1347}
1348
1349int undecchar(char c) {
1350
1351 if (c >= '0' && c <= '9')
1352 return c - '0';
1353
1354 return -EINVAL;
1355}
1356
1357char *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
1377char *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
1501finish:
1502 *t = 0;
1503 return r;
1504}
1505
1506char *cunescape_length(const char *s, size_t length) {
1507 return cunescape_length_with_prefix(s, length, NULL);
1508}
1509
1510char *cunescape(const char *s) {
1511 assert(s);
1512
1513 return cunescape_length(s, strlen(s));
1514}
1515
1516char *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
1545char *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
1574bool 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
1583int 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
1606int 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
1641int 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
1700bool 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
1711bool 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
1733int 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
1758int 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
1818int 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
1866int 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
1909int 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
1966finish:
1967 /* Just in case, flush all crap out */
1968 tcflush(fd, TCIOFLUSH);
1969
1970 return r;
1971}
1972
1973int 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
1983int 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
2028int 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
2064int 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_errno(r, "Failed to reset terminal: %m");
2218
2219 return fd;
2220
2221fail:
2222 safe_close(fd);
2223 safe_close(notify);
2224
2225 return r;
2226}
2227
2228int 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
2254int 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
2267int 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
2287int 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
2307void 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
2321ssize_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
2356ssize_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
2391int 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
2520int 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
2540int 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
2550bool 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
2560int 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
2583char* 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
2601int 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
2657void 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
2686void 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
2703void 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
2734void 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
2746int 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
2764char* 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
2775bool 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
2783char *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
2810char* 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
2822char *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
2832int 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
2852int 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
2869int 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
2906int 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
2950finish:
2951 if (!b)
2952 return -ENOMEM;
2953
2954 *r = b;
2955 if (_devnr)
2956 *_devnr = devnr;
2957
2958 return 0;
2959}
2960
2961int 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
3055int 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
3077static 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
3090static 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
3155int 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
3159int 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
3163int 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
3181int 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
3199cpu_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
3227int 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
3292int 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
3305char *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
3379fail:
3380 free(r);
3381 return NULL;
3382}
3383
3384char **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
3449int 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
3461unsigned 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
3483int 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
3495unsigned 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 */
3518void columns_lines_cache_reset(int signum) {
3519 cached_columns = 0;
3520 cached_lines = 0;
3521}
3522
3523bool 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
3532int 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
3545int 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
3555static 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
3586char *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
3660char *ellipsize(const char *s, size_t length, unsigned percent) {
3661 return ellipsize_mem(s, strlen(s), length, percent);
3662}
3663
3664int 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
3703int touch(const char *path) {
3704 return touch_file(path, false, USEC_INFINITY, (uid_t) -1, (gid_t) -1, 0);
3705}
3706
3707char *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
3726char *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
3756int 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 */
3790int 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 return log_warning_errno(r, "Failed to wait for %s: %m", name);
3800
3801 if (status.si_code == CLD_EXITED) {
3802 if (status.si_status != 0) {
3803 log_warning("%s failed with error code %i.", name, status.si_status);
3804 return status.si_status;
3805 }
3806
3807 log_debug("%s succeeded.", name);
3808 return 0;
3809
3810 } else if (status.si_code == CLD_KILLED ||
3811 status.si_code == CLD_DUMPED) {
3812
3813 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3814 return -EPROTO;
3815 }
3816
3817 log_warning("%s failed due to unknown reason.", name);
3818 return -EPROTO;
3819}
3820
3821noreturn void freeze(void) {
3822
3823 /* Make sure nobody waits for us on a socket anymore */
3824 close_all_fds(NULL, 0);
3825
3826 sync();
3827
3828 for (;;)
3829 pause();
3830}
3831
3832bool null_or_empty(struct stat *st) {
3833 assert(st);
3834
3835 if (S_ISREG(st->st_mode) && st->st_size <= 0)
3836 return true;
3837
3838 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3839 return true;
3840
3841 return false;
3842}
3843
3844int null_or_empty_path(const char *fn) {
3845 struct stat st;
3846
3847 assert(fn);
3848
3849 if (stat(fn, &st) < 0)
3850 return -errno;
3851
3852 return null_or_empty(&st);
3853}
3854
3855int null_or_empty_fd(int fd) {
3856 struct stat st;
3857
3858 assert(fd >= 0);
3859
3860 if (fstat(fd, &st) < 0)
3861 return -errno;
3862
3863 return null_or_empty(&st);
3864}
3865
3866DIR *xopendirat(int fd, const char *name, int flags) {
3867 int nfd;
3868 DIR *d;
3869
3870 assert(!(flags & O_CREAT));
3871
3872 nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3873 if (nfd < 0)
3874 return NULL;
3875
3876 d = fdopendir(nfd);
3877 if (!d) {
3878 safe_close(nfd);
3879 return NULL;
3880 }
3881
3882 return d;
3883}
3884
3885int signal_from_string_try_harder(const char *s) {
3886 int signo;
3887 assert(s);
3888
3889 signo = signal_from_string(s);
3890 if (signo <= 0)
3891 if (startswith(s, "SIG"))
3892 return signal_from_string(s+3);
3893
3894 return signo;
3895}
3896
3897static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3898 _cleanup_free_ char *t = NULL, *u = NULL;
3899 size_t enc_len;
3900
3901 u = unquote(tagvalue, "\"\'");
3902 if (!u)
3903 return NULL;
3904
3905 enc_len = strlen(u) * 4 + 1;
3906 t = new(char, enc_len);
3907 if (!t)
3908 return NULL;
3909
3910 if (encode_devnode_name(u, t, enc_len) < 0)
3911 return NULL;
3912
3913 return strjoin("/dev/disk/by-", by, "/", t, NULL);
3914}
3915
3916char *fstab_node_to_udev_node(const char *p) {
3917 assert(p);
3918
3919 if (startswith(p, "LABEL="))
3920 return tag_to_udev_node(p+6, "label");
3921
3922 if (startswith(p, "UUID="))
3923 return tag_to_udev_node(p+5, "uuid");
3924
3925 if (startswith(p, "PARTUUID="))
3926 return tag_to_udev_node(p+9, "partuuid");
3927
3928 if (startswith(p, "PARTLABEL="))
3929 return tag_to_udev_node(p+10, "partlabel");
3930
3931 return strdup(p);
3932}
3933
3934bool tty_is_vc(const char *tty) {
3935 assert(tty);
3936
3937 return vtnr_from_tty(tty) >= 0;
3938}
3939
3940bool tty_is_console(const char *tty) {
3941 assert(tty);
3942
3943 if (startswith(tty, "/dev/"))
3944 tty += 5;
3945
3946 return streq(tty, "console");
3947}
3948
3949int vtnr_from_tty(const char *tty) {
3950 int i, r;
3951
3952 assert(tty);
3953
3954 if (startswith(tty, "/dev/"))
3955 tty += 5;
3956
3957 if (!startswith(tty, "tty") )
3958 return -EINVAL;
3959
3960 if (tty[3] < '0' || tty[3] > '9')
3961 return -EINVAL;
3962
3963 r = safe_atoi(tty+3, &i);
3964 if (r < 0)
3965 return r;
3966
3967 if (i < 0 || i > 63)
3968 return -EINVAL;
3969
3970 return i;
3971}
3972
3973char *resolve_dev_console(char **active) {
3974 char *tty;
3975
3976 /* Resolve where /dev/console is pointing to, if /sys is actually ours
3977 * (i.e. not read-only-mounted which is a sign for container setups) */
3978
3979 if (path_is_read_only_fs("/sys") > 0)
3980 return NULL;
3981
3982 if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3983 return NULL;
3984
3985 /* If multiple log outputs are configured the last one is what
3986 * /dev/console points to */
3987 tty = strrchr(*active, ' ');
3988 if (tty)
3989 tty++;
3990 else
3991 tty = *active;
3992
3993 if (streq(tty, "tty0")) {
3994 char *tmp;
3995
3996 /* Get the active VC (e.g. tty1) */
3997 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3998 free(*active);
3999 tty = *active = tmp;
4000 }
4001 }
4002
4003 return tty;
4004}
4005
4006bool tty_is_vc_resolve(const char *tty) {
4007 _cleanup_free_ char *active = NULL;
4008
4009 assert(tty);
4010
4011 if (startswith(tty, "/dev/"))
4012 tty += 5;
4013
4014 if (streq(tty, "console")) {
4015 tty = resolve_dev_console(&active);
4016 if (!tty)
4017 return false;
4018 }
4019
4020 return tty_is_vc(tty);
4021}
4022
4023const char *default_term_for_tty(const char *tty) {
4024 assert(tty);
4025
4026 return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
4027}
4028
4029bool dirent_is_file(const struct dirent *de) {
4030 assert(de);
4031
4032 if (ignore_file(de->d_name))
4033 return false;
4034
4035 if (de->d_type != DT_REG &&
4036 de->d_type != DT_LNK &&
4037 de->d_type != DT_UNKNOWN)
4038 return false;
4039
4040 return true;
4041}
4042
4043bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
4044 assert(de);
4045
4046 if (de->d_type != DT_REG &&
4047 de->d_type != DT_LNK &&
4048 de->d_type != DT_UNKNOWN)
4049 return false;
4050
4051 if (ignore_file_allow_backup(de->d_name))
4052 return false;
4053
4054 return endswith(de->d_name, suffix);
4055}
4056
4057void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {
4058 pid_t executor_pid;
4059 int r;
4060
4061 assert(directory);
4062
4063 /* Executes all binaries in a directory in parallel and waits
4064 * for them to finish. Optionally a timeout is applied. */
4065
4066 executor_pid = fork();
4067 if (executor_pid < 0) {
4068 log_error_errno(errno, "Failed to fork: %m");
4069 return;
4070
4071 } else if (executor_pid == 0) {
4072 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
4073 _cleanup_closedir_ DIR *_d = NULL;
4074 struct dirent *de;
4075
4076 /* We fork this all off from a child process so that
4077 * we can somewhat cleanly make use of SIGALRM to set
4078 * a time limit */
4079
4080 reset_all_signal_handlers();
4081 reset_signal_mask();
4082
4083 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4084
4085 if (!d) {
4086 d = _d = opendir(directory);
4087 if (!d) {
4088 if (errno == ENOENT)
4089 _exit(EXIT_SUCCESS);
4090
4091 log_error_errno(errno, "Failed to enumerate directory %s: %m", directory);
4092 _exit(EXIT_FAILURE);
4093 }
4094 }
4095
4096 pids = hashmap_new(NULL);
4097 if (!pids) {
4098 log_oom();
4099 _exit(EXIT_FAILURE);
4100 }
4101
4102 FOREACH_DIRENT(de, d, break) {
4103 _cleanup_free_ char *path = NULL;
4104 pid_t pid;
4105
4106 if (!dirent_is_file(de))
4107 continue;
4108
4109 path = strjoin(directory, "/", de->d_name, NULL);
4110 if (!path) {
4111 log_oom();
4112 _exit(EXIT_FAILURE);
4113 }
4114
4115 pid = fork();
4116 if (pid < 0) {
4117 log_error_errno(errno, "Failed to fork: %m");
4118 continue;
4119 } else if (pid == 0) {
4120 char *_argv[2];
4121
4122 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4123
4124 if (!argv) {
4125 _argv[0] = path;
4126 _argv[1] = NULL;
4127 argv = _argv;
4128 } else
4129 argv[0] = path;
4130
4131 execv(path, argv);
4132 log_error_errno(errno, "Failed to execute %s: %m", path);
4133 _exit(EXIT_FAILURE);
4134 }
4135
4136 log_debug("Spawned %s as " PID_FMT ".", path, pid);
4137
4138 r = hashmap_put(pids, UINT_TO_PTR(pid), path);
4139 if (r < 0) {
4140 log_oom();
4141 _exit(EXIT_FAILURE);
4142 }
4143
4144 path = NULL;
4145 }
4146
4147 /* Abort execution of this process after the
4148 * timout. We simply rely on SIGALRM as default action
4149 * terminating the process, and turn on alarm(). */
4150
4151 if (timeout != USEC_INFINITY)
4152 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
4153
4154 while (!hashmap_isempty(pids)) {
4155 _cleanup_free_ char *path = NULL;
4156 pid_t pid;
4157
4158 pid = PTR_TO_UINT(hashmap_first_key(pids));
4159 assert(pid > 0);
4160
4161 path = hashmap_remove(pids, UINT_TO_PTR(pid));
4162 assert(path);
4163
4164 wait_for_terminate_and_warn(path, pid);
4165 }
4166
4167 _exit(EXIT_SUCCESS);
4168 }
4169
4170 wait_for_terminate_and_warn(directory, executor_pid);
4171}
4172
4173int kill_and_sigcont(pid_t pid, int sig) {
4174 int r;
4175
4176 r = kill(pid, sig) < 0 ? -errno : 0;
4177
4178 if (r >= 0)
4179 kill(pid, SIGCONT);
4180
4181 return r;
4182}
4183
4184bool nulstr_contains(const char*nulstr, const char *needle) {
4185 const char *i;
4186
4187 if (!nulstr)
4188 return false;
4189
4190 NULSTR_FOREACH(i, nulstr)
4191 if (streq(i, needle))
4192 return true;
4193
4194 return false;
4195}
4196
4197bool plymouth_running(void) {
4198 return access("/run/plymouth/pid", F_OK) >= 0;
4199}
4200
4201char* strshorten(char *s, size_t l) {
4202 assert(s);
4203
4204 if (l < strlen(s))
4205 s[l] = 0;
4206
4207 return s;
4208}
4209
4210static bool hostname_valid_char(char c) {
4211 return
4212 (c >= 'a' && c <= 'z') ||
4213 (c >= 'A' && c <= 'Z') ||
4214 (c >= '0' && c <= '9') ||
4215 c == '-' ||
4216 c == '_' ||
4217 c == '.';
4218}
4219
4220bool hostname_is_valid(const char *s) {
4221 const char *p;
4222 bool dot;
4223
4224 if (isempty(s))
4225 return false;
4226
4227 for (p = s, dot = true; *p; p++) {
4228 if (*p == '.') {
4229 if (dot)
4230 return false;
4231
4232 dot = true;
4233 } else {
4234 if (!hostname_valid_char(*p))
4235 return false;
4236
4237 dot = false;
4238 }
4239 }
4240
4241 if (dot)
4242 return false;
4243
4244 if (p-s > HOST_NAME_MAX)
4245 return false;
4246
4247 return true;
4248}
4249
4250char* hostname_cleanup(char *s, bool lowercase) {
4251 char *p, *d;
4252 bool dot;
4253
4254 for (p = s, d = s, dot = true; *p; p++) {
4255 if (*p == '.') {
4256 if (dot)
4257 continue;
4258
4259 *(d++) = '.';
4260 dot = true;
4261 } else if (hostname_valid_char(*p)) {
4262 *(d++) = lowercase ? tolower(*p) : *p;
4263 dot = false;
4264 }
4265
4266 }
4267
4268 if (dot && d > s)
4269 d[-1] = 0;
4270 else
4271 *d = 0;
4272
4273 strshorten(s, HOST_NAME_MAX);
4274
4275 return s;
4276}
4277
4278bool machine_name_is_valid(const char *s) {
4279
4280 if (!hostname_is_valid(s))
4281 return false;
4282
4283 /* Machine names should be useful hostnames, but also be
4284 * useful in unit names, hence we enforce a stricter length
4285 * limitation. */
4286
4287 if (strlen(s) > 64)
4288 return false;
4289
4290 return true;
4291}
4292
4293int pipe_eof(int fd) {
4294 struct pollfd pollfd = {
4295 .fd = fd,
4296 .events = POLLIN|POLLHUP,
4297 };
4298
4299 int r;
4300
4301 r = poll(&pollfd, 1, 0);
4302 if (r < 0)
4303 return -errno;
4304
4305 if (r == 0)
4306 return 0;
4307
4308 return pollfd.revents & POLLHUP;
4309}
4310
4311int fd_wait_for_event(int fd, int event, usec_t t) {
4312
4313 struct pollfd pollfd = {
4314 .fd = fd,
4315 .events = event,
4316 };
4317
4318 struct timespec ts;
4319 int r;
4320
4321 r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);
4322 if (r < 0)
4323 return -errno;
4324
4325 if (r == 0)
4326 return 0;
4327
4328 return pollfd.revents;
4329}
4330
4331int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4332 FILE *f;
4333 char *t;
4334 int fd;
4335
4336 assert(path);
4337 assert(_f);
4338 assert(_temp_path);
4339
4340 t = tempfn_xxxxxx(path);
4341 if (!t)
4342 return -ENOMEM;
4343
4344 fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
4345 if (fd < 0) {
4346 free(t);
4347 return -errno;
4348 }
4349
4350 f = fdopen(fd, "we");
4351 if (!f) {
4352 unlink(t);
4353 free(t);
4354 return -errno;
4355 }
4356
4357 *_f = f;
4358 *_temp_path = t;
4359
4360 return 0;
4361}
4362
4363int terminal_vhangup_fd(int fd) {
4364 assert(fd >= 0);
4365
4366 if (ioctl(fd, TIOCVHANGUP) < 0)
4367 return -errno;
4368
4369 return 0;
4370}
4371
4372int terminal_vhangup(const char *name) {
4373 _cleanup_close_ int fd;
4374
4375 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4376 if (fd < 0)
4377 return fd;
4378
4379 return terminal_vhangup_fd(fd);
4380}
4381
4382int vt_disallocate(const char *name) {
4383 int fd, r;
4384 unsigned u;
4385
4386 /* Deallocate the VT if possible. If not possible
4387 * (i.e. because it is the active one), at least clear it
4388 * entirely (including the scrollback buffer) */
4389
4390 if (!startswith(name, "/dev/"))
4391 return -EINVAL;
4392
4393 if (!tty_is_vc(name)) {
4394 /* So this is not a VT. I guess we cannot deallocate
4395 * it then. But let's at least clear the screen */
4396
4397 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4398 if (fd < 0)
4399 return fd;
4400
4401 loop_write(fd,
4402 "\033[r" /* clear scrolling region */
4403 "\033[H" /* move home */
4404 "\033[2J", /* clear screen */
4405 10, false);
4406 safe_close(fd);
4407
4408 return 0;
4409 }
4410
4411 if (!startswith(name, "/dev/tty"))
4412 return -EINVAL;
4413
4414 r = safe_atou(name+8, &u);
4415 if (r < 0)
4416 return r;
4417
4418 if (u <= 0)
4419 return -EINVAL;
4420
4421 /* Try to deallocate */
4422 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4423 if (fd < 0)
4424 return fd;
4425
4426 r = ioctl(fd, VT_DISALLOCATE, u);
4427 safe_close(fd);
4428
4429 if (r >= 0)
4430 return 0;
4431
4432 if (errno != EBUSY)
4433 return -errno;
4434
4435 /* Couldn't deallocate, so let's clear it fully with
4436 * scrollback */
4437 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4438 if (fd < 0)
4439 return fd;
4440
4441 loop_write(fd,
4442 "\033[r" /* clear scrolling region */
4443 "\033[H" /* move home */
4444 "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4445 10, false);
4446 safe_close(fd);
4447
4448 return 0;
4449}
4450
4451int symlink_atomic(const char *from, const char *to) {
4452 _cleanup_free_ char *t = NULL;
4453
4454 assert(from);
4455 assert(to);
4456
4457 t = tempfn_random(to);
4458 if (!t)
4459 return -ENOMEM;
4460
4461 if (symlink(from, t) < 0)
4462 return -errno;
4463
4464 if (rename(t, to) < 0) {
4465 unlink_noerrno(t);
4466 return -errno;
4467 }
4468
4469 return 0;
4470}
4471
4472int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
4473 _cleanup_free_ char *t = NULL;
4474
4475 assert(path);
4476
4477 t = tempfn_random(path);
4478 if (!t)
4479 return -ENOMEM;
4480
4481 if (mknod(t, mode, dev) < 0)
4482 return -errno;
4483
4484 if (rename(t, path) < 0) {
4485 unlink_noerrno(t);
4486 return -errno;
4487 }
4488
4489 return 0;
4490}
4491
4492int mkfifo_atomic(const char *path, mode_t mode) {
4493 _cleanup_free_ char *t = NULL;
4494
4495 assert(path);
4496
4497 t = tempfn_random(path);
4498 if (!t)
4499 return -ENOMEM;
4500
4501 if (mkfifo(t, mode) < 0)
4502 return -errno;
4503
4504 if (rename(t, path) < 0) {
4505 unlink_noerrno(t);
4506 return -errno;
4507 }
4508
4509 return 0;
4510}
4511
4512bool display_is_local(const char *display) {
4513 assert(display);
4514
4515 return
4516 display[0] == ':' &&
4517 display[1] >= '0' &&
4518 display[1] <= '9';
4519}
4520
4521int socket_from_display(const char *display, char **path) {
4522 size_t k;
4523 char *f, *c;
4524
4525 assert(display);
4526 assert(path);
4527
4528 if (!display_is_local(display))
4529 return -EINVAL;
4530
4531 k = strspn(display+1, "0123456789");
4532
4533 f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
4534 if (!f)
4535 return -ENOMEM;
4536
4537 c = stpcpy(f, "/tmp/.X11-unix/X");
4538 memcpy(c, display+1, k);
4539 c[k] = 0;
4540
4541 *path = f;
4542
4543 return 0;
4544}
4545
4546int get_user_creds(
4547 const char **username,
4548 uid_t *uid, gid_t *gid,
4549 const char **home,
4550 const char **shell) {
4551
4552 struct passwd *p;
4553 uid_t u;
4554
4555 assert(username);
4556 assert(*username);
4557
4558 /* We enforce some special rules for uid=0: in order to avoid
4559 * NSS lookups for root we hardcode its data. */
4560
4561 if (streq(*username, "root") || streq(*username, "0")) {
4562 *username = "root";
4563
4564 if (uid)
4565 *uid = 0;
4566
4567 if (gid)
4568 *gid = 0;
4569
4570 if (home)
4571 *home = "/root";
4572
4573 if (shell)
4574 *shell = "/bin/sh";
4575
4576 return 0;
4577 }
4578
4579 if (parse_uid(*username, &u) >= 0) {
4580 errno = 0;
4581 p = getpwuid(u);
4582
4583 /* If there are multiple users with the same id, make
4584 * sure to leave $USER to the configured value instead
4585 * of the first occurrence in the database. However if
4586 * the uid was configured by a numeric uid, then let's
4587 * pick the real username from /etc/passwd. */
4588 if (p)
4589 *username = p->pw_name;
4590 } else {
4591 errno = 0;
4592 p = getpwnam(*username);
4593 }
4594
4595 if (!p)
4596 return errno > 0 ? -errno : -ESRCH;
4597
4598 if (uid)
4599 *uid = p->pw_uid;
4600
4601 if (gid)
4602 *gid = p->pw_gid;
4603
4604 if (home)
4605 *home = p->pw_dir;
4606
4607 if (shell)
4608 *shell = p->pw_shell;
4609
4610 return 0;
4611}
4612
4613char* uid_to_name(uid_t uid) {
4614 struct passwd *p;
4615 char *r;
4616
4617 if (uid == 0)
4618 return strdup("root");
4619
4620 p = getpwuid(uid);
4621 if (p)
4622 return strdup(p->pw_name);
4623
4624 if (asprintf(&r, UID_FMT, uid) < 0)
4625 return NULL;
4626
4627 return r;
4628}
4629
4630char* gid_to_name(gid_t gid) {
4631 struct group *p;
4632 char *r;
4633
4634 if (gid == 0)
4635 return strdup("root");
4636
4637 p = getgrgid(gid);
4638 if (p)
4639 return strdup(p->gr_name);
4640
4641 if (asprintf(&r, GID_FMT, gid) < 0)
4642 return NULL;
4643
4644 return r;
4645}
4646
4647int get_group_creds(const char **groupname, gid_t *gid) {
4648 struct group *g;
4649 gid_t id;
4650
4651 assert(groupname);
4652
4653 /* We enforce some special rules for gid=0: in order to avoid
4654 * NSS lookups for root we hardcode its data. */
4655
4656 if (streq(*groupname, "root") || streq(*groupname, "0")) {
4657 *groupname = "root";
4658
4659 if (gid)
4660 *gid = 0;
4661
4662 return 0;
4663 }
4664
4665 if (parse_gid(*groupname, &id) >= 0) {
4666 errno = 0;
4667 g = getgrgid(id);
4668
4669 if (g)
4670 *groupname = g->gr_name;
4671 } else {
4672 errno = 0;
4673 g = getgrnam(*groupname);
4674 }
4675
4676 if (!g)
4677 return errno > 0 ? -errno : -ESRCH;
4678
4679 if (gid)
4680 *gid = g->gr_gid;
4681
4682 return 0;
4683}
4684
4685int in_gid(gid_t gid) {
4686 gid_t *gids;
4687 int ngroups_max, r, i;
4688
4689 if (getgid() == gid)
4690 return 1;
4691
4692 if (getegid() == gid)
4693 return 1;
4694
4695 ngroups_max = sysconf(_SC_NGROUPS_MAX);
4696 assert(ngroups_max > 0);
4697
4698 gids = alloca(sizeof(gid_t) * ngroups_max);
4699
4700 r = getgroups(ngroups_max, gids);
4701 if (r < 0)
4702 return -errno;
4703
4704 for (i = 0; i < r; i++)
4705 if (gids[i] == gid)
4706 return 1;
4707
4708 return 0;
4709}
4710
4711int in_group(const char *name) {
4712 int r;
4713 gid_t gid;
4714
4715 r = get_group_creds(&name, &gid);
4716 if (r < 0)
4717 return r;
4718
4719 return in_gid(gid);
4720}
4721
4722int glob_exists(const char *path) {
4723 _cleanup_globfree_ glob_t g = {};
4724 int k;
4725
4726 assert(path);
4727
4728 errno = 0;
4729 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4730
4731 if (k == GLOB_NOMATCH)
4732 return 0;
4733 else if (k == GLOB_NOSPACE)
4734 return -ENOMEM;
4735 else if (k == 0)
4736 return !strv_isempty(g.gl_pathv);
4737 else
4738 return errno ? -errno : -EIO;
4739}
4740
4741int glob_extend(char ***strv, const char *path) {
4742 _cleanup_globfree_ glob_t g = {};
4743 int k;
4744 char **p;
4745
4746 errno = 0;
4747 k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4748
4749 if (k == GLOB_NOMATCH)
4750 return -ENOENT;
4751 else if (k == GLOB_NOSPACE)
4752 return -ENOMEM;
4753 else if (k != 0 || strv_isempty(g.gl_pathv))
4754 return errno ? -errno : -EIO;
4755
4756 STRV_FOREACH(p, g.gl_pathv) {
4757 k = strv_extend(strv, *p);
4758 if (k < 0)
4759 break;
4760 }
4761
4762 return k;
4763}
4764
4765int dirent_ensure_type(DIR *d, struct dirent *de) {
4766 struct stat st;
4767
4768 assert(d);
4769 assert(de);
4770
4771 if (de->d_type != DT_UNKNOWN)
4772 return 0;
4773
4774 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4775 return -errno;
4776
4777 de->d_type =
4778 S_ISREG(st.st_mode) ? DT_REG :
4779 S_ISDIR(st.st_mode) ? DT_DIR :
4780 S_ISLNK(st.st_mode) ? DT_LNK :
4781 S_ISFIFO(st.st_mode) ? DT_FIFO :
4782 S_ISSOCK(st.st_mode) ? DT_SOCK :
4783 S_ISCHR(st.st_mode) ? DT_CHR :
4784 S_ISBLK(st.st_mode) ? DT_BLK :
4785 DT_UNKNOWN;
4786
4787 return 0;
4788}
4789
4790int get_files_in_directory(const char *path, char ***list) {
4791 _cleanup_closedir_ DIR *d = NULL;
4792 size_t bufsize = 0, n = 0;
4793 _cleanup_strv_free_ char **l = NULL;
4794
4795 assert(path);
4796
4797 /* Returns all files in a directory in *list, and the number
4798 * of files as return value. If list is NULL returns only the
4799 * number. */
4800
4801 d = opendir(path);
4802 if (!d)
4803 return -errno;
4804
4805 for (;;) {
4806 struct dirent *de;
4807
4808 errno = 0;
4809 de = readdir(d);
4810 if (!de && errno != 0)
4811 return -errno;
4812 if (!de)
4813 break;
4814
4815 dirent_ensure_type(d, de);
4816
4817 if (!dirent_is_file(de))
4818 continue;
4819
4820 if (list) {
4821 /* one extra slot is needed for the terminating NULL */
4822 if (!GREEDY_REALLOC(l, bufsize, n + 2))
4823 return -ENOMEM;
4824
4825 l[n] = strdup(de->d_name);
4826 if (!l[n])
4827 return -ENOMEM;
4828
4829 l[++n] = NULL;
4830 } else
4831 n++;
4832 }
4833
4834 if (list) {
4835 *list = l;
4836 l = NULL; /* avoid freeing */
4837 }
4838
4839 return n;
4840}
4841
4842char *strjoin(const char *x, ...) {
4843 va_list ap;
4844 size_t l;
4845 char *r, *p;
4846
4847 va_start(ap, x);
4848
4849 if (x) {
4850 l = strlen(x);
4851
4852 for (;;) {
4853 const char *t;
4854 size_t n;
4855
4856 t = va_arg(ap, const char *);
4857 if (!t)
4858 break;
4859
4860 n = strlen(t);
4861 if (n > ((size_t) -1) - l) {
4862 va_end(ap);
4863 return NULL;
4864 }
4865
4866 l += n;
4867 }
4868 } else
4869 l = 0;
4870
4871 va_end(ap);
4872
4873 r = new(char, l+1);
4874 if (!r)
4875 return NULL;
4876
4877 if (x) {
4878 p = stpcpy(r, x);
4879
4880 va_start(ap, x);
4881
4882 for (;;) {
4883 const char *t;
4884
4885 t = va_arg(ap, const char *);
4886 if (!t)
4887 break;
4888
4889 p = stpcpy(p, t);
4890 }
4891
4892 va_end(ap);
4893 } else
4894 r[0] = 0;
4895
4896 return r;
4897}
4898
4899bool is_main_thread(void) {
4900 static thread_local int cached = 0;
4901
4902 if (_unlikely_(cached == 0))
4903 cached = getpid() == gettid() ? 1 : -1;
4904
4905 return cached > 0;
4906}
4907
4908int block_get_whole_disk(dev_t d, dev_t *ret) {
4909 char *p, *s;
4910 int r;
4911 unsigned n, m;
4912
4913 assert(ret);
4914
4915 /* If it has a queue this is good enough for us */
4916 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4917 return -ENOMEM;
4918
4919 r = access(p, F_OK);
4920 free(p);
4921
4922 if (r >= 0) {
4923 *ret = d;
4924 return 0;
4925 }
4926
4927 /* If it is a partition find the originating device */
4928 if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4929 return -ENOMEM;
4930
4931 r = access(p, F_OK);
4932 free(p);
4933
4934 if (r < 0)
4935 return -ENOENT;
4936
4937 /* Get parent dev_t */
4938 if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4939 return -ENOMEM;
4940
4941 r = read_one_line_file(p, &s);
4942 free(p);
4943
4944 if (r < 0)
4945 return r;
4946
4947 r = sscanf(s, "%u:%u", &m, &n);
4948 free(s);
4949
4950 if (r != 2)
4951 return -EINVAL;
4952
4953 /* Only return this if it is really good enough for us. */
4954 if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4955 return -ENOMEM;
4956
4957 r = access(p, F_OK);
4958 free(p);
4959
4960 if (r >= 0) {
4961 *ret = makedev(m, n);
4962 return 0;
4963 }
4964
4965 return -ENOENT;
4966}
4967
4968static const char *const ioprio_class_table[] = {
4969 [IOPRIO_CLASS_NONE] = "none",
4970 [IOPRIO_CLASS_RT] = "realtime",
4971 [IOPRIO_CLASS_BE] = "best-effort",
4972 [IOPRIO_CLASS_IDLE] = "idle"
4973};
4974
4975DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4976
4977static const char *const sigchld_code_table[] = {
4978 [CLD_EXITED] = "exited",
4979 [CLD_KILLED] = "killed",
4980 [CLD_DUMPED] = "dumped",
4981 [CLD_TRAPPED] = "trapped",
4982 [CLD_STOPPED] = "stopped",
4983 [CLD_CONTINUED] = "continued",
4984};
4985
4986DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4987
4988static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4989 [LOG_FAC(LOG_KERN)] = "kern",
4990 [LOG_FAC(LOG_USER)] = "user",
4991 [LOG_FAC(LOG_MAIL)] = "mail",
4992 [LOG_FAC(LOG_DAEMON)] = "daemon",
4993 [LOG_FAC(LOG_AUTH)] = "auth",
4994 [LOG_FAC(LOG_SYSLOG)] = "syslog",
4995 [LOG_FAC(LOG_LPR)] = "lpr",
4996 [LOG_FAC(LOG_NEWS)] = "news",
4997 [LOG_FAC(LOG_UUCP)] = "uucp",
4998 [LOG_FAC(LOG_CRON)] = "cron",
4999 [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
5000 [LOG_FAC(LOG_FTP)] = "ftp",
5001 [LOG_FAC(LOG_LOCAL0)] = "local0",
5002 [LOG_FAC(LOG_LOCAL1)] = "local1",
5003 [LOG_FAC(LOG_LOCAL2)] = "local2",
5004 [LOG_FAC(LOG_LOCAL3)] = "local3",
5005 [LOG_FAC(LOG_LOCAL4)] = "local4",
5006 [LOG_FAC(LOG_LOCAL5)] = "local5",
5007 [LOG_FAC(LOG_LOCAL6)] = "local6",
5008 [LOG_FAC(LOG_LOCAL7)] = "local7"
5009};
5010
5011DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
5012
5013static const char *const log_level_table[] = {
5014 [LOG_EMERG] = "emerg",
5015 [LOG_ALERT] = "alert",
5016 [LOG_CRIT] = "crit",
5017 [LOG_ERR] = "err",
5018 [LOG_WARNING] = "warning",
5019 [LOG_NOTICE] = "notice",
5020 [LOG_INFO] = "info",
5021 [LOG_DEBUG] = "debug"
5022};
5023
5024DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
5025
5026static const char* const sched_policy_table[] = {
5027 [SCHED_OTHER] = "other",
5028 [SCHED_BATCH] = "batch",
5029 [SCHED_IDLE] = "idle",
5030 [SCHED_FIFO] = "fifo",
5031 [SCHED_RR] = "rr"
5032};
5033
5034DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
5035
5036static const char* const rlimit_table[_RLIMIT_MAX] = {
5037 [RLIMIT_CPU] = "LimitCPU",
5038 [RLIMIT_FSIZE] = "LimitFSIZE",
5039 [RLIMIT_DATA] = "LimitDATA",
5040 [RLIMIT_STACK] = "LimitSTACK",
5041 [RLIMIT_CORE] = "LimitCORE",
5042 [RLIMIT_RSS] = "LimitRSS",
5043 [RLIMIT_NOFILE] = "LimitNOFILE",
5044 [RLIMIT_AS] = "LimitAS",
5045 [RLIMIT_NPROC] = "LimitNPROC",
5046 [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5047 [RLIMIT_LOCKS] = "LimitLOCKS",
5048 [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5049 [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5050 [RLIMIT_NICE] = "LimitNICE",
5051 [RLIMIT_RTPRIO] = "LimitRTPRIO",
5052 [RLIMIT_RTTIME] = "LimitRTTIME"
5053};
5054
5055DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5056
5057static const char* const ip_tos_table[] = {
5058 [IPTOS_LOWDELAY] = "low-delay",
5059 [IPTOS_THROUGHPUT] = "throughput",
5060 [IPTOS_RELIABILITY] = "reliability",
5061 [IPTOS_LOWCOST] = "low-cost",
5062};
5063
5064DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
5065
5066static const char *const __signal_table[] = {
5067 [SIGHUP] = "HUP",
5068 [SIGINT] = "INT",
5069 [SIGQUIT] = "QUIT",
5070 [SIGILL] = "ILL",
5071 [SIGTRAP] = "TRAP",
5072 [SIGABRT] = "ABRT",
5073 [SIGBUS] = "BUS",
5074 [SIGFPE] = "FPE",
5075 [SIGKILL] = "KILL",
5076 [SIGUSR1] = "USR1",
5077 [SIGSEGV] = "SEGV",
5078 [SIGUSR2] = "USR2",
5079 [SIGPIPE] = "PIPE",
5080 [SIGALRM] = "ALRM",
5081 [SIGTERM] = "TERM",
5082#ifdef SIGSTKFLT
5083 [SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
5084#endif
5085 [SIGCHLD] = "CHLD",
5086 [SIGCONT] = "CONT",
5087 [SIGSTOP] = "STOP",
5088 [SIGTSTP] = "TSTP",
5089 [SIGTTIN] = "TTIN",
5090 [SIGTTOU] = "TTOU",
5091 [SIGURG] = "URG",
5092 [SIGXCPU] = "XCPU",
5093 [SIGXFSZ] = "XFSZ",
5094 [SIGVTALRM] = "VTALRM",
5095 [SIGPROF] = "PROF",
5096 [SIGWINCH] = "WINCH",
5097 [SIGIO] = "IO",
5098 [SIGPWR] = "PWR",
5099 [SIGSYS] = "SYS"
5100};
5101
5102DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5103
5104const char *signal_to_string(int signo) {
5105 static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
5106 const char *name;
5107
5108 name = __signal_to_string(signo);
5109 if (name)
5110 return name;
5111
5112 if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5113 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
5114 else
5115 snprintf(buf, sizeof(buf), "%d", signo);
5116
5117 return buf;
5118}
5119
5120int signal_from_string(const char *s) {
5121 int signo;
5122 int offset = 0;
5123 unsigned u;
5124
5125 signo = __signal_from_string(s);
5126 if (signo > 0)
5127 return signo;
5128
5129 if (startswith(s, "RTMIN+")) {
5130 s += 6;
5131 offset = SIGRTMIN;
5132 }
5133 if (safe_atou(s, &u) >= 0) {
5134 signo = (int) u + offset;
5135 if (signo > 0 && signo < _NSIG)
5136 return signo;
5137 }
5138 return -EINVAL;
5139}
5140
5141bool kexec_loaded(void) {
5142 bool loaded = false;
5143 char *s;
5144
5145 if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5146 if (s[0] == '1')
5147 loaded = true;
5148 free(s);
5149 }
5150 return loaded;
5151}
5152
5153int prot_from_flags(int flags) {
5154
5155 switch (flags & O_ACCMODE) {
5156
5157 case O_RDONLY:
5158 return PROT_READ;
5159
5160 case O_WRONLY:
5161 return PROT_WRITE;
5162
5163 case O_RDWR:
5164 return PROT_READ|PROT_WRITE;
5165
5166 default:
5167 return -EINVAL;
5168 }
5169}
5170
5171char *format_bytes(char *buf, size_t l, off_t t) {
5172 unsigned i;
5173
5174 static const struct {
5175 const char *suffix;
5176 off_t factor;
5177 } table[] = {
5178 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5179 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5180 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5181 { "G", 1024ULL*1024ULL*1024ULL },
5182 { "M", 1024ULL*1024ULL },
5183 { "K", 1024ULL },
5184 };
5185
5186 for (i = 0; i < ELEMENTSOF(table); i++) {
5187
5188 if (t >= table[i].factor) {
5189 snprintf(buf, l,
5190 "%llu.%llu%s",
5191 (unsigned long long) (t / table[i].factor),
5192 (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5193 table[i].suffix);
5194
5195 goto finish;
5196 }
5197 }
5198
5199 snprintf(buf, l, "%lluB", (unsigned long long) t);
5200
5201finish:
5202 buf[l-1] = 0;
5203 return buf;
5204
5205}
5206
5207void* memdup(const void *p, size_t l) {
5208 void *r;
5209
5210 assert(p);
5211
5212 r = malloc(l);
5213 if (!r)
5214 return NULL;
5215
5216 memcpy(r, p, l);
5217 return r;
5218}
5219
5220int fd_inc_sndbuf(int fd, size_t n) {
5221 int r, value;
5222 socklen_t l = sizeof(value);
5223
5224 r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5225 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5226 return 0;
5227
5228 /* If we have the privileges we will ignore the kernel limit. */
5229
5230 value = (int) n;
5231 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
5232 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
5233 return -errno;
5234
5235 return 1;
5236}
5237
5238int fd_inc_rcvbuf(int fd, size_t n) {
5239 int r, value;
5240 socklen_t l = sizeof(value);
5241
5242 r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5243 if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5244 return 0;
5245
5246 /* If we have the privileges we will ignore the kernel limit. */
5247
5248 value = (int) n;
5249 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
5250 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
5251 return -errno;
5252 return 1;
5253}
5254
5255int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5256 bool stdout_is_tty, stderr_is_tty;
5257 pid_t parent_pid, agent_pid;
5258 sigset_t ss, saved_ss;
5259 unsigned n, i;
5260 va_list ap;
5261 char **l;
5262
5263 assert(pid);
5264 assert(path);
5265
5266 /* Spawns a temporary TTY agent, making sure it goes away when
5267 * we go away */
5268
5269 parent_pid = getpid();
5270
5271 /* First we temporarily block all signals, so that the new
5272 * child has them blocked initially. This way, we can be sure
5273 * that SIGTERMs are not lost we might send to the agent. */
5274 assert_se(sigfillset(&ss) >= 0);
5275 assert_se(sigprocmask(SIG_SETMASK, &ss, &saved_ss) >= 0);
5276
5277 agent_pid = fork();
5278 if (agent_pid < 0) {
5279 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5280 return -errno;
5281 }
5282
5283 if (agent_pid != 0) {
5284 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5285 *pid = agent_pid;
5286 return 0;
5287 }
5288
5289 /* In the child:
5290 *
5291 * Make sure the agent goes away when the parent dies */
5292 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5293 _exit(EXIT_FAILURE);
5294
5295 /* Make sure we actually can kill the agent, if we need to, in
5296 * case somebody invoked us from a shell script that trapped
5297 * SIGTERM or so... */
5298 reset_all_signal_handlers();
5299 reset_signal_mask();
5300
5301 /* Check whether our parent died before we were able
5302 * to set the death signal and unblock the signals */
5303 if (getppid() != parent_pid)
5304 _exit(EXIT_SUCCESS);
5305
5306 /* Don't leak fds to the agent */
5307 close_all_fds(except, n_except);
5308
5309 stdout_is_tty = isatty(STDOUT_FILENO);
5310 stderr_is_tty = isatty(STDERR_FILENO);
5311
5312 if (!stdout_is_tty || !stderr_is_tty) {
5313 int fd;
5314
5315 /* Detach from stdout/stderr. and reopen
5316 * /dev/tty for them. This is important to
5317 * ensure that when systemctl is started via
5318 * popen() or a similar call that expects to
5319 * read EOF we actually do generate EOF and
5320 * not delay this indefinitely by because we
5321 * keep an unused copy of stdin around. */
5322 fd = open("/dev/tty", O_WRONLY);
5323 if (fd < 0) {
5324 log_error_errno(errno, "Failed to open /dev/tty: %m");
5325 _exit(EXIT_FAILURE);
5326 }
5327
5328 if (!stdout_is_tty)
5329 dup2(fd, STDOUT_FILENO);
5330
5331 if (!stderr_is_tty)
5332 dup2(fd, STDERR_FILENO);
5333
5334 if (fd > 2)
5335 close(fd);
5336 }
5337
5338 /* Count arguments */
5339 va_start(ap, path);
5340 for (n = 0; va_arg(ap, char*); n++)
5341 ;
5342 va_end(ap);
5343
5344 /* Allocate strv */
5345 l = alloca(sizeof(char *) * (n + 1));
5346
5347 /* Fill in arguments */
5348 va_start(ap, path);
5349 for (i = 0; i <= n; i++)
5350 l[i] = va_arg(ap, char*);
5351 va_end(ap);
5352
5353 execv(path, l);
5354 _exit(EXIT_FAILURE);
5355}
5356
5357int setrlimit_closest(int resource, const struct rlimit *rlim) {
5358 struct rlimit highest, fixed;
5359
5360 assert(rlim);
5361
5362 if (setrlimit(resource, rlim) >= 0)
5363 return 0;
5364
5365 if (errno != EPERM)
5366 return -errno;
5367
5368 /* So we failed to set the desired setrlimit, then let's try
5369 * to get as close as we can */
5370 assert_se(getrlimit(resource, &highest) == 0);
5371
5372 fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5373 fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5374
5375 if (setrlimit(resource, &fixed) < 0)
5376 return -errno;
5377
5378 return 0;
5379}
5380
5381int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5382 _cleanup_fclose_ FILE *f = NULL;
5383 char *value = NULL;
5384 int r;
5385 bool done = false;
5386 size_t l;
5387 const char *path;
5388
5389 assert(pid >= 0);
5390 assert(field);
5391 assert(_value);
5392
5393 path = procfs_file_alloca(pid, "environ");
5394
5395 f = fopen(path, "re");
5396 if (!f)
5397 return -errno;
5398
5399 l = strlen(field);
5400 r = 0;
5401
5402 do {
5403 char line[LINE_MAX];
5404 unsigned i;
5405
5406 for (i = 0; i < sizeof(line)-1; i++) {
5407 int c;
5408
5409 c = getc(f);
5410 if (_unlikely_(c == EOF)) {
5411 done = true;
5412 break;
5413 } else if (c == 0)
5414 break;
5415
5416 line[i] = c;
5417 }
5418 line[i] = 0;
5419
5420 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5421 value = strdup(line + l + 1);
5422 if (!value)
5423 return -ENOMEM;
5424
5425 r = 1;
5426 break;
5427 }
5428
5429 } while (!done);
5430
5431 *_value = value;
5432 return r;
5433}
5434
5435bool is_valid_documentation_url(const char *url) {
5436 assert(url);
5437
5438 if (startswith(url, "http://") && url[7])
5439 return true;
5440
5441 if (startswith(url, "https://") && url[8])
5442 return true;
5443
5444 if (startswith(url, "file:") && url[5])
5445 return true;
5446
5447 if (startswith(url, "info:") && url[5])
5448 return true;
5449
5450 if (startswith(url, "man:") && url[4])
5451 return true;
5452
5453 return false;
5454}
5455
5456bool in_initrd(void) {
5457 static int saved = -1;
5458 struct statfs s;
5459
5460 if (saved >= 0)
5461 return saved;
5462
5463 /* We make two checks here:
5464 *
5465 * 1. the flag file /etc/initrd-release must exist
5466 * 2. the root file system must be a memory file system
5467 *
5468 * The second check is extra paranoia, since misdetecting an
5469 * initrd can have bad bad consequences due the initrd
5470 * emptying when transititioning to the main systemd.
5471 */
5472
5473 saved = access("/etc/initrd-release", F_OK) >= 0 &&
5474 statfs("/", &s) >= 0 &&
5475 is_temporary_fs(&s);
5476
5477 return saved;
5478}
5479
5480void warn_melody(void) {
5481 _cleanup_close_ int fd = -1;
5482
5483 fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5484 if (fd < 0)
5485 return;
5486
5487 /* Yeah, this is synchronous. Kinda sucks. But well... */
5488
5489 ioctl(fd, KIOCSOUND, (int)(1193180/440));
5490 usleep(125*USEC_PER_MSEC);
5491
5492 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5493 usleep(125*USEC_PER_MSEC);
5494
5495 ioctl(fd, KIOCSOUND, (int)(1193180/220));
5496 usleep(125*USEC_PER_MSEC);
5497
5498 ioctl(fd, KIOCSOUND, 0);
5499}
5500
5501int make_console_stdio(void) {
5502 int fd, r;
5503
5504 /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5505
5506 fd = acquire_terminal("/dev/console", false, true, true, USEC_INFINITY);
5507 if (fd < 0)
5508 return log_error_errno(fd, "Failed to acquire terminal: %m");
5509
5510 r = make_stdio(fd);
5511 if (r < 0)
5512 return log_error_errno(r, "Failed to duplicate terminal fd: %m");
5513
5514 return 0;
5515}
5516
5517int get_home_dir(char **_h) {
5518 struct passwd *p;
5519 const char *e;
5520 char *h;
5521 uid_t u;
5522
5523 assert(_h);
5524
5525 /* Take the user specified one */
5526 e = secure_getenv("HOME");
5527 if (e && path_is_absolute(e)) {
5528 h = strdup(e);
5529 if (!h)
5530 return -ENOMEM;
5531
5532 *_h = h;
5533 return 0;
5534 }
5535
5536 /* Hardcode home directory for root to avoid NSS */
5537 u = getuid();
5538 if (u == 0) {
5539 h = strdup("/root");
5540 if (!h)
5541 return -ENOMEM;
5542
5543 *_h = h;
5544 return 0;
5545 }
5546
5547 /* Check the database... */
5548 errno = 0;
5549 p = getpwuid(u);
5550 if (!p)
5551 return errno > 0 ? -errno : -ESRCH;
5552
5553 if (!path_is_absolute(p->pw_dir))
5554 return -EINVAL;
5555
5556 h = strdup(p->pw_dir);
5557 if (!h)
5558 return -ENOMEM;
5559
5560 *_h = h;
5561 return 0;
5562}
5563
5564int get_shell(char **_s) {
5565 struct passwd *p;
5566 const char *e;
5567 char *s;
5568 uid_t u;
5569
5570 assert(_s);
5571
5572 /* Take the user specified one */
5573 e = getenv("SHELL");
5574 if (e) {
5575 s = strdup(e);
5576 if (!s)
5577 return -ENOMEM;
5578
5579 *_s = s;
5580 return 0;
5581 }
5582
5583 /* Hardcode home directory for root to avoid NSS */
5584 u = getuid();
5585 if (u == 0) {
5586 s = strdup("/bin/sh");
5587 if (!s)
5588 return -ENOMEM;
5589
5590 *_s = s;
5591 return 0;
5592 }
5593
5594 /* Check the database... */
5595 errno = 0;
5596 p = getpwuid(u);
5597 if (!p)
5598 return errno > 0 ? -errno : -ESRCH;
5599
5600 if (!path_is_absolute(p->pw_shell))
5601 return -EINVAL;
5602
5603 s = strdup(p->pw_shell);
5604 if (!s)
5605 return -ENOMEM;
5606
5607 *_s = s;
5608 return 0;
5609}
5610
5611bool filename_is_safe(const char *p) {
5612
5613 if (isempty(p))
5614 return false;
5615
5616 if (strchr(p, '/'))
5617 return false;
5618
5619 if (streq(p, "."))
5620 return false;
5621
5622 if (streq(p, ".."))
5623 return false;
5624
5625 if (strlen(p) > FILENAME_MAX)
5626 return false;
5627
5628 return true;
5629}
5630
5631bool string_is_safe(const char *p) {
5632 const char *t;
5633
5634 if (!p)
5635 return false;
5636
5637 for (t = p; *t; t++) {
5638 if (*t > 0 && *t < ' ')
5639 return false;
5640
5641 if (strchr("\\\"\'\0x7f", *t))
5642 return false;
5643 }
5644
5645 return true;
5646}
5647
5648/**
5649 * Check if a string contains control characters. If 'ok' is non-NULL
5650 * it may be a string containing additional CCs to be considered OK.
5651 */
5652bool string_has_cc(const char *p, const char *ok) {
5653 const char *t;
5654
5655 assert(p);
5656
5657 for (t = p; *t; t++) {
5658 if (ok && strchr(ok, *t))
5659 continue;
5660
5661 if (*t > 0 && *t < ' ')
5662 return true;
5663
5664 if (*t == 127)
5665 return true;
5666 }
5667
5668 return false;
5669}
5670
5671bool path_is_safe(const char *p) {
5672
5673 if (isempty(p))
5674 return false;
5675
5676 if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5677 return false;
5678
5679 if (strlen(p) > PATH_MAX)
5680 return false;
5681
5682 /* The following two checks are not really dangerous, but hey, they still are confusing */
5683 if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5684 return false;
5685
5686 if (strstr(p, "//"))
5687 return false;
5688
5689 return true;
5690}
5691
5692/* hey glibc, APIs with callbacks without a user pointer are so useless */
5693void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5694 int (*compar) (const void *, const void *, void *), void *arg) {
5695 size_t l, u, idx;
5696 const void *p;
5697 int comparison;
5698
5699 l = 0;
5700 u = nmemb;
5701 while (l < u) {
5702 idx = (l + u) / 2;
5703 p = (void *)(((const char *) base) + (idx * size));
5704 comparison = compar(key, p, arg);
5705 if (comparison < 0)
5706 u = idx;
5707 else if (comparison > 0)
5708 l = idx + 1;
5709 else
5710 return (void *)p;
5711 }
5712 return NULL;
5713}
5714
5715bool is_locale_utf8(void) {
5716 const char *set;
5717 static int cached_answer = -1;
5718
5719 if (cached_answer >= 0)
5720 goto out;
5721
5722 if (!setlocale(LC_ALL, "")) {
5723 cached_answer = true;
5724 goto out;
5725 }
5726
5727 set = nl_langinfo(CODESET);
5728 if (!set) {
5729 cached_answer = true;
5730 goto out;
5731 }
5732
5733 if (streq(set, "UTF-8")) {
5734 cached_answer = true;
5735 goto out;
5736 }
5737
5738 /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5739 * unset and everything can do to UTF-8 nowadays. */
5740 set = setlocale(LC_CTYPE, NULL);
5741 if (!set) {
5742 cached_answer = true;
5743 goto out;
5744 }
5745
5746 /* Check result, but ignore the result if C was set
5747 * explicitly. */
5748 cached_answer =
5749 streq(set, "C") &&
5750 !getenv("LC_ALL") &&
5751 !getenv("LC_CTYPE") &&
5752 !getenv("LANG");
5753
5754out:
5755 return (bool) cached_answer;
5756}
5757
5758const char *draw_special_char(DrawSpecialChar ch) {
5759 static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5760
5761 /* UTF-8 */ {
5762 [DRAW_TREE_VERTICAL] = "\342\224\202 ", /* │ */
5763 [DRAW_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
5764 [DRAW_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
5765 [DRAW_TREE_SPACE] = " ", /* */
5766 [DRAW_TRIANGULAR_BULLET] = "\342\200\243", /* ‣ */
5767 [DRAW_BLACK_CIRCLE] = "\342\227\217", /* ● */
5768 [DRAW_ARROW] = "\342\206\222", /* → */
5769 [DRAW_DASH] = "\342\200\223", /* – */
5770 },
5771
5772 /* ASCII fallback */ {
5773 [DRAW_TREE_VERTICAL] = "| ",
5774 [DRAW_TREE_BRANCH] = "|-",
5775 [DRAW_TREE_RIGHT] = "`-",
5776 [DRAW_TREE_SPACE] = " ",
5777 [DRAW_TRIANGULAR_BULLET] = ">",
5778 [DRAW_BLACK_CIRCLE] = "*",
5779 [DRAW_ARROW] = "->",
5780 [DRAW_DASH] = "-",
5781 }
5782 };
5783
5784 return draw_table[!is_locale_utf8()][ch];
5785}
5786
5787char *strreplace(const char *text, const char *old_string, const char *new_string) {
5788 const char *f;
5789 char *t, *r;
5790 size_t l, old_len, new_len;
5791
5792 assert(text);
5793 assert(old_string);
5794 assert(new_string);
5795
5796 old_len = strlen(old_string);
5797 new_len = strlen(new_string);
5798
5799 l = strlen(text);
5800 r = new(char, l+1);
5801 if (!r)
5802 return NULL;
5803
5804 f = text;
5805 t = r;
5806 while (*f) {
5807 char *a;
5808 size_t d, nl;
5809
5810 if (!startswith(f, old_string)) {
5811 *(t++) = *(f++);
5812 continue;
5813 }
5814
5815 d = t - r;
5816 nl = l - old_len + new_len;
5817 a = realloc(r, nl + 1);
5818 if (!a)
5819 goto oom;
5820
5821 l = nl;
5822 r = a;
5823 t = r + d;
5824
5825 t = stpcpy(t, new_string);
5826 f += old_len;
5827 }
5828
5829 *t = 0;
5830 return r;
5831
5832oom:
5833 free(r);
5834 return NULL;
5835}
5836
5837char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5838 const char *i, *begin = NULL;
5839 enum {
5840 STATE_OTHER,
5841 STATE_ESCAPE,
5842 STATE_BRACKET
5843 } state = STATE_OTHER;
5844 char *obuf = NULL;
5845 size_t osz = 0, isz;
5846 FILE *f;
5847
5848 assert(ibuf);
5849 assert(*ibuf);
5850
5851 /* Strips ANSI color and replaces TABs by 8 spaces */
5852
5853 isz = _isz ? *_isz : strlen(*ibuf);
5854
5855 f = open_memstream(&obuf, &osz);
5856 if (!f)
5857 return NULL;
5858
5859 for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5860
5861 switch (state) {
5862
5863 case STATE_OTHER:
5864 if (i >= *ibuf + isz) /* EOT */
5865 break;
5866 else if (*i == '\x1B')
5867 state = STATE_ESCAPE;
5868 else if (*i == '\t')
5869 fputs(" ", f);
5870 else
5871 fputc(*i, f);
5872 break;
5873
5874 case STATE_ESCAPE:
5875 if (i >= *ibuf + isz) { /* EOT */
5876 fputc('\x1B', f);
5877 break;
5878 } else if (*i == '[') {
5879 state = STATE_BRACKET;
5880 begin = i + 1;
5881 } else {
5882 fputc('\x1B', f);
5883 fputc(*i, f);
5884 state = STATE_OTHER;
5885 }
5886
5887 break;
5888
5889 case STATE_BRACKET:
5890
5891 if (i >= *ibuf + isz || /* EOT */
5892 (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5893 fputc('\x1B', f);
5894 fputc('[', f);
5895 state = STATE_OTHER;
5896 i = begin-1;
5897 } else if (*i == 'm')
5898 state = STATE_OTHER;
5899 break;
5900 }
5901 }
5902
5903 if (ferror(f)) {
5904 fclose(f);
5905 free(obuf);
5906 return NULL;
5907 }
5908
5909 fclose(f);
5910
5911 free(*ibuf);
5912 *ibuf = obuf;
5913
5914 if (_isz)
5915 *_isz = osz;
5916
5917 return obuf;
5918}
5919
5920int on_ac_power(void) {
5921 bool found_offline = false, found_online = false;
5922 _cleanup_closedir_ DIR *d = NULL;
5923
5924 d = opendir("/sys/class/power_supply");
5925 if (!d)
5926 return -errno;
5927
5928 for (;;) {
5929 struct dirent *de;
5930 _cleanup_close_ int fd = -1, device = -1;
5931 char contents[6];
5932 ssize_t n;
5933
5934 errno = 0;
5935 de = readdir(d);
5936 if (!de && errno != 0)
5937 return -errno;
5938
5939 if (!de)
5940 break;
5941
5942 if (ignore_file(de->d_name))
5943 continue;
5944
5945 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5946 if (device < 0) {
5947 if (errno == ENOENT || errno == ENOTDIR)
5948 continue;
5949
5950 return -errno;
5951 }
5952
5953 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5954 if (fd < 0) {
5955 if (errno == ENOENT)
5956 continue;
5957
5958 return -errno;
5959 }
5960
5961 n = read(fd, contents, sizeof(contents));
5962 if (n < 0)
5963 return -errno;
5964
5965 if (n != 6 || memcmp(contents, "Mains\n", 6))
5966 continue;
5967
5968 safe_close(fd);
5969 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5970 if (fd < 0) {
5971 if (errno == ENOENT)
5972 continue;
5973
5974 return -errno;
5975 }
5976
5977 n = read(fd, contents, sizeof(contents));
5978 if (n < 0)
5979 return -errno;
5980
5981 if (n != 2 || contents[1] != '\n')
5982 return -EIO;
5983
5984 if (contents[0] == '1') {
5985 found_online = true;
5986 break;
5987 } else if (contents[0] == '0')
5988 found_offline = true;
5989 else
5990 return -EIO;
5991 }
5992
5993 return found_online || !found_offline;
5994}
5995
5996static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
5997 char **i;
5998
5999 assert(path);
6000 assert(mode);
6001 assert(_f);
6002
6003 if (!path_strv_resolve_uniq(search, root))
6004 return -ENOMEM;
6005
6006 STRV_FOREACH(i, search) {
6007 _cleanup_free_ char *p = NULL;
6008 FILE *f;
6009
6010 if (root)
6011 p = strjoin(root, *i, "/", path, NULL);
6012 else
6013 p = strjoin(*i, "/", path, NULL);
6014 if (!p)
6015 return -ENOMEM;
6016
6017 f = fopen(p, mode);
6018 if (f) {
6019 *_f = f;
6020 return 0;
6021 }
6022
6023 if (errno != ENOENT)
6024 return -errno;
6025 }
6026
6027 return -ENOENT;
6028}
6029
6030int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
6031 _cleanup_strv_free_ char **copy = NULL;
6032
6033 assert(path);
6034 assert(mode);
6035 assert(_f);
6036
6037 if (path_is_absolute(path)) {
6038 FILE *f;
6039
6040 f = fopen(path, mode);
6041 if (f) {
6042 *_f = f;
6043 return 0;
6044 }
6045
6046 return -errno;
6047 }
6048
6049 copy = strv_copy((char**) search);
6050 if (!copy)
6051 return -ENOMEM;
6052
6053 return search_and_fopen_internal(path, mode, root, copy, _f);
6054}
6055
6056int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
6057 _cleanup_strv_free_ char **s = NULL;
6058
6059 if (path_is_absolute(path)) {
6060 FILE *f;
6061
6062 f = fopen(path, mode);
6063 if (f) {
6064 *_f = f;
6065 return 0;
6066 }
6067
6068 return -errno;
6069 }
6070
6071 s = strv_split_nulstr(search);
6072 if (!s)
6073 return -ENOMEM;
6074
6075 return search_and_fopen_internal(path, mode, root, s, _f);
6076}
6077
6078char *strextend(char **x, ...) {
6079 va_list ap;
6080 size_t f, l;
6081 char *r, *p;
6082
6083 assert(x);
6084
6085 l = f = *x ? strlen(*x) : 0;
6086
6087 va_start(ap, x);
6088 for (;;) {
6089 const char *t;
6090 size_t n;
6091
6092 t = va_arg(ap, const char *);
6093 if (!t)
6094 break;
6095
6096 n = strlen(t);
6097 if (n > ((size_t) -1) - l) {
6098 va_end(ap);
6099 return NULL;
6100 }
6101
6102 l += n;
6103 }
6104 va_end(ap);
6105
6106 r = realloc(*x, l+1);
6107 if (!r)
6108 return NULL;
6109
6110 p = r + f;
6111
6112 va_start(ap, x);
6113 for (;;) {
6114 const char *t;
6115
6116 t = va_arg(ap, const char *);
6117 if (!t)
6118 break;
6119
6120 p = stpcpy(p, t);
6121 }
6122 va_end(ap);
6123
6124 *p = 0;
6125 *x = r;
6126
6127 return r + l;
6128}
6129
6130char *strrep(const char *s, unsigned n) {
6131 size_t l;
6132 char *r, *p;
6133 unsigned i;
6134
6135 assert(s);
6136
6137 l = strlen(s);
6138 p = r = malloc(l * n + 1);
6139 if (!r)
6140 return NULL;
6141
6142 for (i = 0; i < n; i++)
6143 p = stpcpy(p, s);
6144
6145 *p = 0;
6146 return r;
6147}
6148
6149void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
6150 size_t a, newalloc;
6151 void *q;
6152
6153 assert(p);
6154 assert(allocated);
6155
6156 if (*allocated >= need)
6157 return *p;
6158
6159 newalloc = MAX(need * 2, 64u / size);
6160 a = newalloc * size;
6161
6162 /* check for overflows */
6163 if (a < size * need)
6164 return NULL;
6165
6166 q = realloc(*p, a);
6167 if (!q)
6168 return NULL;
6169
6170 *p = q;
6171 *allocated = newalloc;
6172 return q;
6173}
6174
6175void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
6176 size_t prev;
6177 uint8_t *q;
6178
6179 assert(p);
6180 assert(allocated);
6181
6182 prev = *allocated;
6183
6184 q = greedy_realloc(p, allocated, need, size);
6185 if (!q)
6186 return NULL;
6187
6188 if (*allocated > prev)
6189 memzero(q + prev * size, (*allocated - prev) * size);
6190
6191 return q;
6192}
6193
6194bool id128_is_valid(const char *s) {
6195 size_t i, l;
6196
6197 l = strlen(s);
6198 if (l == 32) {
6199
6200 /* Simple formatted 128bit hex string */
6201
6202 for (i = 0; i < l; i++) {
6203 char c = s[i];
6204
6205 if (!(c >= '0' && c <= '9') &&
6206 !(c >= 'a' && c <= 'z') &&
6207 !(c >= 'A' && c <= 'Z'))
6208 return false;
6209 }
6210
6211 } else if (l == 36) {
6212
6213 /* Formatted UUID */
6214
6215 for (i = 0; i < l; i++) {
6216 char c = s[i];
6217
6218 if ((i == 8 || i == 13 || i == 18 || i == 23)) {
6219 if (c != '-')
6220 return false;
6221 } else {
6222 if (!(c >= '0' && c <= '9') &&
6223 !(c >= 'a' && c <= 'z') &&
6224 !(c >= 'A' && c <= 'Z'))
6225 return false;
6226 }
6227 }
6228
6229 } else
6230 return false;
6231
6232 return true;
6233}
6234
6235int split_pair(const char *s, const char *sep, char **l, char **r) {
6236 char *x, *a, *b;
6237
6238 assert(s);
6239 assert(sep);
6240 assert(l);
6241 assert(r);
6242
6243 if (isempty(sep))
6244 return -EINVAL;
6245
6246 x = strstr(s, sep);
6247 if (!x)
6248 return -EINVAL;
6249
6250 a = strndup(s, x - s);
6251 if (!a)
6252 return -ENOMEM;
6253
6254 b = strdup(x + strlen(sep));
6255 if (!b) {
6256 free(a);
6257 return -ENOMEM;
6258 }
6259
6260 *l = a;
6261 *r = b;
6262
6263 return 0;
6264}
6265
6266int shall_restore_state(void) {
6267 _cleanup_free_ char *value = NULL;
6268 int r;
6269
6270 r = get_proc_cmdline_key("systemd.restore_state=", &value);
6271 if (r < 0)
6272 return r;
6273 if (r == 0)
6274 return true;
6275
6276 return parse_boolean(value) != 0;
6277}
6278
6279int proc_cmdline(char **ret) {
6280 assert(ret);
6281
6282 if (detect_container(NULL) > 0)
6283 return get_process_cmdline(1, 0, false, ret);
6284 else
6285 return read_one_line_file("/proc/cmdline", ret);
6286}
6287
6288int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
6289 _cleanup_free_ char *line = NULL;
6290 const char *p;
6291 int r;
6292
6293 assert(parse_item);
6294
6295 r = proc_cmdline(&line);
6296 if (r < 0)
6297 return r;
6298
6299 p = line;
6300 for (;;) {
6301 _cleanup_free_ char *word = NULL;
6302 char *value = NULL;
6303
6304 r = unquote_first_word(&p, &word, true);
6305 if (r < 0)
6306 return r;
6307 if (r == 0)
6308 break;
6309
6310 /* Filter out arguments that are intended only for the
6311 * initrd */
6312 if (!in_initrd() && startswith(word, "rd."))
6313 continue;
6314
6315 value = strchr(word, '=');
6316 if (value)
6317 *(value++) = 0;
6318
6319 r = parse_item(word, value);
6320 if (r < 0)
6321 return r;
6322 }
6323
6324 return 0;
6325}
6326
6327int get_proc_cmdline_key(const char *key, char **value) {
6328 _cleanup_free_ char *line = NULL, *ret = NULL;
6329 bool found = false;
6330 const char *p;
6331 int r;
6332
6333 assert(key);
6334
6335 r = proc_cmdline(&line);
6336 if (r < 0)
6337 return r;
6338
6339 p = line;
6340 for (;;) {
6341 _cleanup_free_ char *word = NULL;
6342 const char *e;
6343
6344 r = unquote_first_word(&p, &word, true);
6345 if (r < 0)
6346 return r;
6347 if (r == 0)
6348 break;
6349
6350 /* Filter out arguments that are intended only for the
6351 * initrd */
6352 if (!in_initrd() && startswith(word, "rd."))
6353 continue;
6354
6355 if (value) {
6356 e = startswith(word, key);
6357 if (!e)
6358 continue;
6359
6360 r = free_and_strdup(&ret, e);
6361 if (r < 0)
6362 return r;
6363
6364 found = true;
6365 } else {
6366 if (streq(word, key))
6367 found = true;
6368 }
6369 }
6370
6371 if (value) {
6372 *value = ret;
6373 ret = NULL;
6374 }
6375
6376 return found;
6377
6378}
6379
6380int container_get_leader(const char *machine, pid_t *pid) {
6381 _cleanup_free_ char *s = NULL, *class = NULL;
6382 const char *p;
6383 pid_t leader;
6384 int r;
6385
6386 assert(machine);
6387 assert(pid);
6388
6389 p = strappenda("/run/systemd/machines/", machine);
6390 r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
6391 if (r == -ENOENT)
6392 return -EHOSTDOWN;
6393 if (r < 0)
6394 return r;
6395 if (!s)
6396 return -EIO;
6397
6398 if (!streq_ptr(class, "container"))
6399 return -EIO;
6400
6401 r = parse_pid(s, &leader);
6402 if (r < 0)
6403 return r;
6404 if (leader <= 1)
6405 return -EIO;
6406
6407 *pid = leader;
6408 return 0;
6409}
6410
6411int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *root_fd) {
6412 _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, netnsfd = -1;
6413 int rfd = -1;
6414
6415 assert(pid >= 0);
6416
6417 if (mntns_fd) {
6418 const char *mntns;
6419
6420 mntns = procfs_file_alloca(pid, "ns/mnt");
6421 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6422 if (mntnsfd < 0)
6423 return -errno;
6424 }
6425
6426 if (pidns_fd) {
6427 const char *pidns;
6428
6429 pidns = procfs_file_alloca(pid, "ns/pid");
6430 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6431 if (pidnsfd < 0)
6432 return -errno;
6433 }
6434
6435 if (netns_fd) {
6436 const char *netns;
6437
6438 netns = procfs_file_alloca(pid, "ns/net");
6439 netnsfd = open(netns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6440 if (netnsfd < 0)
6441 return -errno;
6442 }
6443
6444 if (root_fd) {
6445 const char *root;
6446
6447 root = procfs_file_alloca(pid, "root");
6448 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6449 if (rfd < 0)
6450 return -errno;
6451 }
6452
6453 if (pidns_fd)
6454 *pidns_fd = pidnsfd;
6455
6456 if (mntns_fd)
6457 *mntns_fd = mntnsfd;
6458
6459 if (netns_fd)
6460 *netns_fd = netnsfd;
6461
6462 if (root_fd)
6463 *root_fd = rfd;
6464
6465 pidnsfd = mntnsfd = netnsfd = -1;
6466
6467 return 0;
6468}
6469
6470int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int root_fd) {
6471
6472 if (pidns_fd >= 0)
6473 if (setns(pidns_fd, CLONE_NEWPID) < 0)
6474 return -errno;
6475
6476 if (mntns_fd >= 0)
6477 if (setns(mntns_fd, CLONE_NEWNS) < 0)
6478 return -errno;
6479
6480 if (netns_fd >= 0)
6481 if (setns(netns_fd, CLONE_NEWNET) < 0)
6482 return -errno;
6483
6484 if (root_fd >= 0) {
6485 if (fchdir(root_fd) < 0)
6486 return -errno;
6487
6488 if (chroot(".") < 0)
6489 return -errno;
6490 }
6491
6492 if (setresgid(0, 0, 0) < 0)
6493 return -errno;
6494
6495 if (setgroups(0, NULL) < 0)
6496 return -errno;
6497
6498 if (setresuid(0, 0, 0) < 0)
6499 return -errno;
6500
6501 return 0;
6502}
6503
6504bool pid_is_unwaited(pid_t pid) {
6505 /* Checks whether a PID is still valid at all, including a zombie */
6506
6507 if (pid <= 0)
6508 return false;
6509
6510 if (kill(pid, 0) >= 0)
6511 return true;
6512
6513 return errno != ESRCH;
6514}
6515
6516bool pid_is_alive(pid_t pid) {
6517 int r;
6518
6519 /* Checks whether a PID is still valid and not a zombie */
6520
6521 if (pid <= 0)
6522 return false;
6523
6524 r = get_process_state(pid);
6525 if (r == -ENOENT || r == 'Z')
6526 return false;
6527
6528 return true;
6529}
6530
6531int getpeercred(int fd, struct ucred *ucred) {
6532 socklen_t n = sizeof(struct ucred);
6533 struct ucred u;
6534 int r;
6535
6536 assert(fd >= 0);
6537 assert(ucred);
6538
6539 r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
6540 if (r < 0)
6541 return -errno;
6542
6543 if (n != sizeof(struct ucred))
6544 return -EIO;
6545
6546 /* Check if the data is actually useful and not suppressed due
6547 * to namespacing issues */
6548 if (u.pid <= 0)
6549 return -ENODATA;
6550 if (u.uid == (uid_t) -1)
6551 return -ENODATA;
6552 if (u.gid == (gid_t) -1)
6553 return -ENODATA;
6554
6555 *ucred = u;
6556 return 0;
6557}
6558
6559int getpeersec(int fd, char **ret) {
6560 socklen_t n = 64;
6561 char *s;
6562 int r;
6563
6564 assert(fd >= 0);
6565 assert(ret);
6566
6567 s = new0(char, n);
6568 if (!s)
6569 return -ENOMEM;
6570
6571 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6572 if (r < 0) {
6573 free(s);
6574
6575 if (errno != ERANGE)
6576 return -errno;
6577
6578 s = new0(char, n);
6579 if (!s)
6580 return -ENOMEM;
6581
6582 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6583 if (r < 0) {
6584 free(s);
6585 return -errno;
6586 }
6587 }
6588
6589 if (isempty(s)) {
6590 free(s);
6591 return -ENOTSUP;
6592 }
6593
6594 *ret = s;
6595 return 0;
6596}
6597
6598/* This is much like like mkostemp() but is subject to umask(). */
6599int mkostemp_safe(char *pattern, int flags) {
6600 _cleanup_umask_ mode_t u;
6601 int fd;
6602
6603 assert(pattern);
6604
6605 u = umask(077);
6606
6607 fd = mkostemp(pattern, flags);
6608 if (fd < 0)
6609 return -errno;
6610
6611 return fd;
6612}
6613
6614int open_tmpfile(const char *path, int flags) {
6615 char *p;
6616 int fd;
6617
6618 assert(path);
6619
6620#ifdef O_TMPFILE
6621 /* Try O_TMPFILE first, if it is supported */
6622 fd = open(path, flags|O_TMPFILE, S_IRUSR|S_IWUSR);
6623 if (fd >= 0)
6624 return fd;
6625#endif
6626
6627 /* Fall back to unguessable name + unlinking */
6628 p = strappenda(path, "/systemd-tmp-XXXXXX");
6629
6630 fd = mkostemp_safe(p, flags);
6631 if (fd < 0)
6632 return fd;
6633
6634 unlink(p);
6635 return fd;
6636}
6637
6638int fd_warn_permissions(const char *path, int fd) {
6639 struct stat st;
6640
6641 if (fstat(fd, &st) < 0)
6642 return -errno;
6643
6644 if (st.st_mode & 0111)
6645 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
6646
6647 if (st.st_mode & 0002)
6648 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
6649
6650 if (getpid() == 1 && (st.st_mode & 0044) != 0044)
6651 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);
6652
6653 return 0;
6654}
6655
6656unsigned long personality_from_string(const char *p) {
6657
6658 /* Parse a personality specifier. We introduce our own
6659 * identifiers that indicate specific ABIs, rather than just
6660 * hints regarding the register size, since we want to keep
6661 * things open for multiple locally supported ABIs for the
6662 * same register size. We try to reuse the ABI identifiers
6663 * used by libseccomp. */
6664
6665#if defined(__x86_64__)
6666
6667 if (streq(p, "x86"))
6668 return PER_LINUX32;
6669
6670 if (streq(p, "x86-64"))
6671 return PER_LINUX;
6672
6673#elif defined(__i386__)
6674
6675 if (streq(p, "x86"))
6676 return PER_LINUX;
6677#endif
6678
6679 /* personality(7) documents that 0xffffffffUL is used for
6680 * querying the current personality, hence let's use that here
6681 * as error indicator. */
6682 return 0xffffffffUL;
6683}
6684
6685const char* personality_to_string(unsigned long p) {
6686
6687#if defined(__x86_64__)
6688
6689 if (p == PER_LINUX32)
6690 return "x86";
6691
6692 if (p == PER_LINUX)
6693 return "x86-64";
6694
6695#elif defined(__i386__)
6696
6697 if (p == PER_LINUX)
6698 return "x86";
6699#endif
6700
6701 return NULL;
6702}
6703
6704uint64_t physical_memory(void) {
6705 long mem;
6706
6707 /* We return this as uint64_t in case we are running as 32bit
6708 * process on a 64bit kernel with huge amounts of memory */
6709
6710 mem = sysconf(_SC_PHYS_PAGES);
6711 assert(mem > 0);
6712
6713 return (uint64_t) mem * (uint64_t) page_size();
6714}
6715
6716char* mount_test_option(const char *haystack, const char *needle) {
6717
6718 struct mntent me = {
6719 .mnt_opts = (char*) haystack
6720 };
6721
6722 assert(needle);
6723
6724 /* Like glibc's hasmntopt(), but works on a string, not a
6725 * struct mntent */
6726
6727 if (!haystack)
6728 return NULL;
6729
6730 return hasmntopt(&me, needle);
6731}
6732
6733void hexdump(FILE *f, const void *p, size_t s) {
6734 const uint8_t *b = p;
6735 unsigned n = 0;
6736
6737 assert(s == 0 || b);
6738
6739 while (s > 0) {
6740 size_t i;
6741
6742 fprintf(f, "%04x ", n);
6743
6744 for (i = 0; i < 16; i++) {
6745
6746 if (i >= s)
6747 fputs(" ", f);
6748 else
6749 fprintf(f, "%02x ", b[i]);
6750
6751 if (i == 7)
6752 fputc(' ', f);
6753 }
6754
6755 fputc(' ', f);
6756
6757 for (i = 0; i < 16; i++) {
6758
6759 if (i >= s)
6760 fputc(' ', f);
6761 else
6762 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
6763 }
6764
6765 fputc('\n', f);
6766
6767 if (s < 16)
6768 break;
6769
6770 n += 16;
6771 b += 16;
6772 s -= 16;
6773 }
6774}
6775
6776int update_reboot_param_file(const char *param) {
6777 int r = 0;
6778
6779 if (param) {
6780
6781 r = write_string_file(REBOOT_PARAM_FILE, param);
6782 if (r < 0)
6783 log_error("Failed to write reboot param to "
6784 REBOOT_PARAM_FILE": %s", strerror(-r));
6785 } else
6786 unlink(REBOOT_PARAM_FILE);
6787
6788 return r;
6789}
6790
6791int umount_recursive(const char *prefix, int flags) {
6792 bool again;
6793 int n = 0, r;
6794
6795 /* Try to umount everything recursively below a
6796 * directory. Also, take care of stacked mounts, and keep
6797 * unmounting them until they are gone. */
6798
6799 do {
6800 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6801
6802 again = false;
6803 r = 0;
6804
6805 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6806 if (!proc_self_mountinfo)
6807 return -errno;
6808
6809 for (;;) {
6810 _cleanup_free_ char *path = NULL, *p = NULL;
6811 int k;
6812
6813 k = fscanf(proc_self_mountinfo,
6814 "%*s " /* (1) mount id */
6815 "%*s " /* (2) parent id */
6816 "%*s " /* (3) major:minor */
6817 "%*s " /* (4) root */
6818 "%ms " /* (5) mount point */
6819 "%*s" /* (6) mount options */
6820 "%*[^-]" /* (7) optional fields */
6821 "- " /* (8) separator */
6822 "%*s " /* (9) file system type */
6823 "%*s" /* (10) mount source */
6824 "%*s" /* (11) mount options 2 */
6825 "%*[^\n]", /* some rubbish at the end */
6826 &path);
6827 if (k != 1) {
6828 if (k == EOF)
6829 break;
6830
6831 continue;
6832 }
6833
6834 p = cunescape(path);
6835 if (!p)
6836 return -ENOMEM;
6837
6838 if (!path_startswith(p, prefix))
6839 continue;
6840
6841 if (umount2(p, flags) < 0) {
6842 r = -errno;
6843 continue;
6844 }
6845
6846 again = true;
6847 n++;
6848
6849 break;
6850 }
6851
6852 } while (again);
6853
6854 return r ? r : n;
6855}
6856
6857int bind_remount_recursive(const char *prefix, bool ro) {
6858 _cleanup_set_free_free_ Set *done = NULL;
6859 _cleanup_free_ char *cleaned = NULL;
6860 int r;
6861
6862 /* Recursively remount a directory (and all its submounts)
6863 * read-only or read-write. If the directory is already
6864 * mounted, we reuse the mount and simply mark it
6865 * MS_BIND|MS_RDONLY (or remove the MS_RDONLY for read-write
6866 * operation). If it isn't we first make it one. Afterwards we
6867 * apply MS_BIND|MS_RDONLY (or remove MS_RDONLY) to all
6868 * submounts we can access, too. When mounts are stacked on
6869 * the same mount point we only care for each individual
6870 * "top-level" mount on each point, as we cannot
6871 * influence/access the underlying mounts anyway. We do not
6872 * have any effect on future submounts that might get
6873 * propagated, they migt be writable. This includes future
6874 * submounts that have been triggered via autofs. */
6875
6876 cleaned = strdup(prefix);
6877 if (!cleaned)
6878 return -ENOMEM;
6879
6880 path_kill_slashes(cleaned);
6881
6882 done = set_new(&string_hash_ops);
6883 if (!done)
6884 return -ENOMEM;
6885
6886 for (;;) {
6887 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6888 _cleanup_set_free_free_ Set *todo = NULL;
6889 bool top_autofs = false;
6890 char *x;
6891
6892 todo = set_new(&string_hash_ops);
6893 if (!todo)
6894 return -ENOMEM;
6895
6896 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6897 if (!proc_self_mountinfo)
6898 return -errno;
6899
6900 for (;;) {
6901 _cleanup_free_ char *path = NULL, *p = NULL, *type = NULL;
6902 int k;
6903
6904 k = fscanf(proc_self_mountinfo,
6905 "%*s " /* (1) mount id */
6906 "%*s " /* (2) parent id */
6907 "%*s " /* (3) major:minor */
6908 "%*s " /* (4) root */
6909 "%ms " /* (5) mount point */
6910 "%*s" /* (6) mount options (superblock) */
6911 "%*[^-]" /* (7) optional fields */
6912 "- " /* (8) separator */
6913 "%ms " /* (9) file system type */
6914 "%*s" /* (10) mount source */
6915 "%*s" /* (11) mount options (bind mount) */
6916 "%*[^\n]", /* some rubbish at the end */
6917 &path,
6918 &type);
6919 if (k != 2) {
6920 if (k == EOF)
6921 break;
6922
6923 continue;
6924 }
6925
6926 p = cunescape(path);
6927 if (!p)
6928 return -ENOMEM;
6929
6930 /* Let's ignore autofs mounts. If they aren't
6931 * triggered yet, we want to avoid triggering
6932 * them, as we don't make any guarantees for
6933 * future submounts anyway. If they are
6934 * already triggered, then we will find
6935 * another entry for this. */
6936 if (streq(type, "autofs")) {
6937 top_autofs = top_autofs || path_equal(cleaned, p);
6938 continue;
6939 }
6940
6941 if (path_startswith(p, cleaned) &&
6942 !set_contains(done, p)) {
6943
6944 r = set_consume(todo, p);
6945 p = NULL;
6946
6947 if (r == -EEXIST)
6948 continue;
6949 if (r < 0)
6950 return r;
6951 }
6952 }
6953
6954 /* If we have no submounts to process anymore and if
6955 * the root is either already done, or an autofs, we
6956 * are done */
6957 if (set_isempty(todo) &&
6958 (top_autofs || set_contains(done, cleaned)))
6959 return 0;
6960
6961 if (!set_contains(done, cleaned) &&
6962 !set_contains(todo, cleaned)) {
6963 /* The prefix directory itself is not yet a
6964 * mount, make it one. */
6965 if (mount(cleaned, cleaned, NULL, MS_BIND|MS_REC, NULL) < 0)
6966 return -errno;
6967
6968 if (mount(NULL, prefix, NULL, MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
6969 return -errno;
6970
6971 x = strdup(cleaned);
6972 if (!x)
6973 return -ENOMEM;
6974
6975 r = set_consume(done, x);
6976 if (r < 0)
6977 return r;
6978 }
6979
6980 while ((x = set_steal_first(todo))) {
6981
6982 r = set_consume(done, x);
6983 if (r == -EEXIST)
6984 continue;
6985 if (r < 0)
6986 return r;
6987
6988 if (mount(NULL, x, NULL, MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0) {
6989
6990 /* Deal with mount points that are
6991 * obstructed by a later mount */
6992
6993 if (errno != ENOENT)
6994 return -errno;
6995 }
6996
6997 }
6998 }
6999}
7000
7001int fflush_and_check(FILE *f) {
7002 assert(f);
7003
7004 errno = 0;
7005 fflush(f);
7006
7007 if (ferror(f))
7008 return errno ? -errno : -EIO;
7009
7010 return 0;
7011}
7012
7013char *tempfn_xxxxxx(const char *p) {
7014 const char *fn;
7015 char *t;
7016 size_t k;
7017
7018 assert(p);
7019
7020 t = new(char, strlen(p) + 1 + 6 + 1);
7021 if (!t)
7022 return NULL;
7023
7024 fn = basename(p);
7025 k = fn - p;
7026
7027 strcpy(stpcpy(stpcpy(mempcpy(t, p, k), "."), fn), "XXXXXX");
7028
7029 return t;
7030}
7031
7032char *tempfn_random(const char *p) {
7033 const char *fn;
7034 char *t, *x;
7035 uint64_t u;
7036 size_t k;
7037 unsigned i;
7038
7039 assert(p);
7040
7041 t = new(char, strlen(p) + 1 + 16 + 1);
7042 if (!t)
7043 return NULL;
7044
7045 fn = basename(p);
7046 k = fn - p;
7047
7048 x = stpcpy(stpcpy(mempcpy(t, p, k), "."), fn);
7049
7050 u = random_u64();
7051 for (i = 0; i < 16; i++) {
7052 *(x++) = hexchar(u & 0xF);
7053 u >>= 4;
7054 }
7055
7056 *x = 0;
7057
7058 return t;
7059}
7060
7061/* make sure the hostname is not "localhost" */
7062bool is_localhost(const char *hostname) {
7063 assert(hostname);
7064
7065 /* This tries to identify local host and domain names
7066 * described in RFC6761 plus the redhatism of .localdomain */
7067
7068 return streq(hostname, "localhost") ||
7069 streq(hostname, "localhost.") ||
7070 streq(hostname, "localdomain.") ||
7071 streq(hostname, "localdomain") ||
7072 endswith(hostname, ".localhost") ||
7073 endswith(hostname, ".localhost.") ||
7074 endswith(hostname, ".localdomain") ||
7075 endswith(hostname, ".localdomain.");
7076}
7077
7078int take_password_lock(const char *root) {
7079
7080 struct flock flock = {
7081 .l_type = F_WRLCK,
7082 .l_whence = SEEK_SET,
7083 .l_start = 0,
7084 .l_len = 0,
7085 };
7086
7087 const char *path;
7088 int fd, r;
7089
7090 /* This is roughly the same as lckpwdf(), but not as awful. We
7091 * don't want to use alarm() and signals, hence we implement
7092 * our own trivial version of this.
7093 *
7094 * Note that shadow-utils also takes per-database locks in
7095 * addition to lckpwdf(). However, we don't given that they
7096 * are redundant as they they invoke lckpwdf() first and keep
7097 * it during everything they do. The per-database locks are
7098 * awfully racy, and thus we just won't do them. */
7099
7100 if (root)
7101 path = strappenda(root, "/etc/.pwd.lock");
7102 else
7103 path = "/etc/.pwd.lock";
7104
7105 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
7106 if (fd < 0)
7107 return -errno;
7108
7109 r = fcntl(fd, F_SETLKW, &flock);
7110 if (r < 0) {
7111 safe_close(fd);
7112 return -errno;
7113 }
7114
7115 return fd;
7116}
7117
7118int is_symlink(const char *path) {
7119 struct stat info;
7120
7121 if (lstat(path, &info) < 0)
7122 return -errno;
7123
7124 return !!S_ISLNK(info.st_mode);
7125}
7126
7127int is_dir(const char* path, bool follow) {
7128 struct stat st;
7129 int r;
7130
7131 if (follow)
7132 r = stat(path, &st);
7133 else
7134 r = lstat(path, &st);
7135 if (r < 0)
7136 return -errno;
7137
7138 return !!S_ISDIR(st.st_mode);
7139}
7140
7141int unquote_first_word(const char **p, char **ret, bool relax) {
7142 _cleanup_free_ char *s = NULL;
7143 size_t allocated = 0, sz = 0;
7144
7145 enum {
7146 START,
7147 VALUE,
7148 VALUE_ESCAPE,
7149 SINGLE_QUOTE,
7150 SINGLE_QUOTE_ESCAPE,
7151 DOUBLE_QUOTE,
7152 DOUBLE_QUOTE_ESCAPE,
7153 SPACE,
7154 } state = START;
7155
7156 assert(p);
7157 assert(*p);
7158 assert(ret);
7159
7160 /* Parses the first word of a string, and returns it in
7161 * *ret. Removes all quotes in the process. When parsing fails
7162 * (because of an uneven number of quotes or similar), leaves
7163 * the pointer *p at the first invalid character. */
7164
7165 for (;;) {
7166 char c = **p;
7167
7168 switch (state) {
7169
7170 case START:
7171 if (c == 0)
7172 goto finish;
7173 else if (strchr(WHITESPACE, c))
7174 break;
7175
7176 state = VALUE;
7177 /* fallthrough */
7178
7179 case VALUE:
7180 if (c == 0)
7181 goto finish;
7182 else if (c == '\'')
7183 state = SINGLE_QUOTE;
7184 else if (c == '\\')
7185 state = VALUE_ESCAPE;
7186 else if (c == '\"')
7187 state = DOUBLE_QUOTE;
7188 else if (strchr(WHITESPACE, c))
7189 state = SPACE;
7190 else {
7191 if (!GREEDY_REALLOC(s, allocated, sz+2))
7192 return -ENOMEM;
7193
7194 s[sz++] = c;
7195 }
7196
7197 break;
7198
7199 case VALUE_ESCAPE:
7200 if (c == 0) {
7201 if (relax)
7202 goto finish;
7203 return -EINVAL;
7204 }
7205
7206 if (!GREEDY_REALLOC(s, allocated, sz+2))
7207 return -ENOMEM;
7208
7209 s[sz++] = c;
7210 state = VALUE;
7211
7212 break;
7213
7214 case SINGLE_QUOTE:
7215 if (c == 0) {
7216 if (relax)
7217 goto finish;
7218 return -EINVAL;
7219 } else if (c == '\'')
7220 state = VALUE;
7221 else if (c == '\\')
7222 state = SINGLE_QUOTE_ESCAPE;
7223 else {
7224 if (!GREEDY_REALLOC(s, allocated, sz+2))
7225 return -ENOMEM;
7226
7227 s[sz++] = c;
7228 }
7229
7230 break;
7231
7232 case SINGLE_QUOTE_ESCAPE:
7233 if (c == 0) {
7234 if (relax)
7235 goto finish;
7236 return -EINVAL;
7237 }
7238
7239 if (!GREEDY_REALLOC(s, allocated, sz+2))
7240 return -ENOMEM;
7241
7242 s[sz++] = c;
7243 state = SINGLE_QUOTE;
7244 break;
7245
7246 case DOUBLE_QUOTE:
7247 if (c == 0)
7248 return -EINVAL;
7249 else if (c == '\"')
7250 state = VALUE;
7251 else if (c == '\\')
7252 state = DOUBLE_QUOTE_ESCAPE;
7253 else {
7254 if (!GREEDY_REALLOC(s, allocated, sz+2))
7255 return -ENOMEM;
7256
7257 s[sz++] = c;
7258 }
7259
7260 break;
7261
7262 case DOUBLE_QUOTE_ESCAPE:
7263 if (c == 0) {
7264 if (relax)
7265 goto finish;
7266 return -EINVAL;
7267 }
7268
7269 if (!GREEDY_REALLOC(s, allocated, sz+2))
7270 return -ENOMEM;
7271
7272 s[sz++] = c;
7273 state = DOUBLE_QUOTE;
7274 break;
7275
7276 case SPACE:
7277 if (c == 0)
7278 goto finish;
7279 if (!strchr(WHITESPACE, c))
7280 goto finish;
7281
7282 break;
7283 }
7284
7285 (*p) ++;
7286 }
7287
7288finish:
7289 if (!s) {
7290 *ret = NULL;
7291 return 0;
7292 }
7293
7294 s[sz] = 0;
7295 *ret = s;
7296 s = NULL;
7297
7298 return 1;
7299}
7300
7301int unquote_many_words(const char **p, ...) {
7302 va_list ap;
7303 char **l;
7304 int n = 0, i, c, r;
7305
7306 /* Parses a number of words from a string, stripping any
7307 * quotes if necessary. */
7308
7309 assert(p);
7310
7311 /* Count how many words are expected */
7312 va_start(ap, p);
7313 for (;;) {
7314 if (!va_arg(ap, char **))
7315 break;
7316 n++;
7317 }
7318 va_end(ap);
7319
7320 if (n <= 0)
7321 return 0;
7322
7323 /* Read all words into a temporary array */
7324 l = newa0(char*, n);
7325 for (c = 0; c < n; c++) {
7326
7327 r = unquote_first_word(p, &l[c], false);
7328 if (r < 0) {
7329 int j;
7330
7331 for (j = 0; j < c; j++)
7332 free(l[j]);
7333
7334 return r;
7335 }
7336
7337 if (r == 0)
7338 break;
7339 }
7340
7341 /* If we managed to parse all words, return them in the passed
7342 * in parameters */
7343 va_start(ap, p);
7344 for (i = 0; i < n; i++) {
7345 char **v;
7346
7347 v = va_arg(ap, char **);
7348 assert(v);
7349
7350 *v = l[i];
7351 }
7352 va_end(ap);
7353
7354 return c;
7355}
7356
7357int free_and_strdup(char **p, const char *s) {
7358 char *t;
7359
7360 assert(p);
7361
7362 /* Replaces a string pointer with an strdup()ed new string,
7363 * possibly freeing the old one. */
7364
7365 if (s) {
7366 t = strdup(s);
7367 if (!t)
7368 return -ENOMEM;
7369 } else
7370 t = NULL;
7371
7372 free(*p);
7373 *p = t;
7374
7375 return 0;
7376}
7377
7378int sethostname_idempotent(const char *s) {
7379 int r;
7380 char buf[HOST_NAME_MAX + 1] = {};
7381
7382 assert(s);
7383
7384 r = gethostname(buf, sizeof(buf));
7385 if (r < 0)
7386 return -errno;
7387
7388 if (streq(buf, s))
7389 return 0;
7390
7391 r = sethostname(s, strlen(s));
7392 if (r < 0)
7393 return -errno;
7394
7395 return 1;
7396}
Unnamed repository; edit this file 'description' to name the repository.