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