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