chiark / gitweb /
util: make sure rm_rf() can be called on symlinks (with the effect of deleting it)
[elogind.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         int 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
535         /* if s ends in \, return index of previous char */
536         return n - escaped;
537 }
538
539 /* Split a string into words. */
540 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
541         const char *current;
542
543         current = *state;
544
545         if (!*current) {
546                 assert(**state == '\0');
547                 return NULL;
548         }
549
550         current += strspn(current, separator);
551         if (!*current) {
552                 *state = current;
553                 return NULL;
554         }
555
556         if (quoted && strchr("\'\"", *current)) {
557                 char quotechars[2] = {*current, '\0'};
558
559                 *l = strcspn_escaped(current + 1, quotechars);
560                 if (current[*l + 1] == '\0' ||
561                     (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
562                         /* right quote missing or garbage at the end */
563                         *state = current;
564                         return NULL;
565                 }
566                 assert(current[*l + 1] == quotechars[0]);
567                 *state = current++ + *l + 2;
568         } else if (quoted) {
569                 *l = strcspn_escaped(current, separator);
570                 if (current[*l] && !strchr(separator, current[*l])) {
571                         /* unfinished escape */
572                         *state = current;
573                         return NULL;
574                 }
575                 *state = current + *l;
576         } else {
577                 *l = strcspn(current, separator);
578                 *state = current + *l;
579         }
580
581         return current;
582 }
583
584 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
585         int r;
586         _cleanup_free_ char *line = NULL;
587         long unsigned ppid;
588         const char *p;
589
590         assert(pid >= 0);
591         assert(_ppid);
592
593         if (pid == 0) {
594                 *_ppid = getppid();
595                 return 0;
596         }
597
598         p = procfs_file_alloca(pid, "stat");
599         r = read_one_line_file(p, &line);
600         if (r < 0)
601                 return r;
602
603         /* Let's skip the pid and comm fields. The latter is enclosed
604          * in () but does not escape any () in its value, so let's
605          * skip over it manually */
606
607         p = strrchr(line, ')');
608         if (!p)
609                 return -EIO;
610
611         p++;
612
613         if (sscanf(p, " "
614                    "%*c "  /* state */
615                    "%lu ", /* ppid */
616                    &ppid) != 1)
617                 return -EIO;
618
619         if ((long unsigned) (pid_t) ppid != ppid)
620                 return -ERANGE;
621
622         *_ppid = (pid_t) ppid;
623
624         return 0;
625 }
626
627 int fchmod_umask(int fd, mode_t m) {
628         mode_t u;
629         int r;
630
631         u = umask(0777);
632         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
633         umask(u);
634
635         return r;
636 }
637
638 char *truncate_nl(char *s) {
639         assert(s);
640
641         s[strcspn(s, NEWLINE)] = 0;
642         return s;
643 }
644
645 int get_process_state(pid_t pid) {
646         const char *p;
647         char state;
648         int r;
649         _cleanup_free_ char *line = NULL;
650
651         assert(pid >= 0);
652
653         p = procfs_file_alloca(pid, "stat");
654         r = read_one_line_file(p, &line);
655         if (r < 0)
656                 return r;
657
658         p = strrchr(line, ')');
659         if (!p)
660                 return -EIO;
661
662         p++;
663
664         if (sscanf(p, " %c", &state) != 1)
665                 return -EIO;
666
667         return (unsigned char) state;
668 }
669
670 int get_process_comm(pid_t pid, char **name) {
671         const char *p;
672         int r;
673
674         assert(name);
675         assert(pid >= 0);
676
677         p = procfs_file_alloca(pid, "comm");
678
679         r = read_one_line_file(p, name);
680         if (r == -ENOENT)
681                 return -ESRCH;
682
683         return r;
684 }
685
686 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
687         _cleanup_fclose_ FILE *f = NULL;
688         char *r = NULL, *k;
689         const char *p;
690         int c;
691
692         assert(line);
693         assert(pid >= 0);
694
695         p = procfs_file_alloca(pid, "cmdline");
696
697         f = fopen(p, "re");
698         if (!f)
699                 return -errno;
700
701         if (max_length == 0) {
702                 size_t len = 0, allocated = 0;
703
704                 while ((c = getc(f)) != EOF) {
705
706                         if (!GREEDY_REALLOC(r, allocated, len+2)) {
707                                 free(r);
708                                 return -ENOMEM;
709                         }
710
711                         r[len++] = isprint(c) ? c : ' ';
712                 }
713
714                 if (len > 0)
715                         r[len-1] = 0;
716
717         } else {
718                 bool space = false;
719                 size_t left;
720
721                 r = new(char, max_length);
722                 if (!r)
723                         return -ENOMEM;
724
725                 k = r;
726                 left = max_length;
727                 while ((c = getc(f)) != EOF) {
728
729                         if (isprint(c)) {
730                                 if (space) {
731                                         if (left <= 4)
732                                                 break;
733
734                                         *(k++) = ' ';
735                                         left--;
736                                         space = false;
737                                 }
738
739                                 if (left <= 4)
740                                         break;
741
742                                 *(k++) = (char) c;
743                                 left--;
744                         }  else
745                                 space = true;
746                 }
747
748                 if (left <= 4) {
749                         size_t n = MIN(left-1, 3U);
750                         memcpy(k, "...", n);
751                         k[n] = 0;
752                 } else
753                         *k = 0;
754         }
755
756         /* Kernel threads have no argv[] */
757         if (isempty(r)) {
758                 _cleanup_free_ char *t = NULL;
759                 int h;
760
761                 free(r);
762
763                 if (!comm_fallback)
764                         return -ENOENT;
765
766                 h = get_process_comm(pid, &t);
767                 if (h < 0)
768                         return h;
769
770                 r = strjoin("[", t, "]", NULL);
771                 if (!r)
772                         return -ENOMEM;
773         }
774
775         *line = r;
776         return 0;
777 }
778
779 int is_kernel_thread(pid_t pid) {
780         const char *p;
781         size_t count;
782         char c;
783         bool eof;
784         FILE *f;
785
786         if (pid == 0)
787                 return 0;
788
789         assert(pid > 0);
790
791         p = procfs_file_alloca(pid, "cmdline");
792         f = fopen(p, "re");
793         if (!f)
794                 return -errno;
795
796         count = fread(&c, 1, 1, f);
797         eof = feof(f);
798         fclose(f);
799
800         /* Kernel threads have an empty cmdline */
801
802         if (count <= 0)
803                 return eof ? 1 : -errno;
804
805         return 0;
806 }
807
808 int get_process_capeff(pid_t pid, char **capeff) {
809         const char *p;
810
811         assert(capeff);
812         assert(pid >= 0);
813
814         p = procfs_file_alloca(pid, "status");
815
816         return get_status_field(p, "\nCapEff:", capeff);
817 }
818
819 static int get_process_link_contents(const char *proc_file, char **name) {
820         int r;
821
822         assert(proc_file);
823         assert(name);
824
825         r = readlink_malloc(proc_file, name);
826         if (r < 0)
827                 return r == -ENOENT ? -ESRCH : r;
828
829         return 0;
830 }
831
832 int get_process_exe(pid_t pid, char **name) {
833         const char *p;
834         char *d;
835         int r;
836
837         assert(pid >= 0);
838
839         p = procfs_file_alloca(pid, "exe");
840         r = get_process_link_contents(p, name);
841         if (r < 0)
842                 return r;
843
844         d = endswith(*name, " (deleted)");
845         if (d)
846                 *d = '\0';
847
848         return 0;
849 }
850
851 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
852         _cleanup_fclose_ FILE *f = NULL;
853         char line[LINE_MAX];
854         const char *p;
855
856         assert(field);
857         assert(uid);
858
859         if (pid == 0)
860                 return getuid();
861
862         p = procfs_file_alloca(pid, "status");
863         f = fopen(p, "re");
864         if (!f)
865                 return -errno;
866
867         FOREACH_LINE(line, f, return -errno) {
868                 char *l;
869
870                 l = strstrip(line);
871
872                 if (startswith(l, field)) {
873                         l += strlen(field);
874                         l += strspn(l, WHITESPACE);
875
876                         l[strcspn(l, WHITESPACE)] = 0;
877
878                         return parse_uid(l, uid);
879                 }
880         }
881
882         return -EIO;
883 }
884
885 int get_process_uid(pid_t pid, uid_t *uid) {
886         return get_process_id(pid, "Uid:", uid);
887 }
888
889 int get_process_gid(pid_t pid, gid_t *gid) {
890         assert_cc(sizeof(uid_t) == sizeof(gid_t));
891         return get_process_id(pid, "Gid:", gid);
892 }
893
894 int get_process_cwd(pid_t pid, char **cwd) {
895         const char *p;
896
897         assert(pid >= 0);
898
899         p = procfs_file_alloca(pid, "cwd");
900
901         return get_process_link_contents(p, cwd);
902 }
903
904 int get_process_root(pid_t pid, char **root) {
905         const char *p;
906
907         assert(pid >= 0);
908
909         p = procfs_file_alloca(pid, "root");
910
911         return get_process_link_contents(p, root);
912 }
913
914 int get_process_environ(pid_t pid, char **env) {
915         _cleanup_fclose_ FILE *f = NULL;
916         _cleanup_free_ char *outcome = NULL;
917         int c;
918         const char *p;
919         size_t allocated = 0, sz = 0;
920
921         assert(pid >= 0);
922         assert(env);
923
924         p = procfs_file_alloca(pid, "environ");
925
926         f = fopen(p, "re");
927         if (!f)
928                 return -errno;
929
930         while ((c = fgetc(f)) != EOF) {
931                 if (!GREEDY_REALLOC(outcome, allocated, sz + 5))
932                         return -ENOMEM;
933
934                 if (c == '\0')
935                         outcome[sz++] = '\n';
936                 else
937                         sz += cescape_char(c, outcome + sz);
938         }
939
940         outcome[sz] = '\0';
941         *env = outcome;
942         outcome = NULL;
943
944         return 0;
945 }
946
947 char *strnappend(const char *s, const char *suffix, size_t b) {
948         size_t a;
949         char *r;
950
951         if (!s && !suffix)
952                 return strdup("");
953
954         if (!s)
955                 return strndup(suffix, b);
956
957         if (!suffix)
958                 return strdup(s);
959
960         assert(s);
961         assert(suffix);
962
963         a = strlen(s);
964         if (b > ((size_t) -1) - a)
965                 return NULL;
966
967         r = new(char, a+b+1);
968         if (!r)
969                 return NULL;
970
971         memcpy(r, s, a);
972         memcpy(r+a, suffix, b);
973         r[a+b] = 0;
974
975         return r;
976 }
977
978 char *strappend(const char *s, const char *suffix) {
979         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
980 }
981
982 int readlinkat_malloc(int fd, const char *p, char **ret) {
983         size_t l = 100;
984         int r;
985
986         assert(p);
987         assert(ret);
988
989         for (;;) {
990                 char *c;
991                 ssize_t n;
992
993                 c = new(char, l);
994                 if (!c)
995                         return -ENOMEM;
996
997                 n = readlinkat(fd, p, c, l-1);
998                 if (n < 0) {
999                         r = -errno;
1000                         free(c);
1001                         return r;
1002                 }
1003
1004                 if ((size_t) n < l-1) {
1005                         c[n] = 0;
1006                         *ret = c;
1007                         return 0;
1008                 }
1009
1010                 free(c);
1011                 l *= 2;
1012         }
1013 }
1014
1015 int readlink_malloc(const char *p, char **ret) {
1016         return readlinkat_malloc(AT_FDCWD, p, ret);
1017 }
1018
1019 int readlink_value(const char *p, char **ret) {
1020         _cleanup_free_ char *link = NULL;
1021         char *value;
1022         int r;
1023
1024         r = readlink_malloc(p, &link);
1025         if (r < 0)
1026                 return r;
1027
1028         value = basename(link);
1029         if (!value)
1030                 return -ENOENT;
1031
1032         value = strdup(value);
1033         if (!value)
1034                 return -ENOMEM;
1035
1036         *ret = value;
1037
1038         return 0;
1039 }
1040
1041 int readlink_and_make_absolute(const char *p, char **r) {
1042         _cleanup_free_ char *target = NULL;
1043         char *k;
1044         int j;
1045
1046         assert(p);
1047         assert(r);
1048
1049         j = readlink_malloc(p, &target);
1050         if (j < 0)
1051                 return j;
1052
1053         k = file_in_same_dir(p, target);
1054         if (!k)
1055                 return -ENOMEM;
1056
1057         *r = k;
1058         return 0;
1059 }
1060
1061 int readlink_and_canonicalize(const char *p, char **r) {
1062         char *t, *s;
1063         int j;
1064
1065         assert(p);
1066         assert(r);
1067
1068         j = readlink_and_make_absolute(p, &t);
1069         if (j < 0)
1070                 return j;
1071
1072         s = canonicalize_file_name(t);
1073         if (s) {
1074                 free(t);
1075                 *r = s;
1076         } else
1077                 *r = t;
1078
1079         path_kill_slashes(*r);
1080
1081         return 0;
1082 }
1083
1084 int reset_all_signal_handlers(void) {
1085         int sig, r = 0;
1086
1087         for (sig = 1; sig < _NSIG; sig++) {
1088                 struct sigaction sa = {
1089                         .sa_handler = SIG_DFL,
1090                         .sa_flags = SA_RESTART,
1091                 };
1092
1093                 /* These two cannot be caught... */
1094                 if (sig == SIGKILL || sig == SIGSTOP)
1095                         continue;
1096
1097                 /* On Linux the first two RT signals are reserved by
1098                  * glibc, and sigaction() will return EINVAL for them. */
1099                 if ((sigaction(sig, &sa, NULL) < 0))
1100                         if (errno != EINVAL && r == 0)
1101                                 r = -errno;
1102         }
1103
1104         return r;
1105 }
1106
1107 int reset_signal_mask(void) {
1108         sigset_t ss;
1109
1110         if (sigemptyset(&ss) < 0)
1111                 return -errno;
1112
1113         if (sigprocmask(SIG_SETMASK, &ss, NULL) < 0)
1114                 return -errno;
1115
1116         return 0;
1117 }
1118
1119 char *strstrip(char *s) {
1120         char *e;
1121
1122         /* Drops trailing whitespace. Modifies the string in
1123          * place. Returns pointer to first non-space character */
1124
1125         s += strspn(s, WHITESPACE);
1126
1127         for (e = strchr(s, 0); e > s; e --)
1128                 if (!strchr(WHITESPACE, e[-1]))
1129                         break;
1130
1131         *e = 0;
1132
1133         return s;
1134 }
1135
1136 char *delete_chars(char *s, const char *bad) {
1137         char *f, *t;
1138
1139         /* Drops all whitespace, regardless where in the string */
1140
1141         for (f = s, t = s; *f; f++) {
1142                 if (strchr(bad, *f))
1143                         continue;
1144
1145                 *(t++) = *f;
1146         }
1147
1148         *t = 0;
1149
1150         return s;
1151 }
1152
1153 char *file_in_same_dir(const char *path, const char *filename) {
1154         char *e, *r;
1155         size_t k;
1156
1157         assert(path);
1158         assert(filename);
1159
1160         /* This removes the last component of path and appends
1161          * filename, unless the latter is absolute anyway or the
1162          * former isn't */
1163
1164         if (path_is_absolute(filename))
1165                 return strdup(filename);
1166
1167         if (!(e = strrchr(path, '/')))
1168                 return strdup(filename);
1169
1170         k = strlen(filename);
1171         if (!(r = new(char, e-path+1+k+1)))
1172                 return NULL;
1173
1174         memcpy(r, path, e-path+1);
1175         memcpy(r+(e-path)+1, filename, k+1);
1176
1177         return r;
1178 }
1179
1180 int rmdir_parents(const char *path, const char *stop) {
1181         size_t l;
1182         int r = 0;
1183
1184         assert(path);
1185         assert(stop);
1186
1187         l = strlen(path);
1188
1189         /* Skip trailing slashes */
1190         while (l > 0 && path[l-1] == '/')
1191                 l--;
1192
1193         while (l > 0) {
1194                 char *t;
1195
1196                 /* Skip last component */
1197                 while (l > 0 && path[l-1] != '/')
1198                         l--;
1199
1200                 /* Skip trailing slashes */
1201                 while (l > 0 && path[l-1] == '/')
1202                         l--;
1203
1204                 if (l <= 0)
1205                         break;
1206
1207                 if (!(t = strndup(path, l)))
1208                         return -ENOMEM;
1209
1210                 if (path_startswith(stop, t)) {
1211                         free(t);
1212                         return 0;
1213                 }
1214
1215                 r = rmdir(t);
1216                 free(t);
1217
1218                 if (r < 0)
1219                         if (errno != ENOENT)
1220                                 return -errno;
1221         }
1222
1223         return 0;
1224 }
1225
1226 char hexchar(int x) {
1227         static const char table[16] = "0123456789abcdef";
1228
1229         return table[x & 15];
1230 }
1231
1232 int unhexchar(char c) {
1233
1234         if (c >= '0' && c <= '9')
1235                 return c - '0';
1236
1237         if (c >= 'a' && c <= 'f')
1238                 return c - 'a' + 10;
1239
1240         if (c >= 'A' && c <= 'F')
1241                 return c - 'A' + 10;
1242
1243         return -EINVAL;
1244 }
1245
1246 char *hexmem(const void *p, size_t l) {
1247         char *r, *z;
1248         const uint8_t *x;
1249
1250         z = r = malloc(l * 2 + 1);
1251         if (!r)
1252                 return NULL;
1253
1254         for (x = p; x < (const uint8_t*) p + l; x++) {
1255                 *(z++) = hexchar(*x >> 4);
1256                 *(z++) = hexchar(*x & 15);
1257         }
1258
1259         *z = 0;
1260         return r;
1261 }
1262
1263 void *unhexmem(const char *p, size_t l) {
1264         uint8_t *r, *z;
1265         const char *x;
1266
1267         assert(p);
1268
1269         z = r = malloc((l + 1) / 2 + 1);
1270         if (!r)
1271                 return NULL;
1272
1273         for (x = p; x < p + l; x += 2) {
1274                 int a, b;
1275
1276                 a = unhexchar(x[0]);
1277                 if (x+1 < p + l)
1278                         b = unhexchar(x[1]);
1279                 else
1280                         b = 0;
1281
1282                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1283         }
1284
1285         *z = 0;
1286         return r;
1287 }
1288
1289 char octchar(int x) {
1290         return '0' + (x & 7);
1291 }
1292
1293 int unoctchar(char c) {
1294
1295         if (c >= '0' && c <= '7')
1296                 return c - '0';
1297
1298         return -EINVAL;
1299 }
1300
1301 char decchar(int x) {
1302         return '0' + (x % 10);
1303 }
1304
1305 int undecchar(char c) {
1306
1307         if (c >= '0' && c <= '9')
1308                 return c - '0';
1309
1310         return -EINVAL;
1311 }
1312
1313 char *cescape(const char *s) {
1314         char *r, *t;
1315         const char *f;
1316
1317         assert(s);
1318
1319         /* Does C style string escaping. */
1320
1321         r = new(char, strlen(s)*4 + 1);
1322         if (!r)
1323                 return NULL;
1324
1325         for (f = s, t = r; *f; f++)
1326                 t += cescape_char(*f, t);
1327
1328         *t = 0;
1329
1330         return r;
1331 }
1332
1333 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1334         char *r, *t;
1335         const char *f;
1336         size_t pl;
1337
1338         assert(s);
1339
1340         /* Undoes C style string escaping, and optionally prefixes it. */
1341
1342         pl = prefix ? strlen(prefix) : 0;
1343
1344         r = new(char, pl+length+1);
1345         if (!r)
1346                 return NULL;
1347
1348         if (prefix)
1349                 memcpy(r, prefix, pl);
1350
1351         for (f = s, t = r + pl; f < s + length; f++) {
1352
1353                 if (*f != '\\') {
1354                         *(t++) = *f;
1355                         continue;
1356                 }
1357
1358                 f++;
1359
1360                 switch (*f) {
1361
1362                 case 'a':
1363                         *(t++) = '\a';
1364                         break;
1365                 case 'b':
1366                         *(t++) = '\b';
1367                         break;
1368                 case 'f':
1369                         *(t++) = '\f';
1370                         break;
1371                 case 'n':
1372                         *(t++) = '\n';
1373                         break;
1374                 case 'r':
1375                         *(t++) = '\r';
1376                         break;
1377                 case 't':
1378                         *(t++) = '\t';
1379                         break;
1380                 case 'v':
1381                         *(t++) = '\v';
1382                         break;
1383                 case '\\':
1384                         *(t++) = '\\';
1385                         break;
1386                 case '"':
1387                         *(t++) = '"';
1388                         break;
1389                 case '\'':
1390                         *(t++) = '\'';
1391                         break;
1392
1393                 case 's':
1394                         /* This is an extension of the XDG syntax files */
1395                         *(t++) = ' ';
1396                         break;
1397
1398                 case 'x': {
1399                         /* hexadecimal encoding */
1400                         int a, b;
1401
1402                         a = unhexchar(f[1]);
1403                         b = unhexchar(f[2]);
1404
1405                         if (a < 0 || b < 0 || (a == 0 && b == 0)) {
1406                                 /* Invalid escape code, let's take it literal then */
1407                                 *(t++) = '\\';
1408                                 *(t++) = 'x';
1409                         } else {
1410                                 *(t++) = (char) ((a << 4) | b);
1411                                 f += 2;
1412                         }
1413
1414                         break;
1415                 }
1416
1417                 case '0':
1418                 case '1':
1419                 case '2':
1420                 case '3':
1421                 case '4':
1422                 case '5':
1423                 case '6':
1424                 case '7': {
1425                         /* octal encoding */
1426                         int a, b, c;
1427
1428                         a = unoctchar(f[0]);
1429                         b = unoctchar(f[1]);
1430                         c = unoctchar(f[2]);
1431
1432                         if (a < 0 || b < 0 || c < 0 || (a == 0 && b == 0 && c == 0)) {
1433                                 /* Invalid escape code, let's take it literal then */
1434                                 *(t++) = '\\';
1435                                 *(t++) = f[0];
1436                         } else {
1437                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1438                                 f += 2;
1439                         }
1440
1441                         break;
1442                 }
1443
1444                 case 0:
1445                         /* premature end of string. */
1446                         *(t++) = '\\';
1447                         goto finish;
1448
1449                 default:
1450                         /* Invalid escape code, let's take it literal then */
1451                         *(t++) = '\\';
1452                         *(t++) = *f;
1453                         break;
1454                 }
1455         }
1456
1457 finish:
1458         *t = 0;
1459         return r;
1460 }
1461
1462 char *cunescape_length(const char *s, size_t length) {
1463         return cunescape_length_with_prefix(s, length, NULL);
1464 }
1465
1466 char *cunescape(const char *s) {
1467         assert(s);
1468
1469         return cunescape_length(s, strlen(s));
1470 }
1471
1472 char *xescape(const char *s, const char *bad) {
1473         char *r, *t;
1474         const char *f;
1475
1476         /* Escapes all chars in bad, in addition to \ and all special
1477          * chars, in \xFF style escaping. May be reversed with
1478          * cunescape. */
1479
1480         r = new(char, strlen(s) * 4 + 1);
1481         if (!r)
1482                 return NULL;
1483
1484         for (f = s, t = r; *f; f++) {
1485
1486                 if ((*f < ' ') || (*f >= 127) ||
1487                     (*f == '\\') || strchr(bad, *f)) {
1488                         *(t++) = '\\';
1489                         *(t++) = 'x';
1490                         *(t++) = hexchar(*f >> 4);
1491                         *(t++) = hexchar(*f);
1492                 } else
1493                         *(t++) = *f;
1494         }
1495
1496         *t = 0;
1497
1498         return r;
1499 }
1500
1501 char *ascii_strlower(char *t) {
1502         char *p;
1503
1504         assert(t);
1505
1506         for (p = t; *p; p++)
1507                 if (*p >= 'A' && *p <= 'Z')
1508                         *p = *p - 'A' + 'a';
1509
1510         return t;
1511 }
1512
1513 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1514         assert(filename);
1515
1516         return
1517                 filename[0] == '.' ||
1518                 streq(filename, "lost+found") ||
1519                 streq(filename, "aquota.user") ||
1520                 streq(filename, "aquota.group") ||
1521                 endswith(filename, ".rpmnew") ||
1522                 endswith(filename, ".rpmsave") ||
1523                 endswith(filename, ".rpmorig") ||
1524                 endswith(filename, ".dpkg-old") ||
1525                 endswith(filename, ".dpkg-new") ||
1526                 endswith(filename, ".dpkg-tmp") ||
1527                 endswith(filename, ".swp");
1528 }
1529
1530 bool ignore_file(const char *filename) {
1531         assert(filename);
1532
1533         if (endswith(filename, "~"))
1534                 return true;
1535
1536         return ignore_file_allow_backup(filename);
1537 }
1538
1539 int fd_nonblock(int fd, bool nonblock) {
1540         int flags, nflags;
1541
1542         assert(fd >= 0);
1543
1544         flags = fcntl(fd, F_GETFL, 0);
1545         if (flags < 0)
1546                 return -errno;
1547
1548         if (nonblock)
1549                 nflags = flags | O_NONBLOCK;
1550         else
1551                 nflags = flags & ~O_NONBLOCK;
1552
1553         if (nflags == flags)
1554                 return 0;
1555
1556         if (fcntl(fd, F_SETFL, nflags) < 0)
1557                 return -errno;
1558
1559         return 0;
1560 }
1561
1562 int fd_cloexec(int fd, bool cloexec) {
1563         int flags, nflags;
1564
1565         assert(fd >= 0);
1566
1567         flags = fcntl(fd, F_GETFD, 0);
1568         if (flags < 0)
1569                 return -errno;
1570
1571         if (cloexec)
1572                 nflags = flags | FD_CLOEXEC;
1573         else
1574                 nflags = flags & ~FD_CLOEXEC;
1575
1576         if (nflags == flags)
1577                 return 0;
1578
1579         if (fcntl(fd, F_SETFD, nflags) < 0)
1580                 return -errno;
1581
1582         return 0;
1583 }
1584
1585 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1586         unsigned i;
1587
1588         assert(n_fdset == 0 || fdset);
1589
1590         for (i = 0; i < n_fdset; i++)
1591                 if (fdset[i] == fd)
1592                         return true;
1593
1594         return false;
1595 }
1596
1597 int close_all_fds(const int except[], unsigned n_except) {
1598         _cleanup_closedir_ DIR *d = NULL;
1599         struct dirent *de;
1600         int r = 0;
1601
1602         assert(n_except == 0 || except);
1603
1604         d = opendir("/proc/self/fd");
1605         if (!d) {
1606                 int fd;
1607                 struct rlimit rl;
1608
1609                 /* When /proc isn't available (for example in chroots)
1610                  * the fallback is brute forcing through the fd
1611                  * table */
1612
1613                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1614                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1615
1616                         if (fd_in_set(fd, except, n_except))
1617                                 continue;
1618
1619                         if (close_nointr(fd) < 0)
1620                                 if (errno != EBADF && r == 0)
1621                                         r = -errno;
1622                 }
1623
1624                 return r;
1625         }
1626
1627         while ((de = readdir(d))) {
1628                 int fd = -1;
1629
1630                 if (ignore_file(de->d_name))
1631                         continue;
1632
1633                 if (safe_atoi(de->d_name, &fd) < 0)
1634                         /* Let's better ignore this, just in case */
1635                         continue;
1636
1637                 if (fd < 3)
1638                         continue;
1639
1640                 if (fd == dirfd(d))
1641                         continue;
1642
1643                 if (fd_in_set(fd, except, n_except))
1644                         continue;
1645
1646                 if (close_nointr(fd) < 0) {
1647                         /* Valgrind has its own FD and doesn't want to have it closed */
1648                         if (errno != EBADF && r == 0)
1649                                 r = -errno;
1650                 }
1651         }
1652
1653         return r;
1654 }
1655
1656 bool chars_intersect(const char *a, const char *b) {
1657         const char *p;
1658
1659         /* Returns true if any of the chars in a are in b. */
1660         for (p = a; *p; p++)
1661                 if (strchr(b, *p))
1662                         return true;
1663
1664         return false;
1665 }
1666
1667 bool fstype_is_network(const char *fstype) {
1668         static const char table[] =
1669                 "cifs\0"
1670                 "smbfs\0"
1671                 "sshfs\0"
1672                 "ncpfs\0"
1673                 "ncp\0"
1674                 "nfs\0"
1675                 "nfs4\0"
1676                 "gfs\0"
1677                 "gfs2\0"
1678                 "glusterfs\0";
1679
1680         const char *x;
1681
1682         x = startswith(fstype, "fuse.");
1683         if (x)
1684                 fstype = x;
1685
1686         return nulstr_contains(table, fstype);
1687 }
1688
1689 int chvt(int vt) {
1690         _cleanup_close_ int fd;
1691
1692         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1693         if (fd < 0)
1694                 return -errno;
1695
1696         if (vt < 0) {
1697                 int tiocl[2] = {
1698                         TIOCL_GETKMSGREDIRECT,
1699                         0
1700                 };
1701
1702                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1703                         return -errno;
1704
1705                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1706         }
1707
1708         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1709                 return -errno;
1710
1711         return 0;
1712 }
1713
1714 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1715         struct termios old_termios, new_termios;
1716         char c, line[LINE_MAX];
1717
1718         assert(f);
1719         assert(ret);
1720
1721         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1722                 new_termios = old_termios;
1723
1724                 new_termios.c_lflag &= ~ICANON;
1725                 new_termios.c_cc[VMIN] = 1;
1726                 new_termios.c_cc[VTIME] = 0;
1727
1728                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1729                         size_t k;
1730
1731                         if (t != USEC_INFINITY) {
1732                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1733                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1734                                         return -ETIMEDOUT;
1735                                 }
1736                         }
1737
1738                         k = fread(&c, 1, 1, f);
1739
1740                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1741
1742                         if (k <= 0)
1743                                 return -EIO;
1744
1745                         if (need_nl)
1746                                 *need_nl = c != '\n';
1747
1748                         *ret = c;
1749                         return 0;
1750                 }
1751         }
1752
1753         if (t != USEC_INFINITY) {
1754                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1755                         return -ETIMEDOUT;
1756         }
1757
1758         errno = 0;
1759         if (!fgets(line, sizeof(line), f))
1760                 return errno ? -errno : -EIO;
1761
1762         truncate_nl(line);
1763
1764         if (strlen(line) != 1)
1765                 return -EBADMSG;
1766
1767         if (need_nl)
1768                 *need_nl = false;
1769
1770         *ret = line[0];
1771         return 0;
1772 }
1773
1774 int ask_char(char *ret, const char *replies, const char *text, ...) {
1775         int r;
1776
1777         assert(ret);
1778         assert(replies);
1779         assert(text);
1780
1781         for (;;) {
1782                 va_list ap;
1783                 char c;
1784                 bool need_nl = true;
1785
1786                 if (on_tty())
1787                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1788
1789                 va_start(ap, text);
1790                 vprintf(text, ap);
1791                 va_end(ap);
1792
1793                 if (on_tty())
1794                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1795
1796                 fflush(stdout);
1797
1798                 r = read_one_char(stdin, &c, USEC_INFINITY, &need_nl);
1799                 if (r < 0) {
1800
1801                         if (r == -EBADMSG) {
1802                                 puts("Bad input, please try again.");
1803                                 continue;
1804                         }
1805
1806                         putchar('\n');
1807                         return r;
1808                 }
1809
1810                 if (need_nl)
1811                         putchar('\n');
1812
1813                 if (strchr(replies, c)) {
1814                         *ret = c;
1815                         return 0;
1816                 }
1817
1818                 puts("Read unexpected character, please try again.");
1819         }
1820 }
1821
1822 int ask_string(char **ret, const char *text, ...) {
1823         assert(ret);
1824         assert(text);
1825
1826         for (;;) {
1827                 char line[LINE_MAX];
1828                 va_list ap;
1829
1830                 if (on_tty())
1831                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1832
1833                 va_start(ap, text);
1834                 vprintf(text, ap);
1835                 va_end(ap);
1836
1837                 if (on_tty())
1838                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1839
1840                 fflush(stdout);
1841
1842                 errno = 0;
1843                 if (!fgets(line, sizeof(line), stdin))
1844                         return errno ? -errno : -EIO;
1845
1846                 if (!endswith(line, "\n"))
1847                         putchar('\n');
1848                 else {
1849                         char *s;
1850
1851                         if (isempty(line))
1852                                 continue;
1853
1854                         truncate_nl(line);
1855                         s = strdup(line);
1856                         if (!s)
1857                                 return -ENOMEM;
1858
1859                         *ret = s;
1860                         return 0;
1861                 }
1862         }
1863 }
1864
1865 int reset_terminal_fd(int fd, bool switch_to_text) {
1866         struct termios termios;
1867         int r = 0;
1868
1869         /* Set terminal to some sane defaults */
1870
1871         assert(fd >= 0);
1872
1873         /* We leave locked terminal attributes untouched, so that
1874          * Plymouth may set whatever it wants to set, and we don't
1875          * interfere with that. */
1876
1877         /* Disable exclusive mode, just in case */
1878         ioctl(fd, TIOCNXCL);
1879
1880         /* Switch to text mode */
1881         if (switch_to_text)
1882                 ioctl(fd, KDSETMODE, KD_TEXT);
1883
1884         /* Enable console unicode mode */
1885         ioctl(fd, KDSKBMODE, K_UNICODE);
1886
1887         if (tcgetattr(fd, &termios) < 0) {
1888                 r = -errno;
1889                 goto finish;
1890         }
1891
1892         /* We only reset the stuff that matters to the software. How
1893          * hardware is set up we don't touch assuming that somebody
1894          * else will do that for us */
1895
1896         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1897         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1898         termios.c_oflag |= ONLCR;
1899         termios.c_cflag |= CREAD;
1900         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1901
1902         termios.c_cc[VINTR]    =   03;  /* ^C */
1903         termios.c_cc[VQUIT]    =  034;  /* ^\ */
1904         termios.c_cc[VERASE]   = 0177;
1905         termios.c_cc[VKILL]    =  025;  /* ^X */
1906         termios.c_cc[VEOF]     =   04;  /* ^D */
1907         termios.c_cc[VSTART]   =  021;  /* ^Q */
1908         termios.c_cc[VSTOP]    =  023;  /* ^S */
1909         termios.c_cc[VSUSP]    =  032;  /* ^Z */
1910         termios.c_cc[VLNEXT]   =  026;  /* ^V */
1911         termios.c_cc[VWERASE]  =  027;  /* ^W */
1912         termios.c_cc[VREPRINT] =  022;  /* ^R */
1913         termios.c_cc[VEOL]     =    0;
1914         termios.c_cc[VEOL2]    =    0;
1915
1916         termios.c_cc[VTIME]  = 0;
1917         termios.c_cc[VMIN]   = 1;
1918
1919         if (tcsetattr(fd, TCSANOW, &termios) < 0)
1920                 r = -errno;
1921
1922 finish:
1923         /* Just in case, flush all crap out */
1924         tcflush(fd, TCIOFLUSH);
1925
1926         return r;
1927 }
1928
1929 int reset_terminal(const char *name) {
1930         _cleanup_close_ int fd = -1;
1931
1932         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1933         if (fd < 0)
1934                 return fd;
1935
1936         return reset_terminal_fd(fd, true);
1937 }
1938
1939 int open_terminal(const char *name, int mode) {
1940         int fd, r;
1941         unsigned c = 0;
1942
1943         /*
1944          * If a TTY is in the process of being closed opening it might
1945          * cause EIO. This is horribly awful, but unlikely to be
1946          * changed in the kernel. Hence we work around this problem by
1947          * retrying a couple of times.
1948          *
1949          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1950          */
1951
1952         assert(!(mode & O_CREAT));
1953
1954         for (;;) {
1955                 fd = open(name, mode, 0);
1956                 if (fd >= 0)
1957                         break;
1958
1959                 if (errno != EIO)
1960                         return -errno;
1961
1962                 /* Max 1s in total */
1963                 if (c >= 20)
1964                         return -errno;
1965
1966                 usleep(50 * USEC_PER_MSEC);
1967                 c++;
1968         }
1969
1970         r = isatty(fd);
1971         if (r < 0) {
1972                 safe_close(fd);
1973                 return -errno;
1974         }
1975
1976         if (!r) {
1977                 safe_close(fd);
1978                 return -ENOTTY;
1979         }
1980
1981         return fd;
1982 }
1983
1984 int flush_fd(int fd) {
1985         struct pollfd pollfd = {
1986                 .fd = fd,
1987                 .events = POLLIN,
1988         };
1989
1990         for (;;) {
1991                 char buf[LINE_MAX];
1992                 ssize_t l;
1993                 int r;
1994
1995                 r = poll(&pollfd, 1, 0);
1996                 if (r < 0) {
1997                         if (errno == EINTR)
1998                                 continue;
1999
2000                         return -errno;
2001
2002                 } else if (r == 0)
2003                         return 0;
2004
2005                 l = read(fd, buf, sizeof(buf));
2006                 if (l < 0) {
2007
2008                         if (errno == EINTR)
2009                                 continue;
2010
2011                         if (errno == EAGAIN)
2012                                 return 0;
2013
2014                         return -errno;
2015                 } else if (l == 0)
2016                         return 0;
2017         }
2018 }
2019
2020 int acquire_terminal(
2021                 const char *name,
2022                 bool fail,
2023                 bool force,
2024                 bool ignore_tiocstty_eperm,
2025                 usec_t timeout) {
2026
2027         int fd = -1, notify = -1, r = 0, wd = -1;
2028         usec_t ts = 0;
2029
2030         assert(name);
2031
2032         /* We use inotify to be notified when the tty is closed. We
2033          * create the watch before checking if we can actually acquire
2034          * it, so that we don't lose any event.
2035          *
2036          * Note: strictly speaking this actually watches for the
2037          * device being closed, it does *not* really watch whether a
2038          * tty loses its controlling process. However, unless some
2039          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2040          * its tty otherwise this will not become a problem. As long
2041          * as the administrator makes sure not configure any service
2042          * on the same tty as an untrusted user this should not be a
2043          * problem. (Which he probably should not do anyway.) */
2044
2045         if (timeout != USEC_INFINITY)
2046                 ts = now(CLOCK_MONOTONIC);
2047
2048         if (!fail && !force) {
2049                 notify = inotify_init1(IN_CLOEXEC | (timeout != USEC_INFINITY ? IN_NONBLOCK : 0));
2050                 if (notify < 0) {
2051                         r = -errno;
2052                         goto fail;
2053                 }
2054
2055                 wd = inotify_add_watch(notify, name, IN_CLOSE);
2056                 if (wd < 0) {
2057                         r = -errno;
2058                         goto fail;
2059                 }
2060         }
2061
2062         for (;;) {
2063                 struct sigaction sa_old, sa_new = {
2064                         .sa_handler = SIG_IGN,
2065                         .sa_flags = SA_RESTART,
2066                 };
2067
2068                 if (notify >= 0) {
2069                         r = flush_fd(notify);
2070                         if (r < 0)
2071                                 goto fail;
2072                 }
2073
2074                 /* We pass here O_NOCTTY only so that we can check the return
2075                  * value TIOCSCTTY and have a reliable way to figure out if we
2076                  * successfully became the controlling process of the tty */
2077                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2078                 if (fd < 0)
2079                         return fd;
2080
2081                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2082                  * if we already own the tty. */
2083                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2084
2085                 /* First, try to get the tty */
2086                 if (ioctl(fd, TIOCSCTTY, force) < 0)
2087                         r = -errno;
2088
2089                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2090
2091                 /* Sometimes it makes sense to ignore TIOCSCTTY
2092                  * returning EPERM, i.e. when very likely we already
2093                  * are have this controlling terminal. */
2094                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
2095                         r = 0;
2096
2097                 if (r < 0 && (force || fail || r != -EPERM)) {
2098                         goto fail;
2099                 }
2100
2101                 if (r >= 0)
2102                         break;
2103
2104                 assert(!fail);
2105                 assert(!force);
2106                 assert(notify >= 0);
2107
2108                 for (;;) {
2109                         uint8_t buffer[INOTIFY_EVENT_MAX] _alignas_(struct inotify_event);
2110                         struct inotify_event *e;
2111                         ssize_t l;
2112
2113                         if (timeout != USEC_INFINITY) {
2114                                 usec_t n;
2115
2116                                 n = now(CLOCK_MONOTONIC);
2117                                 if (ts + timeout < n) {
2118                                         r = -ETIMEDOUT;
2119                                         goto fail;
2120                                 }
2121
2122                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2123                                 if (r < 0)
2124                                         goto fail;
2125
2126                                 if (r == 0) {
2127                                         r = -ETIMEDOUT;
2128                                         goto fail;
2129                                 }
2130                         }
2131
2132                         l = read(notify, buffer, sizeof(buffer));
2133                         if (l < 0) {
2134                                 if (errno == EINTR || errno == EAGAIN)
2135                                         continue;
2136
2137                                 r = -errno;
2138                                 goto fail;
2139                         }
2140
2141                         FOREACH_INOTIFY_EVENT(e, buffer, l) {
2142                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2143                                         r = -EIO;
2144                                         goto fail;
2145                                 }
2146                         }
2147
2148                         break;
2149                 }
2150
2151                 /* We close the tty fd here since if the old session
2152                  * ended our handle will be dead. It's important that
2153                  * we do this after sleeping, so that we don't enter
2154                  * an endless loop. */
2155                 fd = safe_close(fd);
2156         }
2157
2158         safe_close(notify);
2159
2160         r = reset_terminal_fd(fd, true);
2161         if (r < 0)
2162                 log_warning_errno(r, "Failed to reset terminal: %m");
2163
2164         return fd;
2165
2166 fail:
2167         safe_close(fd);
2168         safe_close(notify);
2169
2170         return r;
2171 }
2172
2173 int release_terminal(void) {
2174         static const struct sigaction sa_new = {
2175                 .sa_handler = SIG_IGN,
2176                 .sa_flags = SA_RESTART,
2177         };
2178
2179         _cleanup_close_ int fd = -1;
2180         struct sigaction sa_old;
2181         int r = 0;
2182
2183         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2184         if (fd < 0)
2185                 return -errno;
2186
2187         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2188          * by our own TIOCNOTTY */
2189         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2190
2191         if (ioctl(fd, TIOCNOTTY) < 0)
2192                 r = -errno;
2193
2194         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2195
2196         return r;
2197 }
2198
2199 int sigaction_many(const struct sigaction *sa, ...) {
2200         va_list ap;
2201         int r = 0, sig;
2202
2203         va_start(ap, sa);
2204         while ((sig = va_arg(ap, int)) > 0)
2205                 if (sigaction(sig, sa, NULL) < 0)
2206                         r = -errno;
2207         va_end(ap);
2208
2209         return r;
2210 }
2211
2212 int ignore_signals(int sig, ...) {
2213         struct sigaction sa = {
2214                 .sa_handler = SIG_IGN,
2215                 .sa_flags = SA_RESTART,
2216         };
2217         va_list ap;
2218         int r = 0;
2219
2220         if (sigaction(sig, &sa, NULL) < 0)
2221                 r = -errno;
2222
2223         va_start(ap, sig);
2224         while ((sig = va_arg(ap, int)) > 0)
2225                 if (sigaction(sig, &sa, NULL) < 0)
2226                         r = -errno;
2227         va_end(ap);
2228
2229         return r;
2230 }
2231
2232 int default_signals(int sig, ...) {
2233         struct sigaction sa = {
2234                 .sa_handler = SIG_DFL,
2235                 .sa_flags = SA_RESTART,
2236         };
2237         va_list ap;
2238         int r = 0;
2239
2240         if (sigaction(sig, &sa, NULL) < 0)
2241                 r = -errno;
2242
2243         va_start(ap, sig);
2244         while ((sig = va_arg(ap, int)) > 0)
2245                 if (sigaction(sig, &sa, NULL) < 0)
2246                         r = -errno;
2247         va_end(ap);
2248
2249         return r;
2250 }
2251
2252 void safe_close_pair(int p[]) {
2253         assert(p);
2254
2255         if (p[0] == p[1]) {
2256                 /* Special case pairs which use the same fd in both
2257                  * directions... */
2258                 p[0] = p[1] = safe_close(p[0]);
2259                 return;
2260         }
2261
2262         p[0] = safe_close(p[0]);
2263         p[1] = safe_close(p[1]);
2264 }
2265
2266 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2267         uint8_t *p = buf;
2268         ssize_t n = 0;
2269
2270         assert(fd >= 0);
2271         assert(buf);
2272
2273         while (nbytes > 0) {
2274                 ssize_t k;
2275
2276                 k = read(fd, p, nbytes);
2277                 if (k < 0) {
2278                         if (errno == EINTR)
2279                                 continue;
2280
2281                         if (errno == EAGAIN && do_poll) {
2282
2283                                 /* We knowingly ignore any return value here,
2284                                  * and expect that any error/EOF is reported
2285                                  * via read() */
2286
2287                                 fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
2288                                 continue;
2289                         }
2290
2291                         return n > 0 ? n : -errno;
2292                 }
2293
2294                 if (k == 0)
2295                         return n;
2296
2297                 p += k;
2298                 nbytes -= k;
2299                 n += k;
2300         }
2301
2302         return n;
2303 }
2304
2305 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2306         const uint8_t *p = buf;
2307
2308         assert(fd >= 0);
2309         assert(buf);
2310
2311         errno = 0;
2312
2313         while (nbytes > 0) {
2314                 ssize_t k;
2315
2316                 k = write(fd, p, nbytes);
2317                 if (k < 0) {
2318                         if (errno == EINTR)
2319                                 continue;
2320
2321                         if (errno == EAGAIN && do_poll) {
2322                                 /* We knowingly ignore any return value here,
2323                                  * and expect that any error/EOF is reported
2324                                  * via write() */
2325
2326                                 fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
2327                                 continue;
2328                         }
2329
2330                         return -errno;
2331                 }
2332
2333                 if (k == 0) /* Can't really happen */
2334                         return -EIO;
2335
2336                 p += k;
2337                 nbytes -= k;
2338         }
2339
2340         return 0;
2341 }
2342
2343 int parse_size(const char *t, off_t base, off_t *size) {
2344
2345         /* Soo, sometimes we want to parse IEC binary suffxies, and
2346          * sometimes SI decimal suffixes. This function can parse
2347          * both. Which one is the right way depends on the
2348          * context. Wikipedia suggests that SI is customary for
2349          * hardrware metrics and network speeds, while IEC is
2350          * customary for most data sizes used by software and volatile
2351          * (RAM) memory. Hence be careful which one you pick!
2352          *
2353          * In either case we use just K, M, G as suffix, and not Ki,
2354          * Mi, Gi or so (as IEC would suggest). That's because that's
2355          * frickin' ugly. But this means you really need to make sure
2356          * to document which base you are parsing when you use this
2357          * call. */
2358
2359         struct table {
2360                 const char *suffix;
2361                 unsigned long long factor;
2362         };
2363
2364         static const struct table iec[] = {
2365                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2366                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2367                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2368                 { "G", 1024ULL*1024ULL*1024ULL },
2369                 { "M", 1024ULL*1024ULL },
2370                 { "K", 1024ULL },
2371                 { "B", 1 },
2372                 { "", 1 },
2373         };
2374
2375         static const struct table si[] = {
2376                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2377                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2378                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2379                 { "G", 1000ULL*1000ULL*1000ULL },
2380                 { "M", 1000ULL*1000ULL },
2381                 { "K", 1000ULL },
2382                 { "B", 1 },
2383                 { "", 1 },
2384         };
2385
2386         const struct table *table;
2387         const char *p;
2388         unsigned long long r = 0;
2389         unsigned n_entries, start_pos = 0;
2390
2391         assert(t);
2392         assert(base == 1000 || base == 1024);
2393         assert(size);
2394
2395         if (base == 1000) {
2396                 table = si;
2397                 n_entries = ELEMENTSOF(si);
2398         } else {
2399                 table = iec;
2400                 n_entries = ELEMENTSOF(iec);
2401         }
2402
2403         p = t;
2404         do {
2405                 long long l;
2406                 unsigned long long l2;
2407                 double frac = 0;
2408                 char *e;
2409                 unsigned i;
2410
2411                 errno = 0;
2412                 l = strtoll(p, &e, 10);
2413
2414                 if (errno > 0)
2415                         return -errno;
2416
2417                 if (l < 0)
2418                         return -ERANGE;
2419
2420                 if (e == p)
2421                         return -EINVAL;
2422
2423                 if (*e == '.') {
2424                         e++;
2425                         if (*e >= '0' && *e <= '9') {
2426                                 char *e2;
2427
2428                                 /* strotoull itself would accept space/+/- */
2429                                 l2 = strtoull(e, &e2, 10);
2430
2431                                 if (errno == ERANGE)
2432                                         return -errno;
2433
2434                                 /* Ignore failure. E.g. 10.M is valid */
2435                                 frac = l2;
2436                                 for (; e < e2; e++)
2437                                         frac /= 10;
2438                         }
2439                 }
2440
2441                 e += strspn(e, WHITESPACE);
2442
2443                 for (i = start_pos; i < n_entries; i++)
2444                         if (startswith(e, table[i].suffix)) {
2445                                 unsigned long long tmp;
2446                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2447                                         return -ERANGE;
2448                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2449                                 if (tmp > ULLONG_MAX - r)
2450                                         return -ERANGE;
2451
2452                                 r += tmp;
2453                                 if ((unsigned long long) (off_t) r != r)
2454                                         return -ERANGE;
2455
2456                                 p = e + strlen(table[i].suffix);
2457
2458                                 start_pos = i + 1;
2459                                 break;
2460                         }
2461
2462                 if (i >= n_entries)
2463                         return -EINVAL;
2464
2465         } while (*p);
2466
2467         *size = r;
2468
2469         return 0;
2470 }
2471
2472 int make_stdio(int fd) {
2473         int r, s, t;
2474
2475         assert(fd >= 0);
2476
2477         r = dup2(fd, STDIN_FILENO);
2478         s = dup2(fd, STDOUT_FILENO);
2479         t = dup2(fd, STDERR_FILENO);
2480
2481         if (fd >= 3)
2482                 safe_close(fd);
2483
2484         if (r < 0 || s < 0 || t < 0)
2485                 return -errno;
2486
2487         /* Explicitly unset O_CLOEXEC, since if fd was < 3, then
2488          * dup2() was a NOP and the bit hence possibly set. */
2489         fd_cloexec(STDIN_FILENO, false);
2490         fd_cloexec(STDOUT_FILENO, false);
2491         fd_cloexec(STDERR_FILENO, false);
2492
2493         return 0;
2494 }
2495
2496 int make_null_stdio(void) {
2497         int null_fd;
2498
2499         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2500         if (null_fd < 0)
2501                 return -errno;
2502
2503         return make_stdio(null_fd);
2504 }
2505
2506 bool is_device_path(const char *path) {
2507
2508         /* Returns true on paths that refer to a device, either in
2509          * sysfs or in /dev */
2510
2511         return
2512                 path_startswith(path, "/dev/") ||
2513                 path_startswith(path, "/sys/");
2514 }
2515
2516 int dir_is_empty(const char *path) {
2517         _cleanup_closedir_ DIR *d;
2518
2519         d = opendir(path);
2520         if (!d)
2521                 return -errno;
2522
2523         for (;;) {
2524                 struct dirent *de;
2525
2526                 errno = 0;
2527                 de = readdir(d);
2528                 if (!de && errno != 0)
2529                         return -errno;
2530
2531                 if (!de)
2532                         return 1;
2533
2534                 if (!ignore_file(de->d_name))
2535                         return 0;
2536         }
2537 }
2538
2539 char* dirname_malloc(const char *path) {
2540         char *d, *dir, *dir2;
2541
2542         d = strdup(path);
2543         if (!d)
2544                 return NULL;
2545         dir = dirname(d);
2546         assert(dir);
2547
2548         if (dir != d) {
2549                 dir2 = strdup(dir);
2550                 free(d);
2551                 return dir2;
2552         }
2553
2554         return dir;
2555 }
2556
2557 int dev_urandom(void *p, size_t n) {
2558         static int have_syscall = -1;
2559         int r, fd;
2560         ssize_t k;
2561
2562         /* Gathers some randomness from the kernel. This call will
2563          * never block, and will always return some data from the
2564          * kernel, regardless if the random pool is fully initialized
2565          * or not. It thus makes no guarantee for the quality of the
2566          * returned entropy, but is good enough for or usual usecases
2567          * of seeding the hash functions for hashtable */
2568
2569         /* Use the getrandom() syscall unless we know we don't have
2570          * it, or when the requested size is too large for it. */
2571         if (have_syscall != 0 || (size_t) (int) n != n) {
2572                 r = getrandom(p, n, GRND_NONBLOCK);
2573                 if (r == (int) n) {
2574                         have_syscall = true;
2575                         return 0;
2576                 }
2577
2578                 if (r < 0) {
2579                         if (errno == ENOSYS)
2580                                 /* we lack the syscall, continue with
2581                                  * reading from /dev/urandom */
2582                                 have_syscall = false;
2583                         else if (errno == EAGAIN)
2584                                 /* not enough entropy for now. Let's
2585                                  * remember to use the syscall the
2586                                  * next time, again, but also read
2587                                  * from /dev/urandom for now, which
2588                                  * doesn't care about the current
2589                                  * amount of entropy.  */
2590                                 have_syscall = true;
2591                         else
2592                                 return -errno;
2593                 } else
2594                         /* too short read? */
2595                         return -EIO;
2596         }
2597
2598         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2599         if (fd < 0)
2600                 return errno == ENOENT ? -ENOSYS : -errno;
2601
2602         k = loop_read(fd, p, n, true);
2603         safe_close(fd);
2604
2605         if (k < 0)
2606                 return (int) k;
2607         if ((size_t) k != n)
2608                 return -EIO;
2609
2610         return 0;
2611 }
2612
2613 void initialize_srand(void) {
2614         static bool srand_called = false;
2615         unsigned x;
2616 #ifdef HAVE_SYS_AUXV_H
2617         void *auxv;
2618 #endif
2619
2620         if (srand_called)
2621                 return;
2622
2623         x = 0;
2624
2625 #ifdef HAVE_SYS_AUXV_H
2626         /* The kernel provides us with a bit of entropy in auxv, so
2627          * let's try to make use of that to seed the pseudo-random
2628          * generator. It's better than nothing... */
2629
2630         auxv = (void*) getauxval(AT_RANDOM);
2631         if (auxv)
2632                 x ^= *(unsigned*) auxv;
2633 #endif
2634
2635         x ^= (unsigned) now(CLOCK_REALTIME);
2636         x ^= (unsigned) gettid();
2637
2638         srand(x);
2639         srand_called = true;
2640 }
2641
2642 void random_bytes(void *p, size_t n) {
2643         uint8_t *q;
2644         int r;
2645
2646         r = dev_urandom(p, n);
2647         if (r >= 0)
2648                 return;
2649
2650         /* If some idiot made /dev/urandom unavailable to us, he'll
2651          * get a PRNG instead. */
2652
2653         initialize_srand();
2654
2655         for (q = p; q < (uint8_t*) p + n; q ++)
2656                 *q = rand();
2657 }
2658
2659 void rename_process(const char name[8]) {
2660         assert(name);
2661
2662         /* This is a like a poor man's setproctitle(). It changes the
2663          * comm field, argv[0], and also the glibc's internally used
2664          * name of the process. For the first one a limit of 16 chars
2665          * applies, to the second one usually one of 10 (i.e. length
2666          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2667          * "systemd"). If you pass a longer string it will be
2668          * truncated */
2669
2670         prctl(PR_SET_NAME, name);
2671
2672         if (program_invocation_name)
2673                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2674
2675         if (saved_argc > 0) {
2676                 int i;
2677
2678                 if (saved_argv[0])
2679                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2680
2681                 for (i = 1; i < saved_argc; i++) {
2682                         if (!saved_argv[i])
2683                                 break;
2684
2685                         memzero(saved_argv[i], strlen(saved_argv[i]));
2686                 }
2687         }
2688 }
2689
2690 void sigset_add_many(sigset_t *ss, ...) {
2691         va_list ap;
2692         int sig;
2693
2694         assert(ss);
2695
2696         va_start(ap, ss);
2697         while ((sig = va_arg(ap, int)) > 0)
2698                 assert_se(sigaddset(ss, sig) == 0);
2699         va_end(ap);
2700 }
2701
2702 int sigprocmask_many(int how, ...) {
2703         va_list ap;
2704         sigset_t ss;
2705         int sig;
2706
2707         assert_se(sigemptyset(&ss) == 0);
2708
2709         va_start(ap, how);
2710         while ((sig = va_arg(ap, int)) > 0)
2711                 assert_se(sigaddset(&ss, sig) == 0);
2712         va_end(ap);
2713
2714         if (sigprocmask(how, &ss, NULL) < 0)
2715                 return -errno;
2716
2717         return 0;
2718 }
2719
2720 char* gethostname_malloc(void) {
2721         struct utsname u;
2722
2723         assert_se(uname(&u) >= 0);
2724
2725         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2726                 return strdup(u.nodename);
2727
2728         return strdup(u.sysname);
2729 }
2730
2731 bool hostname_is_set(void) {
2732         struct utsname u;
2733
2734         assert_se(uname(&u) >= 0);
2735
2736         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2737 }
2738
2739 char *lookup_uid(uid_t uid) {
2740         long bufsize;
2741         char *name;
2742         _cleanup_free_ char *buf = NULL;
2743         struct passwd pwbuf, *pw = NULL;
2744
2745         /* Shortcut things to avoid NSS lookups */
2746         if (uid == 0)
2747                 return strdup("root");
2748
2749         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2750         if (bufsize <= 0)
2751                 bufsize = 4096;
2752
2753         buf = malloc(bufsize);
2754         if (!buf)
2755                 return NULL;
2756
2757         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2758                 return strdup(pw->pw_name);
2759
2760         if (asprintf(&name, UID_FMT, uid) < 0)
2761                 return NULL;
2762
2763         return name;
2764 }
2765
2766 char* getlogname_malloc(void) {
2767         uid_t uid;
2768         struct stat st;
2769
2770         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2771                 uid = st.st_uid;
2772         else
2773                 uid = getuid();
2774
2775         return lookup_uid(uid);
2776 }
2777
2778 char *getusername_malloc(void) {
2779         const char *e;
2780
2781         e = getenv("USER");
2782         if (e)
2783                 return strdup(e);
2784
2785         return lookup_uid(getuid());
2786 }
2787
2788 int getttyname_malloc(int fd, char **r) {
2789         char path[PATH_MAX], *c;
2790         int k;
2791
2792         assert(r);
2793
2794         k = ttyname_r(fd, path, sizeof(path));
2795         if (k > 0)
2796                 return -k;
2797
2798         char_array_0(path);
2799
2800         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2801         if (!c)
2802                 return -ENOMEM;
2803
2804         *r = c;
2805         return 0;
2806 }
2807
2808 int getttyname_harder(int fd, char **r) {
2809         int k;
2810         char *s;
2811
2812         k = getttyname_malloc(fd, &s);
2813         if (k < 0)
2814                 return k;
2815
2816         if (streq(s, "tty")) {
2817                 free(s);
2818                 return get_ctty(0, NULL, r);
2819         }
2820
2821         *r = s;
2822         return 0;
2823 }
2824
2825 int get_ctty_devnr(pid_t pid, dev_t *d) {
2826         int r;
2827         _cleanup_free_ char *line = NULL;
2828         const char *p;
2829         unsigned long ttynr;
2830
2831         assert(pid >= 0);
2832
2833         p = procfs_file_alloca(pid, "stat");
2834         r = read_one_line_file(p, &line);
2835         if (r < 0)
2836                 return r;
2837
2838         p = strrchr(line, ')');
2839         if (!p)
2840                 return -EIO;
2841
2842         p++;
2843
2844         if (sscanf(p, " "
2845                    "%*c "  /* state */
2846                    "%*d "  /* ppid */
2847                    "%*d "  /* pgrp */
2848                    "%*d "  /* session */
2849                    "%lu ", /* ttynr */
2850                    &ttynr) != 1)
2851                 return -EIO;
2852
2853         if (major(ttynr) == 0 && minor(ttynr) == 0)
2854                 return -ENOENT;
2855
2856         if (d)
2857                 *d = (dev_t) ttynr;
2858
2859         return 0;
2860 }
2861
2862 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2863         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2864         _cleanup_free_ char *s = NULL;
2865         const char *p;
2866         dev_t devnr;
2867         int k;
2868
2869         assert(r);
2870
2871         k = get_ctty_devnr(pid, &devnr);
2872         if (k < 0)
2873                 return k;
2874
2875         sprintf(fn, "/dev/char/%u:%u", major(devnr), minor(devnr));
2876
2877         k = readlink_malloc(fn, &s);
2878         if (k < 0) {
2879
2880                 if (k != -ENOENT)
2881                         return k;
2882
2883                 /* This is an ugly hack */
2884                 if (major(devnr) == 136) {
2885                         asprintf(&b, "pts/%u", minor(devnr));
2886                         goto finish;
2887                 }
2888
2889                 /* Probably something like the ptys which have no
2890                  * symlink in /dev/char. Let's return something
2891                  * vaguely useful. */
2892
2893                 b = strdup(fn + 5);
2894                 goto finish;
2895         }
2896
2897         if (startswith(s, "/dev/"))
2898                 p = s + 5;
2899         else if (startswith(s, "../"))
2900                 p = s + 3;
2901         else
2902                 p = s;
2903
2904         b = strdup(p);
2905
2906 finish:
2907         if (!b)
2908                 return -ENOMEM;
2909
2910         *r = b;
2911         if (_devnr)
2912                 *_devnr = devnr;
2913
2914         return 0;
2915 }
2916
2917 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2918         _cleanup_closedir_ DIR *d = NULL;
2919         int ret = 0;
2920
2921         assert(fd >= 0);
2922
2923         /* This returns the first error we run into, but nevertheless
2924          * tries to go on. This closes the passed fd. */
2925
2926         d = fdopendir(fd);
2927         if (!d) {
2928                 safe_close(fd);
2929
2930                 return errno == ENOENT ? 0 : -errno;
2931         }
2932
2933         for (;;) {
2934                 struct dirent *de;
2935                 bool is_dir, keep_around;
2936                 struct stat st;
2937                 int r;
2938
2939                 errno = 0;
2940                 de = readdir(d);
2941                 if (!de) {
2942                         if (errno != 0 && ret == 0)
2943                                 ret = -errno;
2944                         return ret;
2945                 }
2946
2947                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2948                         continue;
2949
2950                 if (de->d_type == DT_UNKNOWN ||
2951                     honour_sticky ||
2952                     (de->d_type == DT_DIR && root_dev)) {
2953                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2954                                 if (ret == 0 && errno != ENOENT)
2955                                         ret = -errno;
2956                                 continue;
2957                         }
2958
2959                         is_dir = S_ISDIR(st.st_mode);
2960                         keep_around =
2961                                 honour_sticky &&
2962                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2963                                 (st.st_mode & S_ISVTX);
2964                 } else {
2965                         is_dir = de->d_type == DT_DIR;
2966                         keep_around = false;
2967                 }
2968
2969                 if (is_dir) {
2970                         int subdir_fd;
2971
2972                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2973                         if (root_dev && st.st_dev != root_dev->st_dev)
2974                                 continue;
2975
2976                         subdir_fd = openat(fd, de->d_name,
2977                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2978                         if (subdir_fd < 0) {
2979                                 if (ret == 0 && errno != ENOENT)
2980                                         ret = -errno;
2981                                 continue;
2982                         }
2983
2984                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2985                         if (r < 0 && ret == 0)
2986                                 ret = r;
2987
2988                         if (!keep_around)
2989                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2990                                         if (ret == 0 && errno != ENOENT)
2991                                                 ret = -errno;
2992                                 }
2993
2994                 } else if (!only_dirs && !keep_around) {
2995
2996                         if (unlinkat(fd, de->d_name, 0) < 0) {
2997                                 if (ret == 0 && errno != ENOENT)
2998                                         ret = -errno;
2999                         }
3000                 }
3001         }
3002 }
3003
3004 _pure_ static int is_temporary_fs(struct statfs *s) {
3005         assert(s);
3006
3007         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
3008                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
3009 }
3010
3011 int is_fd_on_temporary_fs(int fd) {
3012         struct statfs s;
3013
3014         if (fstatfs(fd, &s) < 0)
3015                 return -errno;
3016
3017         return is_temporary_fs(&s);
3018 }
3019
3020 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3021         struct statfs s;
3022
3023         assert(fd >= 0);
3024
3025         if (fstatfs(fd, &s) < 0) {
3026                 safe_close(fd);
3027                 return -errno;
3028         }
3029
3030         /* We refuse to clean disk file systems with this call. This
3031          * is extra paranoia just to be sure we never ever remove
3032          * non-state data */
3033         if (!is_temporary_fs(&s)) {
3034                 log_error("Attempted to remove disk file system, and we can't allow that.");
3035                 safe_close(fd);
3036                 return -EPERM;
3037         }
3038
3039         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
3040 }
3041
3042 static int file_is_priv_sticky(const char *p) {
3043         struct stat st;
3044
3045         assert(p);
3046
3047         if (lstat(p, &st) < 0)
3048                 return -errno;
3049
3050         return
3051                 (st.st_uid == 0 || st.st_uid == getuid()) &&
3052                 (st.st_mode & S_ISVTX);
3053 }
3054
3055 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
3056         int fd, r;
3057         struct statfs s;
3058
3059         assert(path);
3060
3061         /* We refuse to clean the root file system with this
3062          * call. This is extra paranoia to never cause a really
3063          * seriously broken system. */
3064         if (path_equal(path, "/")) {
3065                 log_error("Attempted to remove entire root file system, and we can't allow that.");
3066                 return -EPERM;
3067         }
3068
3069         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3070         if (fd < 0) {
3071
3072                 if (errno != ENOTDIR && errno != ELOOP)
3073                         return -errno;
3074
3075                 if (!dangerous) {
3076                         if (statfs(path, &s) < 0)
3077                                 return -errno;
3078
3079                         if (!is_temporary_fs(&s)) {
3080                                 log_error("Attempted to remove disk file system, and we can't allow that.");
3081                                 return -EPERM;
3082                         }
3083                 }
3084
3085                 if (delete_root && !only_dirs)
3086                         if (unlink(path) < 0 && errno != ENOENT)
3087                                 return -errno;
3088
3089                 return 0;
3090         }
3091
3092         if (!dangerous) {
3093                 if (fstatfs(fd, &s) < 0) {
3094                         safe_close(fd);
3095                         return -errno;
3096                 }
3097
3098                 if (!is_temporary_fs(&s)) {
3099                         log_error("Attempted to remove disk file system, and we can't allow that.");
3100                         safe_close(fd);
3101                         return -EPERM;
3102                 }
3103         }
3104
3105         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
3106         if (delete_root) {
3107
3108                 if (honour_sticky && file_is_priv_sticky(path) > 0)
3109                         return r;
3110
3111                 if (rmdir(path) < 0 && errno != ENOENT) {
3112                         if (r == 0)
3113                                 r = -errno;
3114                 }
3115         }
3116
3117         return r;
3118 }
3119
3120 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3121         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
3122 }
3123
3124 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3125         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
3126 }
3127
3128 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3129         assert(path);
3130
3131         /* Under the assumption that we are running privileged we
3132          * first change the access mode and only then hand out
3133          * ownership to avoid a window where access is too open. */
3134
3135         if (mode != MODE_INVALID)
3136                 if (chmod(path, mode) < 0)
3137                         return -errno;
3138
3139         if (uid != UID_INVALID || gid != GID_INVALID)
3140                 if (chown(path, uid, gid) < 0)
3141                         return -errno;
3142
3143         return 0;
3144 }
3145
3146 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3147         assert(fd >= 0);
3148
3149         /* Under the assumption that we are running privileged we
3150          * first change the access mode and only then hand out
3151          * ownership to avoid a window where access is too open. */
3152
3153         if (mode != MODE_INVALID)
3154                 if (fchmod(fd, mode) < 0)
3155                         return -errno;
3156
3157         if (uid != UID_INVALID || gid != GID_INVALID)
3158                 if (fchown(fd, uid, gid) < 0)
3159                         return -errno;
3160
3161         return 0;
3162 }
3163
3164 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3165         cpu_set_t *r;
3166         unsigned n = 1024;
3167
3168         /* Allocates the cpuset in the right size */
3169
3170         for (;;) {
3171                 if (!(r = CPU_ALLOC(n)))
3172                         return NULL;
3173
3174                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3175                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3176
3177                         if (ncpus)
3178                                 *ncpus = n;
3179
3180                         return r;
3181                 }
3182
3183                 CPU_FREE(r);
3184
3185                 if (errno != EINVAL)
3186                         return NULL;
3187
3188                 n *= 2;
3189         }
3190 }
3191
3192 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
3193         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3194         _cleanup_free_ char *s = NULL;
3195         _cleanup_close_ int fd = -1;
3196         struct iovec iovec[6] = {};
3197         int n = 0;
3198         static bool prev_ephemeral;
3199
3200         assert(format);
3201
3202         /* This is independent of logging, as status messages are
3203          * optional and go exclusively to the console. */
3204
3205         if (vasprintf(&s, format, ap) < 0)
3206                 return log_oom();
3207
3208         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3209         if (fd < 0)
3210                 return fd;
3211
3212         if (ellipse) {
3213                 char *e;
3214                 size_t emax, sl;
3215                 int c;
3216
3217                 c = fd_columns(fd);
3218                 if (c <= 0)
3219                         c = 80;
3220
3221                 sl = status ? sizeof(status_indent)-1 : 0;
3222
3223                 emax = c - sl - 1;
3224                 if (emax < 3)
3225                         emax = 3;
3226
3227                 e = ellipsize(s, emax, 50);
3228                 if (e) {
3229                         free(s);
3230                         s = e;
3231                 }
3232         }
3233
3234         if (prev_ephemeral)
3235                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3236         prev_ephemeral = ephemeral;
3237
3238         if (status) {
3239                 if (!isempty(status)) {
3240                         IOVEC_SET_STRING(iovec[n++], "[");
3241                         IOVEC_SET_STRING(iovec[n++], status);
3242                         IOVEC_SET_STRING(iovec[n++], "] ");
3243                 } else
3244                         IOVEC_SET_STRING(iovec[n++], status_indent);
3245         }
3246
3247         IOVEC_SET_STRING(iovec[n++], s);
3248         if (!ephemeral)
3249                 IOVEC_SET_STRING(iovec[n++], "\n");
3250
3251         if (writev(fd, iovec, n) < 0)
3252                 return -errno;
3253
3254         return 0;
3255 }
3256
3257 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3258         va_list ap;
3259         int r;
3260
3261         assert(format);
3262
3263         va_start(ap, format);
3264         r = status_vprintf(status, ellipse, ephemeral, format, ap);
3265         va_end(ap);
3266
3267         return r;
3268 }
3269
3270 char *replace_env(const char *format, char **env) {
3271         enum {
3272                 WORD,
3273                 CURLY,
3274                 VARIABLE
3275         } state = WORD;
3276
3277         const char *e, *word = format;
3278         char *r = NULL, *k;
3279
3280         assert(format);
3281
3282         for (e = format; *e; e ++) {
3283
3284                 switch (state) {
3285
3286                 case WORD:
3287                         if (*e == '$')
3288                                 state = CURLY;
3289                         break;
3290
3291                 case CURLY:
3292                         if (*e == '{') {
3293                                 k = strnappend(r, word, e-word-1);
3294                                 if (!k)
3295                                         goto fail;
3296
3297                                 free(r);
3298                                 r = k;
3299
3300                                 word = e-1;
3301                                 state = VARIABLE;
3302
3303                         } else if (*e == '$') {
3304                                 k = strnappend(r, word, e-word);
3305                                 if (!k)
3306                                         goto fail;
3307
3308                                 free(r);
3309                                 r = k;
3310
3311                                 word = e+1;
3312                                 state = WORD;
3313                         } else
3314                                 state = WORD;
3315                         break;
3316
3317                 case VARIABLE:
3318                         if (*e == '}') {
3319                                 const char *t;
3320
3321                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3322
3323                                 k = strappend(r, t);
3324                                 if (!k)
3325                                         goto fail;
3326
3327                                 free(r);
3328                                 r = k;
3329
3330                                 word = e+1;
3331                                 state = WORD;
3332                         }
3333                         break;
3334                 }
3335         }
3336
3337         k = strnappend(r, word, e-word);
3338         if (!k)
3339                 goto fail;
3340
3341         free(r);
3342         return k;
3343
3344 fail:
3345         free(r);
3346         return NULL;
3347 }
3348
3349 char **replace_env_argv(char **argv, char **env) {
3350         char **ret, **i;
3351         unsigned k = 0, l = 0;
3352
3353         l = strv_length(argv);
3354
3355         ret = new(char*, l+1);
3356         if (!ret)
3357                 return NULL;
3358
3359         STRV_FOREACH(i, argv) {
3360
3361                 /* If $FOO appears as single word, replace it by the split up variable */
3362                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3363                         char *e;
3364                         char **w, **m;
3365                         unsigned q;
3366
3367                         e = strv_env_get(env, *i+1);
3368                         if (e) {
3369                                 int r;
3370
3371                                 r = strv_split_quoted(&m, e, true);
3372                                 if (r < 0) {
3373                                         ret[k] = NULL;
3374                                         strv_free(ret);
3375                                         return NULL;
3376                                 }
3377                         } else
3378                                 m = NULL;
3379
3380                         q = strv_length(m);
3381                         l = l + q - 1;
3382
3383                         w = realloc(ret, sizeof(char*) * (l+1));
3384                         if (!w) {
3385                                 ret[k] = NULL;
3386                                 strv_free(ret);
3387                                 strv_free(m);
3388                                 return NULL;
3389                         }
3390
3391                         ret = w;
3392                         if (m) {
3393                                 memcpy(ret + k, m, q * sizeof(char*));
3394                                 free(m);
3395                         }
3396
3397                         k += q;
3398                         continue;
3399                 }
3400
3401                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3402                 ret[k] = replace_env(*i, env);
3403                 if (!ret[k]) {
3404                         strv_free(ret);
3405                         return NULL;
3406                 }
3407                 k++;
3408         }
3409
3410         ret[k] = NULL;
3411         return ret;
3412 }
3413
3414 int fd_columns(int fd) {
3415         struct winsize ws = {};
3416
3417         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3418                 return -errno;
3419
3420         if (ws.ws_col <= 0)
3421                 return -EIO;
3422
3423         return ws.ws_col;
3424 }
3425
3426 unsigned columns(void) {
3427         const char *e;
3428         int c;
3429
3430         if (_likely_(cached_columns > 0))
3431                 return cached_columns;
3432
3433         c = 0;
3434         e = getenv("COLUMNS");
3435         if (e)
3436                 (void) safe_atoi(e, &c);
3437
3438         if (c <= 0)
3439                 c = fd_columns(STDOUT_FILENO);
3440
3441         if (c <= 0)
3442                 c = 80;
3443
3444         cached_columns = c;
3445         return c;
3446 }
3447
3448 int fd_lines(int fd) {
3449         struct winsize ws = {};
3450
3451         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3452                 return -errno;
3453
3454         if (ws.ws_row <= 0)
3455                 return -EIO;
3456
3457         return ws.ws_row;
3458 }
3459
3460 unsigned lines(void) {
3461         const char *e;
3462         unsigned l;
3463
3464         if (_likely_(cached_lines > 0))
3465                 return cached_lines;
3466
3467         l = 0;
3468         e = getenv("LINES");
3469         if (e)
3470                 (void) safe_atou(e, &l);
3471
3472         if (l <= 0)
3473                 l = fd_lines(STDOUT_FILENO);
3474
3475         if (l <= 0)
3476                 l = 24;
3477
3478         cached_lines = l;
3479         return cached_lines;
3480 }
3481
3482 /* intended to be used as a SIGWINCH sighandler */
3483 void columns_lines_cache_reset(int signum) {
3484         cached_columns = 0;
3485         cached_lines = 0;
3486 }
3487
3488 bool on_tty(void) {
3489         static int cached_on_tty = -1;
3490
3491         if (_unlikely_(cached_on_tty < 0))
3492                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3493
3494         return cached_on_tty;
3495 }
3496
3497 int files_same(const char *filea, const char *fileb) {
3498         struct stat a, b;
3499
3500         if (stat(filea, &a) < 0)
3501                 return -errno;
3502
3503         if (stat(fileb, &b) < 0)
3504                 return -errno;
3505
3506         return a.st_dev == b.st_dev &&
3507                a.st_ino == b.st_ino;
3508 }
3509
3510 int running_in_chroot(void) {
3511         int ret;
3512
3513         ret = files_same("/proc/1/root", "/");
3514         if (ret < 0)
3515                 return ret;
3516
3517         return ret == 0;
3518 }
3519
3520 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3521         size_t x;
3522         char *r;
3523
3524         assert(s);
3525         assert(percent <= 100);
3526         assert(new_length >= 3);
3527
3528         if (old_length <= 3 || old_length <= new_length)
3529                 return strndup(s, old_length);
3530
3531         r = new0(char, new_length+1);
3532         if (!r)
3533                 return NULL;
3534
3535         x = (new_length * percent) / 100;
3536
3537         if (x > new_length - 3)
3538                 x = new_length - 3;
3539
3540         memcpy(r, s, x);
3541         r[x] = '.';
3542         r[x+1] = '.';
3543         r[x+2] = '.';
3544         memcpy(r + x + 3,
3545                s + old_length - (new_length - x - 3),
3546                new_length - x - 3);
3547
3548         return r;
3549 }
3550
3551 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3552         size_t x;
3553         char *e;
3554         const char *i, *j;
3555         unsigned k, len, len2;
3556
3557         assert(s);
3558         assert(percent <= 100);
3559         assert(new_length >= 3);
3560
3561         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3562         if (ascii_is_valid(s))
3563                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3564
3565         if (old_length <= 3 || old_length <= new_length)
3566                 return strndup(s, old_length);
3567
3568         x = (new_length * percent) / 100;
3569
3570         if (x > new_length - 3)
3571                 x = new_length - 3;
3572
3573         k = 0;
3574         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3575                 int c;
3576
3577                 c = utf8_encoded_to_unichar(i);
3578                 if (c < 0)
3579                         return NULL;
3580                 k += unichar_iswide(c) ? 2 : 1;
3581         }
3582
3583         if (k > x) /* last character was wide and went over quota */
3584                 x ++;
3585
3586         for (j = s + old_length; k < new_length && j > i; ) {
3587                 int c;
3588
3589                 j = utf8_prev_char(j);
3590                 c = utf8_encoded_to_unichar(j);
3591                 if (c < 0)
3592                         return NULL;
3593                 k += unichar_iswide(c) ? 2 : 1;
3594         }
3595         assert(i <= j);
3596
3597         /* we don't actually need to ellipsize */
3598         if (i == j)
3599                 return memdup(s, old_length + 1);
3600
3601         /* make space for ellipsis */
3602         j = utf8_next_char(j);
3603
3604         len = i - s;
3605         len2 = s + old_length - j;
3606         e = new(char, len + 3 + len2 + 1);
3607         if (!e)
3608                 return NULL;
3609
3610         /*
3611         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3612                old_length, new_length, x, len, len2, k);
3613         */
3614
3615         memcpy(e, s, len);
3616         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3617         e[len + 1] = 0x80;
3618         e[len + 2] = 0xa6;
3619
3620         memcpy(e + len + 3, j, len2 + 1);
3621
3622         return e;
3623 }
3624
3625 char *ellipsize(const char *s, size_t length, unsigned percent) {
3626         return ellipsize_mem(s, strlen(s), length, percent);
3627 }
3628
3629 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
3630         _cleanup_close_ int fd;
3631         int r;
3632
3633         assert(path);
3634
3635         if (parents)
3636                 mkdir_parents(path, 0755);
3637
3638         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3639         if (fd < 0)
3640                 return -errno;
3641
3642         if (mode > 0) {
3643                 r = fchmod(fd, mode);
3644                 if (r < 0)
3645                         return -errno;
3646         }
3647
3648         if (uid != UID_INVALID || gid != GID_INVALID) {
3649                 r = fchown(fd, uid, gid);
3650                 if (r < 0)
3651                         return -errno;
3652         }
3653
3654         if (stamp != USEC_INFINITY) {
3655                 struct timespec ts[2];
3656
3657                 timespec_store(&ts[0], stamp);
3658                 ts[1] = ts[0];
3659                 r = futimens(fd, ts);
3660         } else
3661                 r = futimens(fd, NULL);
3662         if (r < 0)
3663                 return -errno;
3664
3665         return 0;
3666 }
3667
3668 int touch(const char *path) {
3669         return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);
3670 }
3671
3672 char *unquote(const char *s, const char* quotes) {
3673         size_t l;
3674         assert(s);
3675
3676         /* This is rather stupid, simply removes the heading and
3677          * trailing quotes if there is one. Doesn't care about
3678          * escaping or anything. We should make this smarter one
3679          * day... */
3680
3681         l = strlen(s);
3682         if (l < 2)
3683                 return strdup(s);
3684
3685         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3686                 return strndup(s+1, l-2);
3687
3688         return strdup(s);
3689 }
3690
3691 char *normalize_env_assignment(const char *s) {
3692         _cleanup_free_ char *value = NULL;
3693         const char *eq;
3694         char *p, *name;
3695
3696         eq = strchr(s, '=');
3697         if (!eq) {
3698                 char *r, *t;
3699
3700                 r = strdup(s);
3701                 if (!r)
3702                         return NULL;
3703
3704                 t = strstrip(r);
3705                 if (t != r)
3706                         memmove(r, t, strlen(t) + 1);
3707
3708                 return r;
3709         }
3710
3711         name = strndupa(s, eq - s);
3712         p = strdupa(eq + 1);
3713
3714         value = unquote(strstrip(p), QUOTES);
3715         if (!value)
3716                 return NULL;
3717
3718         return strjoin(strstrip(name), "=", value, NULL);
3719 }
3720
3721 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3722         siginfo_t dummy;
3723
3724         assert(pid >= 1);
3725
3726         if (!status)
3727                 status = &dummy;
3728
3729         for (;;) {
3730                 zero(*status);
3731
3732                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3733
3734                         if (errno == EINTR)
3735                                 continue;
3736
3737                         return -errno;
3738                 }
3739
3740                 return 0;
3741         }
3742 }
3743
3744 /*
3745  * Return values:
3746  * < 0 : wait_for_terminate() failed to get the state of the
3747  *       process, the process was terminated by a signal, or
3748  *       failed for an unknown reason.
3749  * >=0 : The process terminated normally, and its exit code is
3750  *       returned.
3751  *
3752  * That is, success is indicated by a return value of zero, and an
3753  * error is indicated by a non-zero value.
3754  *
3755  * A warning is emitted if the process terminates abnormally,
3756  * and also if it returns non-zero unless check_exit_code is true.
3757  */
3758 int wait_for_terminate_and_warn(const char *name, pid_t pid, bool check_exit_code) {
3759         int r;
3760         siginfo_t status;
3761
3762         assert(name);
3763         assert(pid > 1);
3764
3765         r = wait_for_terminate(pid, &status);
3766         if (r < 0)
3767                 return log_warning_errno(r, "Failed to wait for %s: %m", name);
3768
3769         if (status.si_code == CLD_EXITED) {
3770                 if (status.si_status != 0)
3771                         log_full(check_exit_code ? LOG_WARNING : LOG_DEBUG,
3772                                  "%s failed with error code %i.", name, status.si_status);
3773                 else
3774                         log_debug("%s succeeded.", name);
3775
3776                 return status.si_status;
3777         } else if (status.si_code == CLD_KILLED ||
3778                    status.si_code == CLD_DUMPED) {
3779
3780                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3781                 return -EPROTO;
3782         }
3783
3784         log_warning("%s failed due to unknown reason.", name);
3785         return -EPROTO;
3786 }
3787
3788 noreturn void freeze(void) {
3789
3790         /* Make sure nobody waits for us on a socket anymore */
3791         close_all_fds(NULL, 0);
3792
3793         sync();
3794
3795         for (;;)
3796                 pause();
3797 }
3798
3799 bool null_or_empty(struct stat *st) {
3800         assert(st);
3801
3802         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3803                 return true;
3804
3805         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3806                 return true;
3807
3808         return false;
3809 }
3810
3811 int null_or_empty_path(const char *fn) {
3812         struct stat st;
3813
3814         assert(fn);
3815
3816         if (stat(fn, &st) < 0)
3817                 return -errno;
3818
3819         return null_or_empty(&st);
3820 }
3821
3822 int null_or_empty_fd(int fd) {
3823         struct stat st;
3824
3825         assert(fd >= 0);
3826
3827         if (fstat(fd, &st) < 0)
3828                 return -errno;
3829
3830         return null_or_empty(&st);
3831 }
3832
3833 DIR *xopendirat(int fd, const char *name, int flags) {
3834         int nfd;
3835         DIR *d;
3836
3837         assert(!(flags & O_CREAT));
3838
3839         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3840         if (nfd < 0)
3841                 return NULL;
3842
3843         d = fdopendir(nfd);
3844         if (!d) {
3845                 safe_close(nfd);
3846                 return NULL;
3847         }
3848
3849         return d;
3850 }
3851
3852 int signal_from_string_try_harder(const char *s) {
3853         int signo;
3854         assert(s);
3855
3856         signo = signal_from_string(s);
3857         if (signo <= 0)
3858                 if (startswith(s, "SIG"))
3859                         return signal_from_string(s+3);
3860
3861         return signo;
3862 }
3863
3864 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3865         _cleanup_free_ char *t = NULL, *u = NULL;
3866         size_t enc_len;
3867
3868         u = unquote(tagvalue, "\"\'");
3869         if (!u)
3870                 return NULL;
3871
3872         enc_len = strlen(u) * 4 + 1;
3873         t = new(char, enc_len);
3874         if (!t)
3875                 return NULL;
3876
3877         if (encode_devnode_name(u, t, enc_len) < 0)
3878                 return NULL;
3879
3880         return strjoin("/dev/disk/by-", by, "/", t, NULL);
3881 }
3882
3883 char *fstab_node_to_udev_node(const char *p) {
3884         assert(p);
3885
3886         if (startswith(p, "LABEL="))
3887                 return tag_to_udev_node(p+6, "label");
3888
3889         if (startswith(p, "UUID="))
3890                 return tag_to_udev_node(p+5, "uuid");
3891
3892         if (startswith(p, "PARTUUID="))
3893                 return tag_to_udev_node(p+9, "partuuid");
3894
3895         if (startswith(p, "PARTLABEL="))
3896                 return tag_to_udev_node(p+10, "partlabel");
3897
3898         return strdup(p);
3899 }
3900
3901 bool tty_is_vc(const char *tty) {
3902         assert(tty);
3903
3904         return vtnr_from_tty(tty) >= 0;
3905 }
3906
3907 bool tty_is_console(const char *tty) {
3908         assert(tty);
3909
3910         if (startswith(tty, "/dev/"))
3911                 tty += 5;
3912
3913         return streq(tty, "console");
3914 }
3915
3916 int vtnr_from_tty(const char *tty) {
3917         int i, r;
3918
3919         assert(tty);
3920
3921         if (startswith(tty, "/dev/"))
3922                 tty += 5;
3923
3924         if (!startswith(tty, "tty") )
3925                 return -EINVAL;
3926
3927         if (tty[3] < '0' || tty[3] > '9')
3928                 return -EINVAL;
3929
3930         r = safe_atoi(tty+3, &i);
3931         if (r < 0)
3932                 return r;
3933
3934         if (i < 0 || i > 63)
3935                 return -EINVAL;
3936
3937         return i;
3938 }
3939
3940 char *resolve_dev_console(char **active) {
3941         char *tty;
3942
3943         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3944          * (i.e. not read-only-mounted which is a sign for container setups) */
3945
3946         if (path_is_read_only_fs("/sys") > 0)
3947                 return NULL;
3948
3949         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3950                 return NULL;
3951
3952         /* If multiple log outputs are configured the last one is what
3953          * /dev/console points to */
3954         tty = strrchr(*active, ' ');
3955         if (tty)
3956                 tty++;
3957         else
3958                 tty = *active;
3959
3960         if (streq(tty, "tty0")) {
3961                 char *tmp;
3962
3963                 /* Get the active VC (e.g. tty1) */
3964                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3965                         free(*active);
3966                         tty = *active = tmp;
3967                 }
3968         }
3969
3970         return tty;
3971 }
3972
3973 bool tty_is_vc_resolve(const char *tty) {
3974         _cleanup_free_ char *active = NULL;
3975
3976         assert(tty);
3977
3978         if (startswith(tty, "/dev/"))
3979                 tty += 5;
3980
3981         if (streq(tty, "console")) {
3982                 tty = resolve_dev_console(&active);
3983                 if (!tty)
3984                         return false;