]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/shared/util.c
projects / thirdparty / systemd.git / blob
? search:


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