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