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