1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
6 This file is part of systemd.
8 Copyright 2010 Lennart Poettering
10 systemd is free software; you can redistribute it and/or modify it
11 under the terms of the GNU Lesser General Public License as published by
12 the Free Software Foundation; either version 2.1 of the License, or
13 (at your option) any later version.
15 systemd is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
20 You should have received a copy of the GNU Lesser General Public License
21 along with systemd; If not, see <http://www.gnu.org/licenses/>.
36 #include <sys/inotify.h>
37 #include <sys/socket.h>
39 #include <sys/statfs.h>
40 #include <sys/types.h>
44 #include "formats-util.h"
47 #include "time-util.h"
49 /* What is interpreted as whitespace? */
50 #define WHITESPACE " \t\n\r"
51 #define NEWLINE "\n\r"
54 #define GLOB_CHARS "*?["
56 #define FORMAT_BYTES_MAX 8
58 size_t page_size(void) _pure_
;
59 #define PAGE_ALIGN(l) ALIGN_TO((l), page_size())
61 #define new(t, n) ((t*) malloc_multiply(sizeof(t), (n)))
63 #define new0(t, n) ((t*) calloc((n), sizeof(t)))
65 #define newa(t, n) ((t*) alloca(sizeof(t)*(n)))
67 #define newa0(t, n) ((t*) alloca0(sizeof(t)*(n)))
69 #define newdup(t, p, n) ((t*) memdup_multiply(p, sizeof(t), (n)))
71 #define malloc0(n) (calloc(1, (n)))
73 static inline void *mfree(void *memory
) {
78 static inline const char* yes_no(bool b
) {
79 return b
? "yes" : "no";
82 static inline const char* true_false(bool b
) {
83 return b
? "true" : "false";
86 static inline const char* one_zero(bool b
) {
90 int parse_size(const char *t
, uint64_t base
, uint64_t *size
);
92 int parse_boolean(const char *v
) _pure_
;
93 int parse_pid(const char *s
, pid_t
* ret_pid
);
95 int safe_atou(const char *s
, unsigned *ret_u
);
96 int safe_atoi(const char *s
, int *ret_i
);
98 int safe_atollu(const char *s
, unsigned long long *ret_u
);
99 int safe_atolli(const char *s
, long long int *ret_i
);
101 int safe_atod(const char *s
, double *ret_d
);
103 int safe_atou8(const char *s
, uint8_t *ret
);
105 #if LONG_MAX == INT_MAX
106 static inline int safe_atolu(const char *s
, unsigned long *ret_u
) {
107 assert_cc(sizeof(unsigned long) == sizeof(unsigned));
108 return safe_atou(s
, (unsigned*) ret_u
);
110 static inline int safe_atoli(const char *s
, long int *ret_u
) {
111 assert_cc(sizeof(long int) == sizeof(int));
112 return safe_atoi(s
, (int*) ret_u
);
115 static inline int safe_atolu(const char *s
, unsigned long *ret_u
) {
116 assert_cc(sizeof(unsigned long) == sizeof(unsigned long long));
117 return safe_atollu(s
, (unsigned long long*) ret_u
);
119 static inline int safe_atoli(const char *s
, long int *ret_u
) {
120 assert_cc(sizeof(long int) == sizeof(long long int));
121 return safe_atolli(s
, (long long int*) ret_u
);
125 static inline int safe_atou32(const char *s
, uint32_t *ret_u
) {
126 assert_cc(sizeof(uint32_t) == sizeof(unsigned));
127 return safe_atou(s
, (unsigned*) ret_u
);
130 static inline int safe_atoi32(const char *s
, int32_t *ret_i
) {
131 assert_cc(sizeof(int32_t) == sizeof(int));
132 return safe_atoi(s
, (int*) ret_i
);
135 static inline int safe_atou64(const char *s
, uint64_t *ret_u
) {
136 assert_cc(sizeof(uint64_t) == sizeof(unsigned long long));
137 return safe_atollu(s
, (unsigned long long*) ret_u
);
140 static inline int safe_atoi64(const char *s
, int64_t *ret_i
) {
141 assert_cc(sizeof(int64_t) == sizeof(long long int));
142 return safe_atolli(s
, (long long int*) ret_i
);
145 int safe_atou16(const char *s
, uint16_t *ret
);
146 int safe_atoi16(const char *s
, int16_t *ret
);
148 int readlinkat_malloc(int fd
, const char *p
, char **ret
);
149 int readlink_malloc(const char *p
, char **r
);
150 int readlink_value(const char *p
, char **ret
);
151 int readlink_and_make_absolute(const char *p
, char **r
);
152 int readlink_and_canonicalize(const char *p
, char **r
);
154 char *file_in_same_dir(const char *path
, const char *filename
);
156 int rmdir_parents(const char *path
, const char *stop
);
158 char hexchar(int x
) _const_
;
159 int unhexchar(char c
) _const_
;
160 char octchar(int x
) _const_
;
161 int unoctchar(char c
) _const_
;
162 char decchar(int x
) _const_
;
163 int undecchar(char c
) _const_
;
164 char base32hexchar(int x
) _const_
;
165 int unbase32hexchar(char c
) _const_
;
166 char base64char(int x
) _const_
;
167 int unbase64char(char c
) _const_
;
169 bool dirent_is_file(const struct dirent
*de
) _pure_
;
170 bool dirent_is_file_with_suffix(const struct dirent
*de
, const char *suffix
) _pure_
;
172 bool hidden_file(const char *filename
) _pure_
;
174 /* For basic lookup tables with strictly enumerated entries */
175 #define _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,scope) \
176 scope const char *name##_to_string(type i) { \
177 if (i < 0 || i >= (type) ELEMENTSOF(name##_table)) \
179 return name##_table[i]; \
182 ssize_t
string_table_lookup(const char * const *table
, size_t len
, const char *key
);
184 #define _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,scope) \
185 scope type name##_from_string(const char *s) { \
186 return (type) string_table_lookup(name##_table, ELEMENTSOF(name##_table), s); \
189 #define _DEFINE_STRING_TABLE_LOOKUP(name,type,scope) \
190 _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,scope) \
191 _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,scope) \
192 struct __useless_struct_to_allow_trailing_semicolon__
194 #define DEFINE_STRING_TABLE_LOOKUP(name,type) _DEFINE_STRING_TABLE_LOOKUP(name,type,)
195 #define DEFINE_PRIVATE_STRING_TABLE_LOOKUP(name,type) _DEFINE_STRING_TABLE_LOOKUP(name,type,static)
196 #define DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(name,type) _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,static)
197 #define DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(name,type) _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,static)
199 /* For string conversions where numbers are also acceptable */
200 #define DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(name,type,max) \
201 int name##_to_string_alloc(type i, char **str) { \
203 if (i < 0 || i > max) \
205 if (i < (type) ELEMENTSOF(name##_table)) { \
206 s = strdup(name##_table[i]); \
210 if (asprintf(&s, "%i", i) < 0) \
216 type name##_from_string(const char *s) { \
221 for (i = 0; i < (type) ELEMENTSOF(name##_table); i++) \
222 if (streq_ptr(name##_table[i], s)) \
224 if (safe_atou(s, &u) >= 0 && u <= max) \
228 struct __useless_struct_to_allow_trailing_semicolon__
230 bool fstype_is_network(const char *fstype
);
232 int fopen_temporary(const char *path
, FILE **_f
, char **_temp_path
);
234 bool is_device_path(const char *path
);
236 int dir_is_empty(const char *path
);
237 char* dirname_malloc(const char *path
);
239 static inline int dir_is_populated(const char *path
) {
241 r
= dir_is_empty(path
);
247 int chmod_and_chown(const char *path
, mode_t mode
, uid_t uid
, gid_t gid
);
248 int fchmod_and_fchown(int fd
, mode_t mode
, uid_t uid
, gid_t gid
);
250 typedef long statfs_f_type_t
;
252 bool is_fs_type(const struct statfs
*s
, statfs_f_type_t magic_value
) _pure_
;
253 int fd_check_fstype(int fd
, statfs_f_type_t magic_value
);
254 int path_check_fstype(const char *path
, statfs_f_type_t magic_value
);
256 bool is_temporary_fs(const struct statfs
*s
) _pure_
;
257 int fd_is_temporary_fs(int fd
);
259 #define xsprintf(buf, fmt, ...) \
260 assert_message_se((size_t) snprintf(buf, ELEMENTSOF(buf), fmt, __VA_ARGS__) < ELEMENTSOF(buf), \
261 "xsprintf: " #buf "[] must be big enough")
263 int files_same(const char *filea
, const char *fileb
);
265 int running_in_chroot(void);
267 int touch_file(const char *path
, bool parents
, usec_t stamp
, uid_t uid
, gid_t gid
, mode_t mode
);
268 int touch(const char *path
);
270 noreturn
void freeze(void);
272 bool null_or_empty(struct stat
*st
) _pure_
;
273 int null_or_empty_path(const char *fn
);
274 int null_or_empty_fd(int fd
);
276 DIR *xopendirat(int dirfd
, const char *name
, int flags
);
278 char *fstab_node_to_udev_node(const char *p
);
280 void execute_directories(const char* const* directories
, usec_t timeout
, char *argv
[]);
282 bool plymouth_running(void);
284 int symlink_idempotent(const char *from
, const char *to
);
286 int symlink_atomic(const char *from
, const char *to
);
287 int mknod_atomic(const char *path
, mode_t mode
, dev_t dev
);
288 int mkfifo_atomic(const char *path
, mode_t mode
);
290 int fchmod_umask(int fd
, mode_t mode
);
292 bool display_is_local(const char *display
) _pure_
;
293 int socket_from_display(const char *display
, char **path
);
295 int glob_exists(const char *path
);
296 int glob_extend(char ***strv
, const char *path
);
298 int dirent_ensure_type(DIR *d
, struct dirent
*de
);
300 int get_files_in_directory(const char *path
, char ***list
);
302 bool is_main_thread(void);
304 int block_get_whole_disk(dev_t d
, dev_t
*ret
);
306 #define NULSTR_FOREACH(i, l) \
307 for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)
309 #define NULSTR_FOREACH_PAIR(i, j, l) \
310 for ((i) = (l), (j) = strchr((i), 0)+1; (i) && *(i); (i) = strchr((j), 0)+1, (j) = *(i) ? strchr((i), 0)+1 : (i))
312 int ioprio_class_to_string_alloc(int i
, char **s
);
313 int ioprio_class_from_string(const char *s
);
315 const char *sigchld_code_to_string(int i
) _const_
;
316 int sigchld_code_from_string(const char *s
) _pure_
;
318 int log_facility_unshifted_to_string_alloc(int i
, char **s
);
319 int log_facility_unshifted_from_string(const char *s
);
320 bool log_facility_unshifted_is_valid(int faciliy
);
322 int log_level_to_string_alloc(int i
, char **s
);
323 int log_level_from_string(const char *s
);
324 bool log_level_is_valid(int level
);
326 int sched_policy_to_string_alloc(int i
, char **s
);
327 int sched_policy_from_string(const char *s
);
329 const char *rlimit_to_string(int i
) _const_
;
330 int rlimit_from_string(const char *s
) _pure_
;
332 extern int saved_argc
;
333 extern char **saved_argv
;
335 bool kexec_loaded(void);
337 int prot_from_flags(int flags
) _const_
;
339 char *format_bytes(char *buf
, size_t l
, uint64_t t
);
341 void* memdup(const void *p
, size_t l
) _alloc_(2);
343 int fork_agent(pid_t
*pid
, const int except
[], unsigned n_except
, const char *path
, ...);
345 int setrlimit_closest(int resource
, const struct rlimit
*rlim
);
347 bool http_url_is_valid(const char *url
) _pure_
;
348 bool documentation_url_is_valid(const char *url
) _pure_
;
350 bool http_etag_is_valid(const char *etag
);
352 bool in_initrd(void);
354 static inline void freep(void *p
) {
358 static inline void umaskp(mode_t
*u
) {
362 DEFINE_TRIVIAL_CLEANUP_FUNC(FILE*, endmntent
);
364 #define _cleanup_free_ _cleanup_(freep)
365 #define _cleanup_umask_ _cleanup_(umaskp)
366 #define _cleanup_globfree_ _cleanup_(globfree)
367 #define _cleanup_endmntent_ _cleanup_(endmntentp)
369 _malloc_
_alloc_(1, 2) static inline void *malloc_multiply(size_t a
, size_t b
) {
370 if (_unlikely_(b
!= 0 && a
> ((size_t) -1) / b
))
373 return malloc(a
* b
);
376 _alloc_(2, 3) static inline void *realloc_multiply(void *p
, size_t a
, size_t b
) {
377 if (_unlikely_(b
!= 0 && a
> ((size_t) -1) / b
))
380 return realloc(p
, a
* b
);
383 _alloc_(2, 3) static inline void *memdup_multiply(const void *p
, size_t a
, size_t b
) {
384 if (_unlikely_(b
!= 0 && a
> ((size_t) -1) / b
))
387 return memdup(p
, a
* b
);
390 bool filename_is_valid(const char *p
) _pure_
;
391 bool path_is_safe(const char *p
) _pure_
;
392 bool string_is_safe(const char *p
) _pure_
;
395 * Check if a string contains any glob patterns.
397 _pure_
static inline bool string_is_glob(const char *p
) {
398 return !!strpbrk(p
, GLOB_CHARS
);
401 void *xbsearch_r(const void *key
, const void *base
, size_t nmemb
, size_t size
,
402 int (*compar
) (const void *, const void *, void *),
405 #define _(String) gettext (String)
406 #define N_(String) String
407 void init_gettext(void);
408 bool is_locale_utf8(void);
410 typedef enum DrawSpecialChar
{
415 DRAW_TRIANGULAR_BULLET
,
419 _DRAW_SPECIAL_CHAR_MAX
422 const char *draw_special_char(DrawSpecialChar ch
);
424 int on_ac_power(void);
426 int search_and_fopen(const char *path
, const char *mode
, const char *root
, const char **search
, FILE **_f
);
427 int search_and_fopen_nulstr(const char *path
, const char *mode
, const char *root
, const char *search
, FILE **_f
);
429 #define FOREACH_LINE(line, f, on_error) \
431 if (!fgets(line, sizeof(line), f)) { \
438 #define FOREACH_DIRENT(de, d, on_error) \
439 for (errno = 0, de = readdir(d);; errno = 0, de = readdir(d)) \
445 } else if (hidden_file((de)->d_name)) \
449 #define FOREACH_DIRENT_ALL(de, d, on_error) \
450 for (errno = 0, de = readdir(d);; errno = 0, de = readdir(d)) \
458 static inline void *mempset(void *s
, int c
, size_t n
) {
460 return (uint8_t*)s
+ n
;
463 char *hexmem(const void *p
, size_t l
);
464 int unhexmem(const char *p
, size_t l
, void **mem
, size_t *len
);
466 char *base32hexmem(const void *p
, size_t l
, bool padding
);
467 int unbase32hexmem(const char *p
, size_t l
, bool padding
, void **mem
, size_t *len
);
469 char *base64mem(const void *p
, size_t l
);
470 int unbase64mem(const char *p
, size_t l
, void **mem
, size_t *len
);
472 void* greedy_realloc(void **p
, size_t *allocated
, size_t need
, size_t size
);
473 void* greedy_realloc0(void **p
, size_t *allocated
, size_t need
, size_t size
);
474 #define GREEDY_REALLOC(array, allocated, need) \
475 greedy_realloc((void**) &(array), &(allocated), (need), sizeof((array)[0]))
477 #define GREEDY_REALLOC0(array, allocated, need) \
478 greedy_realloc0((void**) &(array), &(allocated), (need), sizeof((array)[0]))
480 static inline void _reset_errno_(int *saved_errno
) {
481 errno
= *saved_errno
;
484 #define PROTECT_ERRNO _cleanup_(_reset_errno_) __attribute__((unused)) int _saved_errno_ = errno
486 static inline int negative_errno(void) {
487 /* This helper should be used to shut up gcc if you know 'errno' is
488 * negative. Instead of "return -errno;", use "return negative_errno();"
489 * It will suppress bogus gcc warnings in case it assumes 'errno' might
490 * be 0 and thus the caller's error-handling might not be triggered. */
491 assert_return(errno
> 0, -EINVAL
);
495 struct _umask_struct_
{
500 static inline void _reset_umask_(struct _umask_struct_
*s
) {
504 #define RUN_WITH_UMASK(mask) \
505 for (_cleanup_(_reset_umask_) struct _umask_struct_ _saved_umask_ = { umask(mask), false }; \
506 !_saved_umask_.quit ; \
507 _saved_umask_.quit = true)
509 static inline unsigned u64log2(uint64_t n
) {
510 #if __SIZEOF_LONG_LONG__ == 8
511 return (n
> 1) ? (unsigned) __builtin_clzll(n
) ^ 63U : 0;
517 static inline unsigned u32ctz(uint32_t n
) {
518 #if __SIZEOF_INT__ == 4
519 return __builtin_ctz(n
);
525 static inline unsigned log2i(int x
) {
528 return __SIZEOF_INT__
* 8 - __builtin_clz(x
) - 1;
531 static inline unsigned log2u(unsigned x
) {
534 return sizeof(unsigned) * 8 - __builtin_clz(x
) - 1;
537 static inline unsigned log2u_round_up(unsigned x
) {
543 return log2u(x
- 1) + 1;
546 #define DECIMAL_STR_WIDTH(x) \
548 typeof(x) _x_ = (x); \
555 int unlink_noerrno(const char *path
);
561 _new_ = alloca(_len_); \
562 (void *) memset(_new_, 0, _len_); \
565 /* It's not clear what alignment glibc/gcc alloca() guarantee, hence provide a guaranteed safe version */
566 #define alloca_align(size, align) \
569 size_t _mask_ = (align) - 1; \
570 _ptr_ = alloca((size) + _mask_); \
571 (void*)(((uintptr_t)_ptr_ + _mask_) & ~_mask_); \
574 #define alloca0_align(size, align) \
577 size_t _size_ = (size); \
578 _new_ = alloca_align(_size_, (align)); \
579 (void*)memset(_new_, 0, _size_); \
582 bool id128_is_valid(const char *s
) _pure_
;
584 int shall_restore_state(void);
587 * Normal qsort requires base to be nonnull. Here were require
588 * that only if nmemb > 0.
590 static inline void qsort_safe(void *base
, size_t nmemb
, size_t size
, comparison_fn_t compar
) {
595 qsort(base
, nmemb
, size
, compar
);
598 int proc_cmdline(char **ret
);
599 int parse_proc_cmdline(int (*parse_word
)(const char *key
, const char *value
));
600 int get_proc_cmdline_key(const char *parameter
, char **value
);
602 int container_get_leader(const char *machine
, pid_t
*pid
);
604 int namespace_open(pid_t pid
, int *pidns_fd
, int *mntns_fd
, int *netns_fd
, int *userns_fd
, int *root_fd
);
605 int namespace_enter(int pidns_fd
, int mntns_fd
, int netns_fd
, int userns_fd
, int root_fd
);
607 int mkostemp_safe(char *pattern
, int flags
);
608 int open_tmpfile(const char *path
, int flags
);
610 int fd_warn_permissions(const char *path
, int fd
);
612 #ifndef PERSONALITY_INVALID
613 /* personality(7) documents that 0xffffffffUL is used for querying the
614 * current personality, hence let's use that here as error
616 #define PERSONALITY_INVALID 0xffffffffLU
619 unsigned long personality_from_string(const char *p
);
620 const char *personality_to_string(unsigned long);
622 uint64_t physical_memory(void);
624 void hexdump(FILE *f
, const void *p
, size_t s
);
626 union file_handle_union
{
627 struct file_handle handle
;
628 char padding
[sizeof(struct file_handle
) + MAX_HANDLE_SZ
];
630 #define FILE_HANDLE_INIT { .handle.handle_bytes = MAX_HANDLE_SZ }
632 int update_reboot_param_file(const char *param
);
634 int umount_recursive(const char *target
, int flags
);
636 int bind_remount_recursive(const char *prefix
, bool ro
);
638 int fflush_and_check(FILE *f
);
640 int tempfn_xxxxxx(const char *p
, const char *extra
, char **ret
);
641 int tempfn_random(const char *p
, const char *extra
, char **ret
);
642 int tempfn_random_child(const char *p
, const char *extra
, char **ret
);
644 int take_password_lock(const char *root
);
646 int is_symlink(const char *path
);
647 int is_dir(const char *path
, bool follow
);
648 int is_device_node(const char *path
);
650 #define INOTIFY_EVENT_MAX (sizeof(struct inotify_event) + NAME_MAX + 1)
652 #define FOREACH_INOTIFY_EVENT(e, buffer, sz) \
653 for ((e) = &buffer.ev; \
654 (uint8_t*) (e) < (uint8_t*) (buffer.raw) + (sz); \
655 (e) = (struct inotify_event*) ((uint8_t*) (e) + sizeof(struct inotify_event) + (e)->len))
657 union inotify_event_buffer
{
658 struct inotify_event ev
;
659 uint8_t raw
[INOTIFY_EVENT_MAX
];
662 #define laccess(path, mode) faccessat(AT_FDCWD, (path), (mode), AT_SYMLINK_NOFOLLOW)
664 ssize_t
fgetxattrat_fake(int dirfd
, const char *filename
, const char *attribute
, void *value
, size_t size
, int flags
);
666 int fd_setcrtime(int fd
, usec_t usec
);
667 int fd_getcrtime(int fd
, usec_t
*usec
);
668 int path_getcrtime(const char *p
, usec_t
*usec
);
669 int fd_getcrtime_at(int dirfd
, const char *name
, usec_t
*usec
, int flags
);
671 int chattr_fd(int fd
, unsigned value
, unsigned mask
);
672 int chattr_path(const char *p
, unsigned value
, unsigned mask
);
674 int read_attr_fd(int fd
, unsigned *ret
);
675 int read_attr_path(const char *p
, unsigned *ret
);
677 #define RLIMIT_MAKE_CONST(lim) ((struct rlimit) { lim, lim })
679 int syslog_parse_priority(const char **p
, int *priority
, bool with_facility
);
681 int rename_noreplace(int olddirfd
, const char *oldpath
, int newdirfd
, const char *newpath
);
683 int parse_mode(const char *s
, mode_t
*ret
);
685 int mount_move_root(const char *path
);
687 int getxattr_malloc(const char *path
, const char *name
, char **value
, bool allow_symlink
);
688 int fgetxattr_malloc(int fd
, const char *name
, char **value
);
690 void nop_signal_handler(int sig
);
694 bool fdname_is_valid(const char *s
);
696 bool oom_score_adjust_is_valid(int oa
);