Line data    Source code

       1             : /* SPDX-License-Identifier: LGPL-2.1+ */
       2             : #pragma once
       3             : 
       4             : #include <fcntl.h>
       5             : #include <stdbool.h>
       6             : #include <stddef.h>
       7             : #include <sys/stat.h>
       8             : #include <sys/statfs.h>
       9             : #include <sys/types.h>
      10             : #include <sys/vfs.h>
      11             : 
      12             : #include "macro.h"
      13             : 
      14             : int is_symlink(const char *path);
      15             : int is_dir(const char *path, bool follow);
      16             : int is_dir_fd(int fd);
      17             : int is_device_node(const char *path);
      18             : 
      19             : int dir_is_empty_at(int dir_fd, const char *path);
      20          20 : static inline int dir_is_empty(const char *path) {
      21          20 :         return dir_is_empty_at(AT_FDCWD, path);
      22             : }
      23             : 
      24             : static inline int dir_is_populated(const char *path) {
      25             :         int r;
      26             :         r = dir_is_empty(path);
      27             :         if (r < 0)
      28             :                 return r;
      29             :         return !r;
      30             : }
      31             : 
      32             : bool null_or_empty(struct stat *st) _pure_;
      33             : int null_or_empty_path(const char *fn);
      34             : int null_or_empty_fd(int fd);
      35             : 
      36             : int path_is_read_only_fs(const char *path);
      37             : 
      38             : int files_same(const char *filea, const char *fileb, int flags);
      39             : 
      40             : /* The .f_type field of struct statfs is really weird defined on
      41             :  * different archs. Let's give its type a name. */
      42             : typedef typeof(((struct statfs*)NULL)->f_type) statfs_f_type_t;
      43             : 
      44             : bool is_fs_type(const struct statfs *s, statfs_f_type_t magic_value) _pure_;
      45             : int fd_is_fs_type(int fd, statfs_f_type_t magic_value);
      46             : int path_is_fs_type(const char *path, statfs_f_type_t magic_value);
      47             : 
      48             : bool is_temporary_fs(const struct statfs *s) _pure_;
      49             : bool is_network_fs(const struct statfs *s) _pure_;
      50             : 
      51             : int fd_is_temporary_fs(int fd);
      52             : int fd_is_network_fs(int fd);
      53             : 
      54             : int path_is_temporary_fs(const char *path);
      55             : 
      56             : /* Because statfs.t_type can be int on some architectures, we have to cast
      57             :  * the const magic to the type, otherwise the compiler warns about
      58             :  * signed/unsigned comparison, because the magic can be 32 bit unsigned.
      59             :  */
      60             : #define F_TYPE_EQUAL(a, b) (a == (typeof(a)) b)
      61             : 
      62             : int stat_verify_regular(const struct stat *st);
      63             : int fd_verify_regular(int fd);
      64             : 
      65             : int stat_verify_directory(const struct stat *st);
      66             : int fd_verify_directory(int fd);
      67             : 
      68             : /* glibc and the Linux kernel have different ideas about the major/minor size. These calls will check whether the
      69             :  * specified major is valid by the Linux kernel's standards, not by glibc's. Linux has 20bits of minor, and 12 bits of
      70             :  * major space. See MINORBITS in linux/kdev_t.h in the kernel sources. (If you wonder why we define _y here, instead of
      71             :  * comparing directly >= 0: it's to trick out -Wtype-limits, which would otherwise complain if the type is unsigned, as
      72             :  * such a test would be pointless in such a case.) */
      73             : 
      74             : #define DEVICE_MAJOR_VALID(x)                                           \
      75             :         ({                                                              \
      76             :                 typeof(x) _x = (x), _y = 0;                             \
      77             :                 _x >= _y && _x < (UINT32_C(1) << 12);                   \
      78             :                                                                         \
      79             :         })
      80             : 
      81             : #define DEVICE_MINOR_VALID(x)                                           \
      82             :         ({                                                              \
      83             :                 typeof(x) _x = (x), _y = 0;                             \
      84             :                 _x >= _y && _x < (UINT32_C(1) << 20);                   \
      85             :         })
      86             : 
      87             : int device_path_make_major_minor(mode_t mode, dev_t devno, char **ret);
      88             : int device_path_make_canonical(mode_t mode, dev_t devno, char **ret);
      89             : int device_path_parse_major_minor(const char *path, mode_t *ret_mode, dev_t *ret_devno);