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