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