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