/*
* ProFTPD - FTP server daemon
* Copyright (c) 1997, 1998 Public Flood Software
* Copyright (c) 1999, 2000 MacGyver aka Habeeb J. Dihu <macgyver@tos.net>
* Copyright (c) 2001-2024 The ProFTPD Project
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
*
* As a special exemption, Public Flood Software/MacGyver aka Habeeb J. Dihu
* and other respective copyright holders give permission to link this program
* with OpenSSL, and distribute the resulting executable, without including
* the source code for OpenSSL in the source distribution.
*/
/* ProFTPD virtual/modular filesystem support. */
#ifndef PR_FSIO_H
#define PR_FSIO_H
#include "conf.h"
#include "error.h"
#ifdef PR_USE_XATTR
# if defined(HAVE_SYS_EXTATTR_H)
# include <sys/extattr.h>
# elif defined(HAVE_SYS_XATTR_H)
# include <sys/xattr.h>
# if defined(HAVE_ATTR_XATTR_H)
# include <attr/xattr.h>
# endif /* HAVE_ATTR_XATTR_H */
# endif /* HAVE_SYS_XATTR_H */
#endif /* PR_USE_XATTR */
/* This is a Tru64-specific hack, to work around some macro funkiness
* in their /usr/include/sys/mount.h header.
*/
#ifdef OSF5
# undef fh_data
#endif
/* Operation codes */
#define FSIO_FILE_STAT 0x0000001
#define FSIO_FILE_LSTAT 0x0000002
#define FSIO_FILE_RENAME 0x0000004
#define FSIO_FILE_UNLINK 0x0000008
#define FSIO_FILE_OPEN 0x0000010
/* Was FSIO_FILE_CREAT, now unused */
#define FSIO_FILE_CLOSE 0x0000040
#define FSIO_FILE_READ 0x0000080
#define FSIO_FILE_WRITE 0x0000100
#define FSIO_FILE_LINK 0x0000200
#define FSIO_FILE_SYMLINK 0x0000400
#define FSIO_FILE_READLINK 0x0000800
#define FSIO_FILE_TRUNC 0x0001000
#define FSIO_FILE_CHMOD 0x0002000
#define FSIO_FILE_CHOWN 0x0004000
#define FSIO_FILE_ACCESS 0x0008000
#define FSIO_FILE_PREAD 0x0010000
#define FSIO_FILE_PWRITE 0x0020000
#define FSIO_FILE_UTIMES 0x0040000
#define FSIO_FILE_GETXATTR 0x0080000
#define FSIO_FILE_LGETXATTR 0x0100000
#define FSIO_FILE_LISTXATTR 0x0200000
#define FSIO_FILE_LLISTXATTR 0x0400000
#define FSIO_FILE_REMOVEXATTR 0x0800000
#define FSIO_FILE_LREMOVEXATTR 0x1000000
#define FSIO_FILE_SETXATTR 0x2000000
#define FSIO_FILE_LSETXATTR 0x4000000
#define FSIO_FILE_REALPATH 0x8000000
/* Macro that defines the most common file ops */
#define FSIO_FILE_COMMON (FSIO_FILE_OPEN|FSIO_FILE_READ|FSIO_FILE_WRITE|\
FSIO_FILE_CLOSE)
#define FSIO_DIR_CHROOT (1 << 16)
#define FSIO_DIR_CHDIR (1 << 17)
#define FSIO_DIR_OPENDIR (1 << 18)
#define FSIO_DIR_CLOSEDIR (1 << 19)
#define FSIO_DIR_READDIR (1 << 20)
#define FSIO_DIR_MKDIR (1 << 21)
#define FSIO_DIR_RMDIR (1 << 22)
/* Macro that defines directory operations */
#define FSIO_DIR_COMMON (FSIO_DIR_CHROOT|FSIO_DIR_CHDIR|\
FSIO_DIR_OPENDIR|FSIO_DIR_READDIR|\
FSIO_DIR_CLOSEDIR|FSIO_DIR_MKDIR|\
FSIO_DIR_RMDIR)
/* Default mode used when creating files */
#define PR_OPEN_MODE 0666
/* Modular filesystem object */
typedef struct fs_rec pr_fs_t;
typedef struct fh_rec pr_fh_t;
struct fs_rec {
/* These pointers will be effective once layered FS modules are
* supported
*/
pr_fs_t *fs_next, *fs_prev;
/* Descriptive tag for this FS object */
char *fs_name;
/* Original name for this FS object. When FS handlers are inherited,
* the name of the FS will be automatically updated to contain the
* combined names, which changes things.
*/
char *fs_original_name;
char *fs_path;
/* Slot for module-specific data */
void *fs_data;
/* Pool for this object's use */
struct pool_rec *fs_pool;
/* FS function pointers */
int (*stat)(pr_fs_t *, const char *, struct stat *);
int (*fstat)(pr_fh_t *, int, struct stat *);
int (*lstat)(pr_fs_t *, const char *, struct stat *);
int (*rename)(pr_fs_t *, const char *, const char *);
int (*unlink)(pr_fs_t *, const char *);
int (*open)(pr_fh_t *, const char *, int);
int (*close)(pr_fh_t *, int);
int (*read)(pr_fh_t *, int, char *, size_t);
ssize_t (*pread)(pr_fh_t *, int, void *, size_t, off_t);
int (*write)(pr_fh_t *, int, const char *, size_t);
ssize_t (*pwrite)(pr_fh_t *, int, const void *, size_t, off_t);
off_t (*lseek)(pr_fh_t *, int, off_t, int);
int (*link)(pr_fs_t *, const char *, const char *);
int (*readlink)(pr_fs_t *, const char *, char *, size_t);
int (*symlink)(pr_fs_t *, const char *, const char *);
int (*ftruncate)(pr_fh_t *, int, off_t);
int (*truncate)(pr_fs_t *, const char *, off_t);
int (*chmod)(pr_fs_t *, const char *, mode_t);
int (*fchmod)(pr_fh_t *, int, mode_t);
int (*chown)(pr_fs_t *, const char *, uid_t, gid_t);
int (*fchown)(pr_fh_t *, int, uid_t, gid_t);
int (*lchown)(pr_fs_t *, const char *, uid_t, gid_t);
int (*access)(pr_fs_t *, const char *, int, uid_t, gid_t, array_header *);
int (*faccess)(pr_fh_t *, int, uid_t, gid_t, array_header *);
int (*utimes)(pr_fs_t *, const char *, struct timeval *);
int (*futimes)(pr_fh_t *, int, struct timeval *);
int (*fsync)(pr_fh_t *, int);
const char *(*realpath)(pr_fs_t *, pool *p, const char *);
/* Extended attribute support */
ssize_t (*getxattr)(pool *, pr_fs_t *, const char *, const char *, void *,
size_t);
ssize_t (*lgetxattr)(pool *, pr_fs_t *, const char *, const char *, void *,
size_t);
ssize_t (*fgetxattr)(pool *, pr_fh_t *, int, const char *, void *, size_t);
int (*listxattr)(pool *, pr_fs_t *, const char *, array_header **);
int (*llistxattr)(pool *, pr_fs_t *, const char *, array_header **);
int (*flistxattr)(pool *, pr_fh_t *, int, array_header **);
int (*removexattr)(pool *, pr_fs_t *, const char *, const char *);
int (*lremovexattr)(pool *, pr_fs_t *, const char *, const char *);
int (*fremovexattr)(pool *, pr_fh_t *, int, const char *);
int (*setxattr)(pool *, pr_fs_t *, const char *, const char *, void *,
size_t, int);
int (*lsetxattr)(pool *, pr_fs_t *, const char *, const char *, void *,
size_t, int);
int (*fsetxattr)(pool *, pr_fh_t *, int, const char *, void *, size_t, int);
/* For actual operations on the directory (or subdirs)
* we cast the return from opendir to DIR* in src/fs.c, so
* modules can use their own data type
*/
int (*chdir)(pr_fs_t *, const char *);
int (*chroot)(pr_fs_t *, const char *);
void *(*opendir)(pr_fs_t *, const char *);
int (*closedir)(pr_fs_t *, void *);
struct dirent *(*readdir)(pr_fs_t *, void *);
int (*mkdir)(pr_fs_t *, const char *, mode_t);
int (*rmdir)(pr_fs_t *, const char *);
/* This flag determines whether this FS handler allows cross-FS hardlinks,
* either from this FS to another FS, or from another FS to this FS.
*
* If the flag is set to FALSE by the FS registrant, then a hardlink
* across FS handlers will fail, with errno set to EXDEV. The caller
* will then have to handle the EXDEV error appropriately.
*/
int allow_xdev_link;
/* This flag determines whether this FS handler allows cross-FS renames,
* either from this FS to another FS, or from another FS to this FS.
*
* If the flag is set to FALSE by the FS registrant, then a rename
* across FS handlers will fail, with errno set to EXDEV. The caller
* will then have to handle the EXDEV error appropriately.
*
* In the core engine, a RNFR/RNTO sequence which encounters an EXDEV
* error will cause a copy/delete of the file. This can be more IO
* intensive than expected, and lead to longer times for the RNTO
* command to complete.
*/
int allow_xdev_rename;
/* This flag determines whether the paths handled by this FS handler
* are standard, filesystem-based paths, and such use the standard
* path separator, glob semantics, etc.
*/
int non_std_path;
};
struct fh_rec {
/* Pool for this object's use */
pool *fh_pool;
int fh_fd;
char *fh_path;
/* Arbitrary data associated with this file. */
void *fh_data;
/* Pointer to the filesystem in which this file is located. */
pr_fs_t *fh_fs;
/* For buffer I/O on this file, should anything choose to use it. */
pr_buffer_t *fh_buf;
/* Hint of the optimal buffer size for IO on this file. */
size_t fh_iosz;
};
/* Maximum symlink count, for loop detection. */
#define PR_FSIO_MAX_LINK_COUNT 32
/* Macros for that code that needs to get into the internals of pr_fs_t.
* (These will help keep the internals as opaque as possible).
*/
#define PR_FH_FD(f) ((f)->fh_fd)
int pr_fsio_stat(const char *, struct stat *);
int pr_fsio_fstat(pr_fh_t *, struct stat *);
int pr_fsio_lstat(const char *, struct stat *);
int pr_fsio_readlink(const char *, char *, size_t);
int pr_fsio_chdir(const char *, int);
int pr_fsio_chdir_canon(const char *, int);
void *pr_fsio_opendir(const char *);
int pr_fsio_closedir(void *);
struct dirent *pr_fsio_readdir(void *);
int pr_fsio_mkdir(const char *, mode_t);
int pr_fsio_rmdir(const char *);
int pr_fsio_rename(const char *, const char *);
int pr_fsio_smkdir(pool *, const char *, mode_t, uid_t, gid_t);
int pr_fsio_unlink(const char *);
pr_fh_t *pr_fsio_open(const char *, int);
pr_fh_t *pr_fsio_open_canon(const char *, int);
int pr_fsio_close(pr_fh_t *);
int pr_fsio_read(pr_fh_t *, char *, size_t);
ssize_t pr_fsio_pread(pr_fh_t *, void *, size_t, off_t);
int pr_fsio_write(pr_fh_t *, const char *, size_t);
ssize_t pr_fsio_pwrite(pr_fh_t *, const void *, size_t, off_t);
int pr_fsio_link(const char *, const char *);
int pr_fsio_symlink(const char *, const char *);
int pr_fsio_ftruncate(pr_fh_t *, off_t);
int pr_fsio_truncate(const char *, off_t);
int pr_fsio_chmod(const char *, mode_t);
int pr_fsio_fchmod(pr_fh_t *, mode_t);
int pr_fsio_chown(const char *, uid_t, gid_t);
int pr_fsio_fchown(pr_fh_t *, uid_t, gid_t);
int pr_fsio_lchown(const char *, uid_t, gid_t);
int pr_fsio_chroot(const char *);
int pr_fsio_access(const char *, int, uid_t, gid_t, array_header *);
int pr_fsio_faccess(pr_fh_t *, int, uid_t, gid_t, array_header *);
int pr_fsio_utimes(const char *, struct timeval *);
int pr_fsio_utimes_with_root(const char *, struct timeval *);
int pr_fsio_futimes(pr_fh_t *, struct timeval *);
int pr_fsio_fsync(pr_fh_t *fh);
off_t pr_fsio_lseek(pr_fh_t *, off_t, int);
const char *pr_fsio_realpath(pool *p, const char *path);
/* Extended attribute support */
ssize_t pr_fsio_getxattr(pool *p, const char *, const char *, void *, size_t);
ssize_t pr_fsio_lgetxattr(pool *, const char *, const char *, void *, size_t);
ssize_t pr_fsio_fgetxattr(pool *, pr_fh_t *, const char *, void *, size_t);
int pr_fsio_listxattr(pool *, const char *, array_header **);
int pr_fsio_llistxattr(pool *, const char *, array_header **);
int pr_fsio_flistxattr(pool *, pr_fh_t *, array_header **);
int pr_fsio_removexattr(pool *, const char *, const char *);
int pr_fsio_lremovexattr(pool *, const char *, const char *);
int pr_fsio_fremovexattr(pool *, pr_fh_t *, const char *);
int pr_fsio_setxattr(pool *, const char *, const char *, void *, size_t, int);
int pr_fsio_lsetxattr(pool *, const char *, const char *, void *, size_t, int);
int pr_fsio_fsetxattr(pool *, pr_fh_t *, const char *, void *, size_t, int);
/* setxattr flags */
#define PR_FSIO_XATTR_FL_CREATE 0x001
#define PR_FSIO_XATTR_FL_REPLACE 0x002
/* Error-using variants of the FSIO API. */
int pr_fsio_chmod_with_error(pool *p, const char *path, mode_t mode,
pr_error_t **err);
int pr_fsio_chown_with_error(pool *p, const char *path, uid_t uid, gid_t gid,
pr_error_t **err);
int pr_fsio_chroot_with_error(pool *p, const char *path, pr_error_t **err);
int pr_fsio_close_with_error(pool *p, pr_fh_t *fh, pr_error_t **err);
int pr_fsio_fchmod_with_error(pool *p, pr_fh_t *fh, mode_t mode,
pr_error_t **err);
int pr_fsio_fchown_with_error(pool *p, pr_fh_t *fh, uid_t uid, gid_t gid,
pr_error_t **err);
int pr_fsio_lchown_with_error(pool *p, const char *path, uid_t uid, gid_t gid,
pr_error_t **err);
int pr_fsio_lstat_with_error(pool *p, const char *path, struct stat *st,
pr_error_t **err);
int pr_fsio_mkdir_with_error(pool *p, const char *path, mode_t mode,
pr_error_t **err);
pr_fh_t *pr_fsio_open_with_error(pool *p, const char *path, int flags,
pr_error_t **err);
int pr_fsio_read_with_error(pool *p, pr_fh_t *fh, char *buf, size_t sz,
pr_error_t **err);
int pr_fsio_rename_with_error(pool *p, const char *from, const char *to,
pr_error_t **err);
int pr_fsio_rmdir_with_error(pool *p, const char *path, pr_error_t **err);
int pr_fsio_stat_with_error(pool *p, const char *path, struct stat *st,
pr_error_t **err);
int pr_fsio_unlink_with_error(pool *p, const char *path, pr_error_t **err);
int pr_fsio_write_with_error(pool *p, pr_fh_t *fh, const char *buf, size_t sz,
pr_error_t **err);
/* Set a flag determining whether we guard against write operations in
* certain sensitive directories while we are chrooted, e.g. "Roaring Beast"
* style attacks.
*/
int pr_fsio_guard_chroot(int);
/* Set a flag determining whether to use mkdtemp(3) (if available) or not.
* Returns the previously-set value.
*/
int pr_fsio_set_use_mkdtemp(int);
/* Sets a bitmask of various FSIO API options. Returns the previously
* set options.
*/
unsigned long pr_fsio_set_options(unsigned long opts);
#define PR_FSIO_OPT_IGNORE_XATTR 0x00001
/* FS-related functions */
char *pr_fsio_getline(char *, size_t, pr_fh_t *, unsigned int *);
char *pr_fsio_getpipebuf(pool *, int, long *);
char *pr_fsio_gets(char *, size_t, pr_fh_t *);
int pr_fsio_puts(const char *, pr_fh_t *);
int pr_fsio_set_block(pr_fh_t *);
pr_fs_t *pr_register_fs(pool *, const char *, const char *);
pr_fs_t *pr_register_fs2(pool *, const char *, const char *, int);
#define PR_FSIO_REGISTER_FL_INHERIT_HANDLERS 0x00001
pr_fs_t *pr_create_fs(pool *, const char *);
pr_fs_t *pr_get_fs(const char *, int *);
int pr_insert_fs(pr_fs_t *, const char *);
pr_fs_t *pr_remove_fs(const char *);
pr_fs_t *pr_unmount_fs(const char *, const char *);
int pr_unregister_fs(const char *);
/* FS Statcache API */
void pr_fs_clear_cache(void);
int pr_fs_clear_cache2(const char *path);
/* Dump the current contents of the statcache via trace logging, to the
* "fs.statcache" trace channel.
*/
void pr_fs_statcache_dump(void);
/* Clears the entire statcache. */
void pr_fs_statcache_free(void);
/* Clears the entire statcache and re-creates the memory pool. */
void pr_fs_statcache_reset(void);
/* Tune the statcache policy: max number of items in the cache at any
* one time, the max age (in seconds) for items in the cache, and the policy
* flags.
*
* Note that setting a size of zero, OR setting a max age of zero, effectively
* disables the statcache.
*/
int pr_fs_statcache_set_policy(unsigned int size, unsigned int max_age,
unsigned int flags);
/* Copy a file from the given source path to the destination path. */
int pr_fs_copy_file(const char *src, const char *dst);
/* Similar to pr_fs_copy_file(), with the addition of an optional progress
* callback, invoked during the potentially long-running copy process.
*
* The callback, when present, will be invoked with the number of bytes
* just written to the destination file in that iteration.
*/
int pr_fs_copy_file2(const char *src, const char *dst, int flags,
void (*progress_cb)(int));
#define PR_FSIO_COPY_FILE_FL_NO_DELETE_ON_FAILURE 0x0001
int pr_fs_setcwd(const char *);
const char *pr_fs_getcwd(void);
const char *pr_fs_getvwd(void);
int pr_fs_dircat(char *, int, const char *, const char *);
int pr_fs_interpolate(const char *, char *, size_t);
int pr_fs_resolve_partial(const char *, char *, size_t, int);
int pr_fs_resolve_path(const char *, char *, size_t, int);
char *pr_fs_decode_path(pool *, const char *);
/* Similar to pr_fs_decode_path(), but allows callers to provide flags. These
* flags can be used, for example, to request that if there are errors during
* the decoding, the function NOT hide/mask them, as is done by default, but
* convey them to the caller for handling at a higher code layer.
*/
char *pr_fs_decode_path2(pool *, const char *, int);
#define FSIO_DECODE_FL_TELL_ERRORS 0x001
char *pr_fs_encode_path(pool *, const char *);
int pr_fs_use_encoding(int);
/* Split the given path into its individual path components. */
array_header *pr_fs_split_path(pool *p, const char *path);
/* Given an array of individual path components, join them into a single
* path. The count parameter indicates how many components in the array,
* starting from zero, to use.
*/
char *pr_fs_join_path(pool *p, array_header *components, size_t count);
int pr_fs_valid_path(const char *);
void pr_fs_virtual_path(const char *, char *, size_t);
void pr_fs_clean_path(const char *, char *, size_t);
int pr_fs_clean_path2(const char *, char *, size_t, int);
#define PR_FSIO_CLEAN_PATH_FL_MAKE_ABS_PATH 0x001
int pr_fs_glob(const char *, int, int (*errfunc)(const char *, int), glob_t *);
void pr_fs_globfree(glob_t *);
void pr_resolve_fs_map(void);
/* Close all but the main three fds. */
void pr_fs_close_extra_fds(void);
/* The main three fds (stdin, stdout, stderr) need to be protected, reserved
* for use. This function uses dup(2) to open new fds on the given fd
* until the new fd is not one of the big three.
*/
int pr_fs_get_usable_fd(int);
/* Similar to pr_fs_get_usable_fd(), except that it automatically closes the
* old (given) fd if a usable fd was found. Returns -1 (with errno set) if
* a usable fd could not be found.
*/
int pr_fs_get_usable_fd2(int *);
#if defined(HAVE_STATFS) || defined(HAVE_SYS_STATVFS_H) || \
defined(HAVE_SYS_VFS_H)
off_t pr_fs_getsize(char *);
#endif
/* Unlike pr_fs_getsize(), this function is always present, and is also
* capable of returning an error when there is a problem checking the
* filesystem stats.
*/
int pr_fs_getsize2(char *, off_t *);
/* Similar to pr_fs_getsize2(), except that this operates on an already-opened
* file descriptor, rather than a path.
*/
int pr_fs_fgetsize(int, off_t *);
/* Perform access(2)-like checks on the given struct stat. */
int pr_fs_have_access(struct stat *st, int mode, uid_t uid, gid_t gid,
array_header *suppl_gids);
/* Returns TRUE if the given path is on an NFS-mounted filesystem, FALSE
* if not on an NFS-mounted filesystem, and -1 if there was an error
* determining which (with errno set appropriately).
*/
int pr_fs_is_nfs(const char *path);
/* Provide advice/hints to the OS about what we are going to do with the
* given section of the opened file.
*/
void pr_fs_fadvise(int fd, off_t offset, off_t len, int advice);
#define PR_FS_FADVISE_NORMAL 10
#define PR_FS_FADVISE_RANDOM 11
#define PR_FS_FADVISE_SEQUENTIAL 12
#define PR_FS_FADVISE_WILLNEED 13
#define PR_FS_FADVISE_DONTNEED 14
#define PR_FS_FADVISE_NOREUSE 15
/* For internal use only. */
int init_fs(void);
#ifdef PR_USE_DEVEL
void pr_fs_dump(void (*)(const char *, ...));
#endif /* PR_USE_DEVEL */
#endif /* PR_FSIO_H */
Anons79 File Manager Version 1.0, Coded By Anons79
Email: [email protected]
Anons79 Mini Shell