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