[thirdparty/systemd.git] / src / basic / path-util.h

/* SPDX-License-Identifier: LGPL-2.1+ */
#pragma once

/***
  This file is part of systemd.

  Copyright 2010-2012 Lennart Poettering
***/

#include <alloca.h>
#include <stdbool.h>
#include <stddef.h>

#include "macro.h"
#include "string-util.h"
#include "time-util.h"

#if HAVE_SPLIT_BIN
#  define PATH_SBIN_BIN(x) x "sbin:" x "bin"
#  define PATH0_SBIN_BIN(x) x "sbin\0" x "bin"
#else
#  define PATH0_SBIN_BIN(x) x "bin"
#  define PATH_SBIN_BIN(x) x "bin"
#endif

#define DEFAULT_PATH_NORMAL PATH_SBIN_BIN("/usr/local/") ":" PATH_SBIN_BIN("/usr/")
#define DEFAULT_PATH0_NORMAL PATH0_SBIN_BIN("/usr/local/") "\0" PATH0_SBIN_BIN("/usr/")
#define DEFAULT_PATH_SPLIT_USR DEFAULT_PATH_NORMAL ":" PATH_SBIN_BIN("/")
#define DEFAULT_PATH0_SPLIT_USR DEFAULT_PATH0_NORMAL "\0" PATH0_SBIN_BIN("/")

#if HAVE_SPLIT_USR
#  define DEFAULT_PATH DEFAULT_PATH_SPLIT_USR
#  define DEFAULT_PATH_NULSTR DEFAULT_PATH0_SPLIT_USR
#else
#  define DEFAULT_PATH DEFAULT_PATH_NORMAL
#  define DEFAULT_PATH_NULSTR DEFAULT_PATH0_NORMAL
#endif

bool is_path(const char *p) _pure_;
int path_split_and_make_absolute(const char *p, char ***ret);
bool path_is_absolute(const char *p) _pure_;
char* path_make_absolute(const char *p, const char *prefix);
int safe_getcwd(char **ret);
int path_make_absolute_cwd(const char *p, char **ret);
int path_make_relative(const char *from_dir, const char *to_path, char **_r);
char* path_kill_slashes(char *path);
char* path_startswith(const char *path, const char *prefix) _pure_;
int path_compare(const char *a, const char *b) _pure_;
bool path_equal(const char *a, const char *b) _pure_;
bool path_equal_or_files_same(const char *a, const char *b, int flags);
char* path_join(const char *root, const char *path, const char *rest);

static inline bool path_equal_ptr(const char *a, const char *b) {
        return !!a == !!b && (!a || path_equal(a, b));
}

/* Note: the search terminates on the first NULL item. */
#define PATH_IN_SET(p, ...)                                     \
        ({                                                      \
                char **s;                                       \
                bool _found = false;                            \
                STRV_FOREACH(s, STRV_MAKE(__VA_ARGS__))         \
                        if (path_equal(p, *s)) {                \
                               _found = true;                   \
                               break;                           \
                        }                                       \
                _found;                                         \
        })

#define PATH_STARTSWITH_SET(p, ...)                             \
        ({                                                      \
                char **s;                                       \
                bool _found = false;                            \
                STRV_FOREACH(s, STRV_MAKE(__VA_ARGS__))         \
                        if (path_startswith(p, *s)) {           \
                               _found = true;                   \
                               break;                           \
                        }                                       \
                _found;                                         \
        })

int path_strv_make_absolute_cwd(char **l);
char** path_strv_resolve(char **l, const char *root);
char** path_strv_resolve_uniq(char **l, const char *root);

int find_binary(const char *name, char **filename);

bool paths_check_timestamp(const char* const* paths, usec_t *paths_ts_usec, bool update);

int fsck_exists(const char *fstype);
int mkfs_exists(const char *fstype);

/* Iterates through the path prefixes of the specified path, going up
 * the tree, to root. Also returns "" (and not "/"!) for the root
 * directory. Excludes the specified directory itself */
#define PATH_FOREACH_PREFIX(prefix, path) \
        for (char *_slash = ({ path_kill_slashes(strcpy(prefix, path)); streq(prefix, "/") ? NULL : strrchr(prefix, '/'); }); _slash && ((*_slash = 0), true); _slash = strrchr((prefix), '/'))

/* Same as PATH_FOREACH_PREFIX but also includes the specified path itself */
#define PATH_FOREACH_PREFIX_MORE(prefix, path) \
        for (char *_slash = ({ path_kill_slashes(strcpy(prefix, path)); if (streq(prefix, "/")) prefix[0] = 0; strrchr(prefix, 0); }); _slash && ((*_slash = 0), true); _slash = strrchr((prefix), '/'))

char *prefix_root(const char *root, const char *path);

/* Similar to prefix_root(), but returns an alloca() buffer, or
 * possibly a const pointer into the path parameter */
#define prefix_roota(root, path)                                        \
        ({                                                              \
                const char* _path = (path), *_root = (root), *_ret;     \
                char *_p, *_n;                                          \
                size_t _l;                                              \
                while (_path[0] == '/' && _path[1] == '/')              \
                        _path ++;                                       \
                if (isempty(_root) || path_equal(_root, "/"))           \
                        _ret = _path;                                   \
                else {                                                  \
                        _l = strlen(_root) + 1 + strlen(_path) + 1;     \
                        _n = alloca(_l);                                \
                        _p = stpcpy(_n, _root);                         \
                        while (_p > _n && _p[-1] == '/')                \
                                _p--;                                   \
                        if (_path[0] != '/')                            \
                                *(_p++) = '/';                          \
                        strcpy(_p, _path);                              \
                        _ret = _n;                                      \
                }                                                       \
                _ret;                                                   \
        })

int parse_path_argument_and_warn(const char *path, bool suppress_root, char **arg);

char* dirname_malloc(const char *path);
const char *last_path_component(const char *path);

bool filename_is_valid(const char *p) _pure_;
bool path_is_normalized(const char *p) _pure_;

char *file_in_same_dir(const char *path, const char *filename);

bool hidden_or_backup_file(const char *filename) _pure_;

bool is_device_path(const char *path);
bool is_deviceallow_pattern(const char *path);

int systemd_installation_has_version(const char *root, unsigned minimal_version);

bool dot_or_dot_dot(const char *path);

static inline const char *skip_dev_prefix(const char *p) {
        const char *e;

        /* Drop any /dev prefix if there is any */

        e = path_startswith(p, "/dev/");

        return e ?: p;
}
Commit	Line	Data
	1	/* SPDX-License-Identifier: LGPL-2.1+ */
	2	#pragma once
	3
	4	/***
	5	This file is part of systemd.
	6
	7	Copyright 2010-2012 Lennart Poettering
	8	***/
	9
	10	#include <alloca.h>
	11	#include <stdbool.h>
	12	#include <stddef.h>
	13
	14	#include "macro.h"
	15	#include "string-util.h"
	16	#include "time-util.h"
	17
	18	#if HAVE_SPLIT_BIN
	19	# define PATH_SBIN_BIN(x) x "sbin:" x "bin"
	20	# define PATH0_SBIN_BIN(x) x "sbin\0" x "bin"
	21	#else
	22	# define PATH0_SBIN_BIN(x) x "bin"
	23	# define PATH_SBIN_BIN(x) x "bin"
	24	#endif
	25
	26	#define DEFAULT_PATH_NORMAL PATH_SBIN_BIN("/usr/local/") ":" PATH_SBIN_BIN("/usr/")
	27	#define DEFAULT_PATH0_NORMAL PATH0_SBIN_BIN("/usr/local/") "\0" PATH0_SBIN_BIN("/usr/")
	28	#define DEFAULT_PATH_SPLIT_USR DEFAULT_PATH_NORMAL ":" PATH_SBIN_BIN("/")
	29	#define DEFAULT_PATH0_SPLIT_USR DEFAULT_PATH0_NORMAL "\0" PATH0_SBIN_BIN("/")
	30
	31	#if HAVE_SPLIT_USR
	32	# define DEFAULT_PATH DEFAULT_PATH_SPLIT_USR
	33	# define DEFAULT_PATH_NULSTR DEFAULT_PATH0_SPLIT_USR
	34	#else
	35	# define DEFAULT_PATH DEFAULT_PATH_NORMAL
	36	# define DEFAULT_PATH_NULSTR DEFAULT_PATH0_NORMAL
	37	#endif
	38
	39	bool is_path(const char *p) _pure_;
	40	int path_split_and_make_absolute(const char p, char **ret);
	41	bool path_is_absolute(const char *p) _pure_;
	42	char* path_make_absolute(const char p, const char prefix);
	43	int safe_getcwd(char **ret);
	44	int path_make_absolute_cwd(const char p, char *ret);
	45	int path_make_relative(const char from_dir, const char to_path, char **_r);
	46	char* path_kill_slashes(char *path);
	47	char* path_startswith(const char path, const char prefix) _pure_;
	48	int path_compare(const char a, const char b) _pure_;
	49	bool path_equal(const char a, const char b) _pure_;
	50	bool path_equal_or_files_same(const char a, const char b, int flags);
	51	char* path_join(const char root, const char path, const char *rest);
	52
	53	static inline bool path_equal_ptr(const char a, const char b) {
	54	return !!a == !!b && (!a \|\| path_equal(a, b));
	55	}
	56
	57	/* Note: the search terminates on the first NULL item. */
	58	#define PATH_IN_SET(p, ...) \
	59	({ \
	60	char **s; \
	61	bool _found = false; \
	62	STRV_FOREACH(s, STRV_MAKE(__VA_ARGS__)) \
	63	if (path_equal(p, *s)) { \
	64	_found = true; \
	65	break; \
	66	} \
	67	_found; \
	68	})
	69
	70	#define PATH_STARTSWITH_SET(p, ...) \
	71	({ \
	72	char **s; \
	73	bool _found = false; \
	74	STRV_FOREACH(s, STRV_MAKE(__VA_ARGS__)) \
	75	if (path_startswith(p, *s)) { \
	76	_found = true; \
	77	break; \
	78	} \
	79	_found; \
	80	})
	81
	82	int path_strv_make_absolute_cwd(char **l);
	83	char path_strv_resolve(char l, const char *root);
	84	char path_strv_resolve_uniq(char l, const char *root);
	85
	86	int find_binary(const char name, char *filename);
	87
	88	bool paths_check_timestamp(const char* const* paths, usec_t *paths_ts_usec, bool update);
	89
	90	int fsck_exists(const char *fstype);
	91	int mkfs_exists(const char *fstype);
	92
	93	/* Iterates through the path prefixes of the specified path, going up
	94	* the tree, to root. Also returns "" (and not "/"!) for the root
	95	* directory. Excludes the specified directory itself */
	96	#define PATH_FOREACH_PREFIX(prefix, path) \
	97	for (char _slash = ({ path_kill_slashes(strcpy(prefix, path)); streq(prefix, "/") ? NULL : strrchr(prefix, '/'); }); _slash && ((_slash = 0), true); _slash = strrchr((prefix), '/'))
	98
	99	/* Same as PATH_FOREACH_PREFIX but also includes the specified path itself */
	100	#define PATH_FOREACH_PREFIX_MORE(prefix, path) \
	101	for (char _slash = ({ path_kill_slashes(strcpy(prefix, path)); if (streq(prefix, "/")) prefix[0] = 0; strrchr(prefix, 0); }); _slash && ((_slash = 0), true); _slash = strrchr((prefix), '/'))
	102
	103	char prefix_root(const char root, const char *path);
	104
	105	/* Similar to prefix_root(), but returns an alloca() buffer, or
	106	* possibly a const pointer into the path parameter */
	107	#define prefix_roota(root, path) \
	108	({ \
	109	const char* _path = (path), _root = (root), _ret; \
	110	char _p, _n; \
	111	size_t _l; \
	112	while (_path[0] == '/' && _path[1] == '/') \
	113	_path ++; \
	114	if (isempty(_root) \|\| path_equal(_root, "/")) \
	115	_ret = _path; \
	116	else { \
	117	_l = strlen(_root) + 1 + strlen(_path) + 1; \
	118	_n = alloca(_l); \
	119	_p = stpcpy(_n, _root); \
	120	while (_p > _n && _p[-1] == '/') \
	121	_p--; \
	122	if (_path[0] != '/') \
	123	*(_p++) = '/'; \
	124	strcpy(_p, _path); \
	125	_ret = _n; \
	126	} \
	127	_ret; \
	128	})
	129
	130	int parse_path_argument_and_warn(const char path, bool suppress_root, char *arg);
	131
	132	char* dirname_malloc(const char *path);
	133	const char last_path_component(const char path);
	134
	135	bool filename_is_valid(const char *p) _pure_;
	136	bool path_is_normalized(const char *p) _pure_;
	137
	138	char file_in_same_dir(const char path, const char *filename);
	139
	140	bool hidden_or_backup_file(const char *filename) _pure_;
	141
	142	bool is_device_path(const char *path);
	143	bool is_deviceallow_pattern(const char *path);
	144
	145	int systemd_installation_has_version(const char *root, unsigned minimal_version);
	146
	147	bool dot_or_dot_dot(const char *path);
	148
	149	static inline const char skip_dev_prefix(const char p) {
	150	const char *e;
	151
	152	/* Drop any /dev prefix if there is any */
	153
	154	e = path_startswith(p, "/dev/");
	155
	156	return e ?: p;
	157	}