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