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