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