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


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