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