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 close_nointr(int fd
);
91 int safe_close(int fd
);
92 void safe_close_pair(int p
[]);
94 void close_many(const int fds
[], unsigned n_fd
);
96 int fclose_nointr(FILE *f
);
97 FILE* safe_fclose(FILE *f
);
98 DIR* safe_closedir(DIR *f
);
100 int parse_size(const char *t
, uint64_t base
, uint64_t *size
);
102 int parse_boolean(const char *v
) _pure_
;
103 int parse_pid(const char *s
, pid_t
* ret_pid
);
104 int parse_uid(const char *s
, uid_t
* ret_uid
);
105 #define parse_gid(s, ret_gid) parse_uid(s, ret_gid)
107 bool uid_is_valid(uid_t uid
);
109 static inline bool gid_is_valid(gid_t gid
) {
110 return uid_is_valid((uid_t
) gid
);
113 int safe_atou(const char *s
, unsigned *ret_u
);
114 int safe_atoi(const char *s
, int *ret_i
);
116 int safe_atollu(const char *s
, unsigned long long *ret_u
);
117 int safe_atolli(const char *s
, long long int *ret_i
);
119 int safe_atod(const char *s
, double *ret_d
);
121 int safe_atou8(const char *s
, uint8_t *ret
);
123 #if LONG_MAX == INT_MAX
124 static inline int safe_atolu(const char *s
, unsigned long *ret_u
) {
125 assert_cc(sizeof(unsigned long) == sizeof(unsigned));
126 return safe_atou(s
, (unsigned*) ret_u
);
128 static inline int safe_atoli(const char *s
, long int *ret_u
) {
129 assert_cc(sizeof(long int) == sizeof(int));
130 return safe_atoi(s
, (int*) ret_u
);
133 static inline int safe_atolu(const char *s
, unsigned long *ret_u
) {
134 assert_cc(sizeof(unsigned long) == sizeof(unsigned long long));
135 return safe_atollu(s
, (unsigned long long*) ret_u
);
137 static inline int safe_atoli(const char *s
, long int *ret_u
) {
138 assert_cc(sizeof(long int) == sizeof(long long int));
139 return safe_atolli(s
, (long long int*) ret_u
);
143 static inline int safe_atou32(const char *s
, uint32_t *ret_u
) {
144 assert_cc(sizeof(uint32_t) == sizeof(unsigned));
145 return safe_atou(s
, (unsigned*) ret_u
);
148 static inline int safe_atoi32(const char *s
, int32_t *ret_i
) {
149 assert_cc(sizeof(int32_t) == sizeof(int));
150 return safe_atoi(s
, (int*) ret_i
);
153 static inline int safe_atou64(const char *s
, uint64_t *ret_u
) {
154 assert_cc(sizeof(uint64_t) == sizeof(unsigned long long));
155 return safe_atollu(s
, (unsigned long long*) ret_u
);
158 static inline int safe_atoi64(const char *s
, int64_t *ret_i
) {
159 assert_cc(sizeof(int64_t) == sizeof(long long int));
160 return safe_atolli(s
, (long long int*) ret_i
);
163 int safe_atou16(const char *s
, uint16_t *ret
);
164 int safe_atoi16(const char *s
, int16_t *ret
);
166 int readlinkat_malloc(int fd
, const char *p
, char **ret
);
167 int readlink_malloc(const char *p
, char **r
);
168 int readlink_value(const char *p
, char **ret
);
169 int readlink_and_make_absolute(const char *p
, char **r
);
170 int readlink_and_canonicalize(const char *p
, char **r
);
172 char *file_in_same_dir(const char *path
, const char *filename
);
174 int rmdir_parents(const char *path
, const char *stop
);
176 char hexchar(int x
) _const_
;
177 int unhexchar(char c
) _const_
;
178 char octchar(int x
) _const_
;
179 int unoctchar(char c
) _const_
;
180 char decchar(int x
) _const_
;
181 int undecchar(char c
) _const_
;
182 char base32hexchar(int x
) _const_
;
183 int unbase32hexchar(char c
) _const_
;
184 char base64char(int x
) _const_
;
185 int unbase64char(char c
) _const_
;
187 bool dirent_is_file(const struct dirent
*de
) _pure_
;
188 bool dirent_is_file_with_suffix(const struct dirent
*de
, const char *suffix
) _pure_
;
190 bool hidden_file(const char *filename
) _pure_
;
192 /* For basic lookup tables with strictly enumerated entries */
193 #define _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,scope) \
194 scope const char *name##_to_string(type i) { \
195 if (i < 0 || i >= (type) ELEMENTSOF(name##_table)) \
197 return name##_table[i]; \
200 ssize_t
string_table_lookup(const char * const *table
, size_t len
, const char *key
);
202 #define _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,scope) \
203 scope type name##_from_string(const char *s) { \
204 return (type) string_table_lookup(name##_table, ELEMENTSOF(name##_table), s); \
207 #define _DEFINE_STRING_TABLE_LOOKUP(name,type,scope) \
208 _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,scope) \
209 _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,scope) \
210 struct __useless_struct_to_allow_trailing_semicolon__
212 #define DEFINE_STRING_TABLE_LOOKUP(name,type) _DEFINE_STRING_TABLE_LOOKUP(name,type,)
213 #define DEFINE_PRIVATE_STRING_TABLE_LOOKUP(name,type) _DEFINE_STRING_TABLE_LOOKUP(name,type,static)
214 #define DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(name,type) _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,static)
215 #define DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(name,type) _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,static)
217 /* For string conversions where numbers are also acceptable */
218 #define DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(name,type,max) \
219 int name##_to_string_alloc(type i, char **str) { \
221 if (i < 0 || i > max) \
223 if (i < (type) ELEMENTSOF(name##_table)) { \
224 s = strdup(name##_table[i]); \
228 if (asprintf(&s, "%i", i) < 0) \
234 type name##_from_string(const char *s) { \
239 for (i = 0; i < (type) ELEMENTSOF(name##_table); i++) \
240 if (streq_ptr(name##_table[i], s)) \
242 if (safe_atou(s, &u) >= 0 && u <= max) \
246 struct __useless_struct_to_allow_trailing_semicolon__
248 int fd_nonblock(int fd
, bool nonblock
);
249 int fd_cloexec(int fd
, bool cloexec
);
251 int close_all_fds(const int except
[], unsigned n_except
);
253 bool fstype_is_network(const char *fstype
);
255 int flush_fd(int fd
);
257 int fopen_temporary(const char *path
, FILE **_f
, char **_temp_path
);
259 ssize_t
loop_read(int fd
, void *buf
, size_t nbytes
, bool do_poll
);
260 int loop_read_exact(int fd
, void *buf
, size_t nbytes
, bool do_poll
);
261 int loop_write(int fd
, const void *buf
, size_t nbytes
, bool do_poll
);
263 bool is_device_path(const char *path
);
265 int dir_is_empty(const char *path
);
266 char* dirname_malloc(const char *path
);
268 static inline int dir_is_populated(const char *path
) {
270 r
= dir_is_empty(path
);
276 char* lookup_uid(uid_t uid
);
277 char* getlogname_malloc(void);
278 char* getusername_malloc(void);
280 int chmod_and_chown(const char *path
, mode_t mode
, uid_t uid
, gid_t gid
);
281 int fchmod_and_fchown(int fd
, mode_t mode
, uid_t uid
, gid_t gid
);
283 typedef long statfs_f_type_t
;
285 bool is_fs_type(const struct statfs
*s
, statfs_f_type_t magic_value
) _pure_
;
286 int fd_check_fstype(int fd
, statfs_f_type_t magic_value
);
287 int path_check_fstype(const char *path
, statfs_f_type_t magic_value
);
289 bool is_temporary_fs(const struct statfs
*s
) _pure_
;
290 int fd_is_temporary_fs(int fd
);
292 int pipe_eof(int fd
);
294 #define xsprintf(buf, fmt, ...) \
295 assert_message_se((size_t) snprintf(buf, ELEMENTSOF(buf), fmt, __VA_ARGS__) < ELEMENTSOF(buf), \
296 "xsprintf: " #buf "[] must be big enough")
298 int files_same(const char *filea
, const char *fileb
);
300 int running_in_chroot(void);
302 int touch_file(const char *path
, bool parents
, usec_t stamp
, uid_t uid
, gid_t gid
, mode_t mode
);
303 int touch(const char *path
);
305 noreturn
void freeze(void);
307 bool null_or_empty(struct stat
*st
) _pure_
;
308 int null_or_empty_path(const char *fn
);
309 int null_or_empty_fd(int fd
);
311 DIR *xopendirat(int dirfd
, const char *name
, int flags
);
313 char *fstab_node_to_udev_node(const char *p
);
315 void execute_directories(const char* const* directories
, usec_t timeout
, char *argv
[]);
317 bool plymouth_running(void);
319 int symlink_idempotent(const char *from
, const char *to
);
321 int symlink_atomic(const char *from
, const char *to
);
322 int mknod_atomic(const char *path
, mode_t mode
, dev_t dev
);
323 int mkfifo_atomic(const char *path
, mode_t mode
);
325 int fchmod_umask(int fd
, mode_t mode
);
327 bool display_is_local(const char *display
) _pure_
;
328 int socket_from_display(const char *display
, char **path
);
330 int get_user_creds(const char **username
, uid_t
*uid
, gid_t
*gid
, const char **home
, const char **shell
);
331 int get_group_creds(const char **groupname
, gid_t
*gid
);
333 int in_gid(gid_t gid
);
334 int in_group(const char *name
);
336 char* uid_to_name(uid_t uid
);
337 char* gid_to_name(gid_t gid
);
339 int glob_exists(const char *path
);
340 int glob_extend(char ***strv
, const char *path
);
342 int dirent_ensure_type(DIR *d
, struct dirent
*de
);
344 int get_files_in_directory(const char *path
, char ***list
);
346 bool is_main_thread(void);
348 int block_get_whole_disk(dev_t d
, dev_t
*ret
);
350 #define NULSTR_FOREACH(i, l) \
351 for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)
353 #define NULSTR_FOREACH_PAIR(i, j, l) \
354 for ((i) = (l), (j) = strchr((i), 0)+1; (i) && *(i); (i) = strchr((j), 0)+1, (j) = *(i) ? strchr((i), 0)+1 : (i))
356 int ioprio_class_to_string_alloc(int i
, char **s
);
357 int ioprio_class_from_string(const char *s
);
359 const char *sigchld_code_to_string(int i
) _const_
;
360 int sigchld_code_from_string(const char *s
) _pure_
;
362 int log_facility_unshifted_to_string_alloc(int i
, char **s
);
363 int log_facility_unshifted_from_string(const char *s
);
364 bool log_facility_unshifted_is_valid(int faciliy
);
366 int log_level_to_string_alloc(int i
, char **s
);
367 int log_level_from_string(const char *s
);
368 bool log_level_is_valid(int level
);
370 int sched_policy_to_string_alloc(int i
, char **s
);
371 int sched_policy_from_string(const char *s
);
373 const char *rlimit_to_string(int i
) _const_
;
374 int rlimit_from_string(const char *s
) _pure_
;
376 int ip_tos_to_string_alloc(int i
, char **s
);
377 int ip_tos_from_string(const char *s
);
379 extern int saved_argc
;
380 extern char **saved_argv
;
382 bool kexec_loaded(void);
384 int prot_from_flags(int flags
) _const_
;
386 char *format_bytes(char *buf
, size_t l
, uint64_t t
);
388 int fd_wait_for_event(int fd
, int event
, usec_t timeout
);
390 void* memdup(const void *p
, size_t l
) _alloc_(2);
392 int fd_inc_sndbuf(int fd
, size_t n
);
393 int fd_inc_rcvbuf(int fd
, size_t n
);
395 int fork_agent(pid_t
*pid
, const int except
[], unsigned n_except
, const char *path
, ...);
397 int setrlimit_closest(int resource
, const struct rlimit
*rlim
);
399 bool http_url_is_valid(const char *url
) _pure_
;
400 bool documentation_url_is_valid(const char *url
) _pure_
;
402 bool http_etag_is_valid(const char *etag
);
404 bool in_initrd(void);
406 int get_home_dir(char **ret
);
407 int get_shell(char **_ret
);
409 static inline void freep(void *p
) {
413 static inline void closep(int *fd
) {
417 static inline void umaskp(mode_t
*u
) {
421 static inline void close_pairp(int (*p
)[2]) {
425 static inline void fclosep(FILE **f
) {
429 DEFINE_TRIVIAL_CLEANUP_FUNC(FILE*, pclose
);
430 DEFINE_TRIVIAL_CLEANUP_FUNC(DIR*, closedir
);
431 DEFINE_TRIVIAL_CLEANUP_FUNC(FILE*, endmntent
);
433 #define _cleanup_free_ _cleanup_(freep)
434 #define _cleanup_close_ _cleanup_(closep)
435 #define _cleanup_umask_ _cleanup_(umaskp)
436 #define _cleanup_globfree_ _cleanup_(globfree)
437 #define _cleanup_fclose_ _cleanup_(fclosep)
438 #define _cleanup_pclose_ _cleanup_(pclosep)
439 #define _cleanup_closedir_ _cleanup_(closedirp)
440 #define _cleanup_endmntent_ _cleanup_(endmntentp)
441 #define _cleanup_close_pair_ _cleanup_(close_pairp)
443 _malloc_
_alloc_(1, 2) static inline void *malloc_multiply(size_t a
, size_t b
) {
444 if (_unlikely_(b
!= 0 && a
> ((size_t) -1) / b
))
447 return malloc(a
* b
);
450 _alloc_(2, 3) static inline void *realloc_multiply(void *p
, size_t a
, size_t b
) {
451 if (_unlikely_(b
!= 0 && a
> ((size_t) -1) / b
))
454 return realloc(p
, a
* b
);
457 _alloc_(2, 3) static inline void *memdup_multiply(const void *p
, size_t a
, size_t b
) {
458 if (_unlikely_(b
!= 0 && a
> ((size_t) -1) / b
))
461 return memdup(p
, a
* b
);
464 bool filename_is_valid(const char *p
) _pure_
;
465 bool path_is_safe(const char *p
) _pure_
;
466 bool string_is_safe(const char *p
) _pure_
;
469 * Check if a string contains any glob patterns.
471 _pure_
static inline bool string_is_glob(const char *p
) {
472 return !!strpbrk(p
, GLOB_CHARS
);
475 void *xbsearch_r(const void *key
, const void *base
, size_t nmemb
, size_t size
,
476 int (*compar
) (const void *, const void *, void *),
479 #define _(String) gettext (String)
480 #define N_(String) String
481 void init_gettext(void);
482 bool is_locale_utf8(void);
484 typedef enum DrawSpecialChar
{
489 DRAW_TRIANGULAR_BULLET
,
493 _DRAW_SPECIAL_CHAR_MAX
496 const char *draw_special_char(DrawSpecialChar ch
);
498 int on_ac_power(void);
500 int search_and_fopen(const char *path
, const char *mode
, const char *root
, const char **search
, FILE **_f
);
501 int search_and_fopen_nulstr(const char *path
, const char *mode
, const char *root
, const char *search
, FILE **_f
);
503 #define FOREACH_LINE(line, f, on_error) \
505 if (!fgets(line, sizeof(line), f)) { \
512 #define FOREACH_DIRENT(de, d, on_error) \
513 for (errno = 0, de = readdir(d);; errno = 0, de = readdir(d)) \
519 } else if (hidden_file((de)->d_name)) \
523 #define FOREACH_DIRENT_ALL(de, d, on_error) \
524 for (errno = 0, de = readdir(d);; errno = 0, de = readdir(d)) \
532 static inline void *mempset(void *s
, int c
, size_t n
) {
534 return (uint8_t*)s
+ n
;
537 char *hexmem(const void *p
, size_t l
);
538 int unhexmem(const char *p
, size_t l
, void **mem
, size_t *len
);
540 char *base32hexmem(const void *p
, size_t l
, bool padding
);
541 int unbase32hexmem(const char *p
, size_t l
, bool padding
, void **mem
, size_t *len
);
543 char *base64mem(const void *p
, size_t l
);
544 int unbase64mem(const char *p
, size_t l
, void **mem
, size_t *len
);
546 void* greedy_realloc(void **p
, size_t *allocated
, size_t need
, size_t size
);
547 void* greedy_realloc0(void **p
, size_t *allocated
, size_t need
, size_t size
);
548 #define GREEDY_REALLOC(array, allocated, need) \
549 greedy_realloc((void**) &(array), &(allocated), (need), sizeof((array)[0]))
551 #define GREEDY_REALLOC0(array, allocated, need) \
552 greedy_realloc0((void**) &(array), &(allocated), (need), sizeof((array)[0]))
554 static inline void _reset_errno_(int *saved_errno
) {
555 errno
= *saved_errno
;
558 #define PROTECT_ERRNO _cleanup_(_reset_errno_) __attribute__((unused)) int _saved_errno_ = errno
560 static inline int negative_errno(void) {
561 /* This helper should be used to shut up gcc if you know 'errno' is
562 * negative. Instead of "return -errno;", use "return negative_errno();"
563 * It will suppress bogus gcc warnings in case it assumes 'errno' might
564 * be 0 and thus the caller's error-handling might not be triggered. */
565 assert_return(errno
> 0, -EINVAL
);
569 struct _umask_struct_
{
574 static inline void _reset_umask_(struct _umask_struct_
*s
) {
578 #define RUN_WITH_UMASK(mask) \
579 for (_cleanup_(_reset_umask_) struct _umask_struct_ _saved_umask_ = { umask(mask), false }; \
580 !_saved_umask_.quit ; \
581 _saved_umask_.quit = true)
583 static inline unsigned u64log2(uint64_t n
) {
584 #if __SIZEOF_LONG_LONG__ == 8
585 return (n
> 1) ? (unsigned) __builtin_clzll(n
) ^ 63U : 0;
591 static inline unsigned u32ctz(uint32_t n
) {
592 #if __SIZEOF_INT__ == 4
593 return __builtin_ctz(n
);
599 static inline unsigned log2i(int x
) {
602 return __SIZEOF_INT__
* 8 - __builtin_clz(x
) - 1;
605 static inline unsigned log2u(unsigned x
) {
608 return sizeof(unsigned) * 8 - __builtin_clz(x
) - 1;
611 static inline unsigned log2u_round_up(unsigned x
) {
617 return log2u(x
- 1) + 1;
620 static inline bool logind_running(void) {
621 return access("/run/systemd/seats/", F_OK
) >= 0;
624 #define DECIMAL_STR_WIDTH(x) \
626 typeof(x) _x_ = (x); \
633 int unlink_noerrno(const char *path
);
639 _new_ = alloca(_len_); \
640 (void *) memset(_new_, 0, _len_); \
643 /* It's not clear what alignment glibc/gcc alloca() guarantee, hence provide a guaranteed safe version */
644 #define alloca_align(size, align) \
647 size_t _mask_ = (align) - 1; \
648 _ptr_ = alloca((size) + _mask_); \
649 (void*)(((uintptr_t)_ptr_ + _mask_) & ~_mask_); \
652 #define alloca0_align(size, align) \
655 size_t _size_ = (size); \
656 _new_ = alloca_align(_size_, (align)); \
657 (void*)memset(_new_, 0, _size_); \
660 bool id128_is_valid(const char *s
) _pure_
;
662 int shall_restore_state(void);
665 * Normal qsort requires base to be nonnull. Here were require
666 * that only if nmemb > 0.
668 static inline void qsort_safe(void *base
, size_t nmemb
, size_t size
, comparison_fn_t compar
) {
673 qsort(base
, nmemb
, size
, compar
);
676 int proc_cmdline(char **ret
);
677 int parse_proc_cmdline(int (*parse_word
)(const char *key
, const char *value
));
678 int get_proc_cmdline_key(const char *parameter
, char **value
);
680 int container_get_leader(const char *machine
, pid_t
*pid
);
682 int namespace_open(pid_t pid
, int *pidns_fd
, int *mntns_fd
, int *netns_fd
, int *userns_fd
, int *root_fd
);
683 int namespace_enter(int pidns_fd
, int mntns_fd
, int netns_fd
, int userns_fd
, int root_fd
);
685 int getpeercred(int fd
, struct ucred
*ucred
);
686 int getpeersec(int fd
, char **ret
);
688 int writev_safe(int fd
, const struct iovec
*w
, int j
);
690 int mkostemp_safe(char *pattern
, int flags
);
691 int open_tmpfile(const char *path
, int flags
);
693 int fd_warn_permissions(const char *path
, int fd
);
695 #ifndef PERSONALITY_INVALID
696 /* personality(7) documents that 0xffffffffUL is used for querying the
697 * current personality, hence let's use that here as error
699 #define PERSONALITY_INVALID 0xffffffffLU
702 unsigned long personality_from_string(const char *p
);
703 const char *personality_to_string(unsigned long);
705 uint64_t physical_memory(void);
707 void hexdump(FILE *f
, const void *p
, size_t s
);
709 union file_handle_union
{
710 struct file_handle handle
;
711 char padding
[sizeof(struct file_handle
) + MAX_HANDLE_SZ
];
713 #define FILE_HANDLE_INIT { .handle.handle_bytes = MAX_HANDLE_SZ }
715 int update_reboot_param_file(const char *param
);
717 int umount_recursive(const char *target
, int flags
);
719 int bind_remount_recursive(const char *prefix
, bool ro
);
721 int fflush_and_check(FILE *f
);
723 int tempfn_xxxxxx(const char *p
, const char *extra
, char **ret
);
724 int tempfn_random(const char *p
, const char *extra
, char **ret
);
725 int tempfn_random_child(const char *p
, const char *extra
, char **ret
);
727 int take_password_lock(const char *root
);
729 int is_symlink(const char *path
);
730 int is_dir(const char *path
, bool follow
);
731 int is_device_node(const char *path
);
733 #define INOTIFY_EVENT_MAX (sizeof(struct inotify_event) + NAME_MAX + 1)
735 #define FOREACH_INOTIFY_EVENT(e, buffer, sz) \
736 for ((e) = &buffer.ev; \
737 (uint8_t*) (e) < (uint8_t*) (buffer.raw) + (sz); \
738 (e) = (struct inotify_event*) ((uint8_t*) (e) + sizeof(struct inotify_event) + (e)->len))
740 union inotify_event_buffer
{
741 struct inotify_event ev
;
742 uint8_t raw
[INOTIFY_EVENT_MAX
];
745 #define laccess(path, mode) faccessat(AT_FDCWD, (path), (mode), AT_SYMLINK_NOFOLLOW)
747 ssize_t
fgetxattrat_fake(int dirfd
, const char *filename
, const char *attribute
, void *value
, size_t size
, int flags
);
749 int fd_setcrtime(int fd
, usec_t usec
);
750 int fd_getcrtime(int fd
, usec_t
*usec
);
751 int path_getcrtime(const char *p
, usec_t
*usec
);
752 int fd_getcrtime_at(int dirfd
, const char *name
, usec_t
*usec
, int flags
);
754 int same_fd(int a
, int b
);
756 int chattr_fd(int fd
, unsigned value
, unsigned mask
);
757 int chattr_path(const char *p
, unsigned value
, unsigned mask
);
759 int read_attr_fd(int fd
, unsigned *ret
);
760 int read_attr_path(const char *p
, unsigned *ret
);
762 #define RLIMIT_MAKE_CONST(lim) ((struct rlimit) { lim, lim })
764 ssize_t
sparse_write(int fd
, const void *p
, size_t sz
, size_t run_length
);
766 void sigkill_wait(pid_t
*pid
);
767 #define _cleanup_sigkill_wait_ _cleanup_(sigkill_wait)
769 int syslog_parse_priority(const char **p
, int *priority
, bool with_facility
);
771 void cmsg_close_all(struct msghdr
*mh
);
773 int rename_noreplace(int olddirfd
, const char *oldpath
, int newdirfd
, const char *newpath
);
775 int parse_mode(const char *s
, mode_t
*ret
);
777 int mount_move_root(const char *path
);
779 int reset_uid_gid(void);
781 int getxattr_malloc(const char *path
, const char *name
, char **value
, bool allow_symlink
);
782 int fgetxattr_malloc(int fd
, const char *name
, char **value
);
784 int send_one_fd(int transport_fd
, int fd
, int flags
);
785 int receive_one_fd(int transport_fd
, int flags
);
787 void nop_signal_handler(int sig
);
791 bool fdname_is_valid(const char *s
);
793 bool oom_score_adjust_is_valid(int oa
);