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