[Git][reproducible-builds/disorderfs][master] 3 commits: Apply astyle with the default settings to disorderfs.cpp.

Chris Lamb gitlab at salsa.debian.org
Thu May 21 10:53:28 UTC 2020



Chris Lamb pushed to branch master at Reproducible Builds / disorderfs


Commits:
119c27ce by Chris Lamb at 2020-05-21T11:43:07+01:00
Apply astyle with the default settings to disorderfs.cpp.

- - - - -
89ab46e6 by Chris Lamb at 2020-05-21T11:50:36+01:00
Use "directory entries" over "dirents" in human-readable output/log messages.

- - - - -
b38eac90 by Chris Lamb at 2020-05-21T11:51:41+01:00
Release 0.5.10

- - - - -


1 changed file:

- disorderfs.cpp


Changes:

=====================================
disorderfs.cpp
=====================================
@@ -43,522 +43,524 @@ extern "C" {
 #include <sys/file.h>
 #include <stddef.h>
 
-#define DISORDERFS_VERSION "0.5.9"
+#define DISORDERFS_VERSION "0.5.10"
 
 namespace {
-	std::vector<std::string>	bare_arguments;
-	std::string			root;
-	struct Disorderfs_config {
-		// ATTENTION! Members of this struct MUST be ints, even the booleans, because
-		// that's what fuse_opt_parse expects.  Take heed or you will get memory corruption!
-		int			multi_user{0};
-		int			shuffle_dirents{0};
-		int			reverse_dirents{1};
-		int			sort_dirents{0};
-		int			pad_blocks{1};
-		int			share_locks{0};
-		int			quiet{0};
-	};
-	Disorderfs_config		config;
+std::vector<std::string>        bare_arguments;
+std::string                        root;
+struct Disorderfs_config {
+    // ATTENTION! Members of this struct MUST be ints, even the booleans, because
+    // that's what fuse_opt_parse expects.  Take heed or you will get memory corruption!
+    int                        multi_user{0};
+    int                        shuffle_dirents{0};
+    int                        reverse_dirents{1};
+    int                        sort_dirents{0};
+    int                        pad_blocks{1};
+    int                        share_locks{0};
+    int                        quiet{0};
+};
+Disorderfs_config                config;
 
-	void perror_and_die (const char* s)
-	{
-		std::perror(s);
-		std::abort();
-	}
+void perror_and_die (const char* s)
+{
+    std::perror(s);
+    std::abort();
+}
 
-	int wrap (int retval) { return retval == -1 ? -errno : 0; }
-	using Dirents = std::vector<std::pair<std::string, ino_t>>;
+int wrap (int retval) {
+    return retval == -1 ? -errno : 0;
+}
+using Dirents = std::vector<std::pair<std::string, ino_t>>;
 
-	// The libc versions of seteuid, etc. set the credentials for all threads.
-	// We need to set credentials for a single thread only, so call the syscalls directly.
-	int thread_seteuid (uid_t euid)
-	{
+// The libc versions of seteuid, etc. set the credentials for all threads.
+// We need to set credentials for a single thread only, so call the syscalls directly.
+int thread_seteuid (uid_t euid)
+{
 #ifdef SYS_setresuid32
-		return syscall(SYS_setresuid32, static_cast<uid_t>(-1), euid, static_cast<uid_t>(-1));
+    return syscall(SYS_setresuid32, static_cast<uid_t>(-1), euid, static_cast<uid_t>(-1));
 #else
-		return syscall(SYS_setresuid, static_cast<uid_t>(-1), euid, static_cast<uid_t>(-1));
+    return syscall(SYS_setresuid, static_cast<uid_t>(-1), euid, static_cast<uid_t>(-1));
 #endif
-	}
-	int thread_setegid (gid_t egid)
-	{
+}
+int thread_setegid (gid_t egid)
+{
 #ifdef SYS_setresgid32
-		return syscall(SYS_setresgid32, static_cast<gid_t>(-1), egid, static_cast<gid_t>(-1));
+    return syscall(SYS_setresgid32, static_cast<gid_t>(-1), egid, static_cast<gid_t>(-1));
 #else
-		return syscall(SYS_setresgid, static_cast<gid_t>(-1), egid, static_cast<gid_t>(-1));
+    return syscall(SYS_setresgid, static_cast<gid_t>(-1), egid, static_cast<gid_t>(-1));
 #endif
-	}
-	int thread_setgroups (size_t size, const gid_t* list)
-	{
+}
+int thread_setgroups (size_t size, const gid_t* list)
+{
 #ifdef SYS_setgroups32
-		return syscall(SYS_setgroups32, size, list);
+    return syscall(SYS_setgroups32, size, list);
 #else
-		return syscall(SYS_setgroups, size, list);
+    return syscall(SYS_setgroups, size, list);
 #endif
-	}
+}
 
-	std::vector<gid_t> get_fuse_groups ()
-	{
-		long				ngroups_max = sysconf(_SC_NGROUPS_MAX);
-		if (ngroups_max < 0) {
-			ngroups_max = 65536;
-		}
-		std::vector<gid_t>		groups(ngroups_max + 1);
-		int				ngroups = fuse_getgroups(groups.size(), groups.data());
-		if (ngroups < 0) {
-			std::perror("fuse_getgroups");
-			groups.clear();
-		} else if (static_cast<unsigned int>(ngroups) < groups.size()) {
-			groups.resize(ngroups);
-		}
-		return groups;
-	}
+std::vector<gid_t> get_fuse_groups ()
+{
+    long                                ngroups_max = sysconf(_SC_NGROUPS_MAX);
+    if (ngroups_max < 0) {
+        ngroups_max = 65536;
+    }
+    std::vector<gid_t>                groups(ngroups_max + 1);
+    int                                ngroups = fuse_getgroups(groups.size(), groups.data());
+    if (ngroups < 0) {
+        std::perror("fuse_getgroups");
+        groups.clear();
+    } else if (static_cast<unsigned int>(ngroups) < groups.size()) {
+        groups.resize(ngroups);
+    }
+    return groups;
+}
 
-	void drop_privileges ()
-	{
-		// These functions should not fail as long as disorderfs is running as root.
-		// If they do fail, things could be in a pretty inconsistent state, so just
-		// kill the program instead of trying to gracefully recover.
-		const std::vector<gid_t>	groups(get_fuse_groups());
-		if (thread_setgroups(groups.size(), groups.data()) == -1) {
-			perror_and_die("setgroups");
-		}
-		if (thread_setegid(fuse_get_context()->gid) == -1) {
-			perror_and_die("setegid");
-		}
-		if (thread_seteuid(fuse_get_context()->uid) == -1) {
-			perror_and_die("seteuid");
-		}
-	}
+void drop_privileges ()
+{
+    // These functions should not fail as long as disorderfs is running as root.
+    // If they do fail, things could be in a pretty inconsistent state, so just
+    // kill the program instead of trying to gracefully recover.
+    const std::vector<gid_t>        groups(get_fuse_groups());
+    if (thread_setgroups(groups.size(), groups.data()) == -1) {
+        perror_and_die("setgroups");
+    }
+    if (thread_setegid(fuse_get_context()->gid) == -1) {
+        perror_and_die("setegid");
+    }
+    if (thread_seteuid(fuse_get_context()->uid) == -1) {
+        perror_and_die("seteuid");
+    }
+}
 
-	void restore_privileges ()
-	{
-		// These functions should not fail as long as disorderfs is running as root.
-		// If they do fail, things could be in a pretty inconsistent state, so just
-		// kill the program instead of trying to gracefully recover.
-		const std::vector<gid_t>	groups;
-		if (thread_seteuid(0) == -1) {
-			perror_and_die("seteuid()");
-		}
-		if (thread_setegid(0) == -1) {
-			perror_and_die("setegid(0)");
-		}
-		if (thread_setgroups(groups.size(), groups.data()) == -1) {
-			perror_and_die("setgroups(0)");
-		}
-	}
+void restore_privileges ()
+{
+    // These functions should not fail as long as disorderfs is running as root.
+    // If they do fail, things could be in a pretty inconsistent state, so just
+    // kill the program instead of trying to gracefully recover.
+    const std::vector<gid_t>        groups;
+    if (thread_seteuid(0) == -1) {
+        perror_and_die("seteuid()");
+    }
+    if (thread_setegid(0) == -1) {
+        perror_and_die("setegid(0)");
+    }
+    if (thread_setgroups(groups.size(), groups.data()) == -1) {
+        perror_and_die("setgroups(0)");
+    }
+}
 
-	struct Guard {
-		Guard ()
-		{
-			if (config.multi_user && getuid() == 0) {
-				drop_privileges();
-			}
-		}
-		~Guard ()
-		{
-			if (config.multi_user && getuid() == 0) {
-				restore_privileges();
-			}
-		}
-	};
+struct Guard {
+    Guard ()
+    {
+        if (config.multi_user && getuid() == 0) {
+            drop_privileges();
+        }
+    }
+    ~Guard ()
+    {
+        if (config.multi_user && getuid() == 0) {
+            restore_privileges();
+        }
+    }
+};
 
-	template<class T> void set_fuse_data (struct fuse_file_info* fi, T data)
-	{
-		static_assert(sizeof(data) <= sizeof(fi->fh),
-			      "fuse_file_info::fh too small to store data");
-		std::memcpy(&fi->fh, &data, sizeof(data));
-	}
+template<class T> void set_fuse_data (struct fuse_file_info* fi, T data)
+{
+    static_assert(sizeof(data) <= sizeof(fi->fh),
+                  "fuse_file_info::fh too small to store data");
+    std::memcpy(&fi->fh, &data, sizeof(data));
+}
 
-	template<class T> T get_fuse_data (struct fuse_file_info* fi)
-	{
-		T data;
-		static_assert(sizeof(data) <= sizeof(fi->fh),
-			      "fuse_file_info::fh too small to store data");
-		std::memcpy(&data, &fi->fh, sizeof(data));
-		return data;
-	}
+template<class T> T get_fuse_data (struct fuse_file_info* fi)
+{
+    T data;
+    static_assert(sizeof(data) <= sizeof(fi->fh),
+                  "fuse_file_info::fh too small to store data");
+    std::memcpy(&data, &fi->fh, sizeof(data));
+    return data;
+}
 
-	struct fuse_operations		disorderfs_fuse_operations;
-	enum {
-		KEY_HELP,
-		KEY_VERSION,
-		KEY_QUIET
-	};
+struct fuse_operations                disorderfs_fuse_operations;
+enum {
+    KEY_HELP,
+    KEY_VERSION,
+    KEY_QUIET
+};
 #define DISORDERFS_OPT(t, p, v) { t, offsetof(Disorderfs_config, p), v }
-	const struct fuse_opt disorderfs_fuse_opts[] = {
-		DISORDERFS_OPT("--multi-user=no", multi_user, false),
-		DISORDERFS_OPT("--multi-user=yes", multi_user, true),
-		DISORDERFS_OPT("--shuffle-dirents=no", shuffle_dirents, false),
-		DISORDERFS_OPT("--shuffle-dirents=yes", shuffle_dirents, true),
-		DISORDERFS_OPT("--reverse-dirents=no", reverse_dirents, false),
-		DISORDERFS_OPT("--reverse-dirents=yes", reverse_dirents, true),
-		DISORDERFS_OPT("--sort-dirents=no", sort_dirents, false),
-		DISORDERFS_OPT("--sort-dirents=yes", sort_dirents, true),
-		DISORDERFS_OPT("--pad-blocks=%i", pad_blocks, 0),
-		DISORDERFS_OPT("--share-locks=no", share_locks, false),
-		DISORDERFS_OPT("--share-locks=yes", share_locks, true),
-		FUSE_OPT_KEY("-h", KEY_HELP),
-		FUSE_OPT_KEY("--help", KEY_HELP),
-		FUSE_OPT_KEY("-V", KEY_VERSION),
-		FUSE_OPT_KEY("--version", KEY_VERSION),
-		FUSE_OPT_KEY("-q", KEY_QUIET),
-		FUSE_OPT_KEY("--quiet", KEY_QUIET),
-		FUSE_OPT_END
-	};
-	int fuse_opt_proc (void* data, const char* arg, int key, struct fuse_args* outargs)
-	{
-		if (key == FUSE_OPT_KEY_NONOPT) {
-			bare_arguments.emplace_back(arg);
-			return 0;
-		} else if (key == KEY_HELP) {
-			std::clog << "Usage: disorderfs [OPTIONS] ROOTDIR MOUNTPOINT" << std::endl;
-			std::clog << "General options:" << std::endl;
-			std::clog << "    -o opt,[opt...]        mount options (see below)" << std::endl;
-			std::clog << "    -h, --help             display help" << std::endl;
-			std::clog << "    -V, --version          display version info" << std::endl;
-			std::clog << "    -q, --quiet            don't output any status messages" << std::endl;
-			std::clog << std::endl;
-			std::clog << "disorderfs options:" << std::endl;
-			std::clog << "    --multi-user=yes|no    allow multiple users to access overlay (requires root; default: no)" << std::endl;
-			std::clog << "    --shuffle-dirents=yes|no  randomly shuffle dirents? (default: no)" << std::endl;
-			std::clog << "    --reverse-dirents=yes|no  reverse dirent order? (default: yes)" << std::endl;
-			std::clog << "    --sort-dirents=yes|no  sort dirents deterministically instead (default: no)" << std::endl;
-			std::clog << "    --pad-blocks=N         add N to st_blocks (default: 1)" << std::endl;
-			std::clog << "    --share-locks=yes|no   share locks with underlying filesystem (BUGGY; default: no)" << std::endl;
-			std::clog << std::endl;
-			fuse_opt_add_arg(outargs, "-ho");
-			fuse_main(outargs->argc, outargs->argv, &disorderfs_fuse_operations, nullptr);
-			std::exit(0);
-		} else if (key == KEY_VERSION) {
-			std::cout << "disorderfs version: " DISORDERFS_VERSION << std::endl;
-			fuse_opt_add_arg(outargs, "--version");
-			fuse_main(outargs->argc, outargs->argv, &disorderfs_fuse_operations, nullptr);
-			std::exit(0);
-		} else if (key == KEY_QUIET) {
-			config.quiet = true;
-			return 0;
-		}
-		return 1;
-	}
+const struct fuse_opt disorderfs_fuse_opts[] = {
+    DISORDERFS_OPT("--multi-user=no", multi_user, false),
+    DISORDERFS_OPT("--multi-user=yes", multi_user, true),
+    DISORDERFS_OPT("--shuffle-dirents=no", shuffle_dirents, false),
+    DISORDERFS_OPT("--shuffle-dirents=yes", shuffle_dirents, true),
+    DISORDERFS_OPT("--reverse-dirents=no", reverse_dirents, false),
+    DISORDERFS_OPT("--reverse-dirents=yes", reverse_dirents, true),
+    DISORDERFS_OPT("--sort-dirents=no", sort_dirents, false),
+    DISORDERFS_OPT("--sort-dirents=yes", sort_dirents, true),
+    DISORDERFS_OPT("--pad-blocks=%i", pad_blocks, 0),
+    DISORDERFS_OPT("--share-locks=no", share_locks, false),
+    DISORDERFS_OPT("--share-locks=yes", share_locks, true),
+    FUSE_OPT_KEY("-h", KEY_HELP),
+    FUSE_OPT_KEY("--help", KEY_HELP),
+    FUSE_OPT_KEY("-V", KEY_VERSION),
+    FUSE_OPT_KEY("--version", KEY_VERSION),
+    FUSE_OPT_KEY("-q", KEY_QUIET),
+    FUSE_OPT_KEY("--quiet", KEY_QUIET),
+    FUSE_OPT_END
+};
+int fuse_opt_proc (void* data, const char* arg, int key, struct fuse_args* outargs)
+{
+    if (key == FUSE_OPT_KEY_NONOPT) {
+        bare_arguments.emplace_back(arg);
+        return 0;
+    } else if (key == KEY_HELP) {
+        std::clog << "Usage: disorderfs [OPTIONS] ROOTDIR MOUNTPOINT" << std::endl;
+        std::clog << "General options:" << std::endl;
+        std::clog << "    -o opt,[opt...]        mount options (see below)" << std::endl;
+        std::clog << "    -h, --help             display help" << std::endl;
+        std::clog << "    -V, --version          display version info" << std::endl;
+        std::clog << "    -q, --quiet            don't output any status messages" << std::endl;
+        std::clog << std::endl;
+        std::clog << "disorderfs options:" << std::endl;
+        std::clog << "    --multi-user=yes|no    allow multiple users to access overlay (requires root; default: no)" << std::endl;
+        std::clog << "    --shuffle-dirents=yes|no  randomly shuffle directory entries? (default: no)" << std::endl;
+        std::clog << "    --reverse-dirents=yes|no  reverse dirent order? (default: yes)" << std::endl;
+        std::clog << "    --sort-dirents=yes|no  sort directory entries deterministically instead (default: no)" << std::endl;
+        std::clog << "    --pad-blocks=N         add N to st_blocks (default: 1)" << std::endl;
+        std::clog << "    --share-locks=yes|no   share locks with underlying filesystem (BUGGY; default: no)" << std::endl;
+        std::clog << std::endl;
+        fuse_opt_add_arg(outargs, "-ho");
+        fuse_main(outargs->argc, outargs->argv, &disorderfs_fuse_operations, nullptr);
+        std::exit(0);
+    } else if (key == KEY_VERSION) {
+        std::cout << "disorderfs version: " DISORDERFS_VERSION << std::endl;
+        fuse_opt_add_arg(outargs, "--version");
+        fuse_main(outargs->argc, outargs->argv, &disorderfs_fuse_operations, nullptr);
+        std::exit(0);
+    } else if (key == KEY_QUIET) {
+        config.quiet = true;
+        return 0;
+    }
+    return 1;
+}
 }
 
-int	main (int argc, char** argv)
+int        main (int argc, char** argv)
 {
-	signal(SIGPIPE, SIG_IGN);
-	umask(0);
+    signal(SIGPIPE, SIG_IGN);
+    umask(0);
 
-	/*
-	 * Parse command line options
-	 */
-	struct fuse_args	fargs = FUSE_ARGS_INIT(argc, argv);
-	fuse_opt_parse(&fargs, &config, disorderfs_fuse_opts, fuse_opt_proc);
+    /*
+     * Parse command line options
+     */
+    struct fuse_args        fargs = FUSE_ARGS_INIT(argc, argv);
+    fuse_opt_parse(&fargs, &config, disorderfs_fuse_opts, fuse_opt_proc);
 
-	if (bare_arguments.size() != 2) {
-		std::clog << "disorderfs: error: wrong number of arguments" << std::endl;
-		std::clog << "Usage: disorderfs [OPTIONS] ROOTDIR MOUNTPOINT" << std::endl;
-		return 2;
-	}
+    if (bare_arguments.size() != 2) {
+        std::clog << "disorderfs: error: wrong number of arguments" << std::endl;
+        std::clog << "Usage: disorderfs [OPTIONS] ROOTDIR MOUNTPOINT" << std::endl;
+        return 2;
+    }
 
-	if (char* resolved_path = realpath(bare_arguments[0].c_str(), nullptr)) {
-		root = resolved_path;
-		std::free(resolved_path);
-	} else {
-		std::perror(bare_arguments[0].c_str());
-		return 1;
-	}
+    if (char* resolved_path = realpath(bare_arguments[0].c_str(), nullptr)) {
+        root = resolved_path;
+        std::free(resolved_path);
+    } else {
+        std::perror(bare_arguments[0].c_str());
+        return 1;
+    }
 
-	// Add some of our own hard-coded FUSE options:
-	fuse_opt_add_arg(&fargs, "-o");
-	fuse_opt_add_arg(&fargs, "atomic_o_trunc,default_permissions,use_ino"); // XXX: other mount options?
-	if (config.multi_user) {
-		fuse_opt_add_arg(&fargs, "-o");
-		fuse_opt_add_arg(&fargs, "allow_other");
-	}
-	fuse_opt_add_arg(&fargs, bare_arguments[1].c_str());
+    // Add some of our own hard-coded FUSE options:
+    fuse_opt_add_arg(&fargs, "-o");
+    fuse_opt_add_arg(&fargs, "atomic_o_trunc,default_permissions,use_ino"); // XXX: other mount options?
+    if (config.multi_user) {
+        fuse_opt_add_arg(&fargs, "-o");
+        fuse_opt_add_arg(&fargs, "allow_other");
+    }
+    fuse_opt_add_arg(&fargs, bare_arguments[1].c_str());
 
-	if (!config.quiet) {
-		if (config.shuffle_dirents) {
-			std::cout << "disorderfs: shuffling dirents" << std::endl;
-		}
-		if (config.reverse_dirents) {
-			std::cout << "disorderfs: reversing dirents" << std::endl;
-		}
-		if (config.sort_dirents) {
-			std::cout << "disorderfs: sorting dirents" << std::endl;
-		}
-	}
+    if (!config.quiet) {
+        if (config.shuffle_dirents) {
+            std::cout << "disorderfs: shuffling directory entries" << std::endl;
+        }
+        if (config.reverse_dirents) {
+            std::cout << "disorderfs: reversing directory entries" << std::endl;
+        }
+        if (config.sort_dirents) {
+            std::cout << "disorderfs: sorting directory entries" << std::endl;
+        }
+    }
 
-	/*
-	 * Initialize disorderfs_fuse_operations
-	 */
+    /*
+     * Initialize disorderfs_fuse_operations
+     */
 
-	/*
-	 * Indicate that we should accept UTIME_OMIT (and UTIME_NOW) in the
-	 * utimens operations for "touch -m" and "touch -a"
-	 */
-	disorderfs_fuse_operations.flag_utime_omit_ok = 1;
+    /*
+     * Indicate that we should accept UTIME_OMIT (and UTIME_NOW) in the
+     * utimens operations for "touch -m" and "touch -a"
+     */
+    disorderfs_fuse_operations.flag_utime_omit_ok = 1;
 
-	disorderfs_fuse_operations.getattr = [] (const char* path, struct stat* st) -> int {
-		Guard g;
-		if (lstat((root + path).c_str(), st) == -1) {
-			return -errno;
-		}
-		st->st_blocks += config.pad_blocks;
-		return 0;
-	};
-	disorderfs_fuse_operations.readlink = [] (const char* path, char* buf, size_t sz) -> int {
-		Guard g;
-		const ssize_t len{readlink((root + path).c_str(), buf, sz - 1)}; // sz > 0, since it includes space for null terminator
-		if (len == -1) {
-			return -errno;
-		}
-		buf[len] = '\0';
-		return 0;
-	};
-	disorderfs_fuse_operations.mknod = [] (const char* path, mode_t mode, dev_t dev) -> int {
-		Guard g;
-		return wrap(mknod((root + path).c_str(), mode, dev));
-	};
-	disorderfs_fuse_operations.mkdir = [] (const char* path, mode_t mode) -> int {
-		Guard g;
-		return wrap(mkdir((root + path).c_str(), mode));
-	};
-	disorderfs_fuse_operations.unlink = [] (const char* path) -> int {
-		Guard g;
-		return wrap(unlink((root + path).c_str()));
-	};
-	disorderfs_fuse_operations.rmdir = [] (const char* path) -> int {
-		Guard g;
-		return wrap(rmdir((root + path).c_str()));
-	};
-	disorderfs_fuse_operations.symlink = [] (const char* target, const char* linkpath) -> int {
-		Guard g;
-		return wrap(symlink(target, (root + linkpath).c_str()));
-	};
-	disorderfs_fuse_operations.rename = [] (const char* oldpath, const char* newpath) -> int {
-		Guard g;
-		return wrap(rename((root + oldpath).c_str(), (root + newpath).c_str()));
-	};
-	disorderfs_fuse_operations.link = [] (const char* oldpath, const char* newpath) -> int {
-		Guard g;
-		return wrap(link((root + oldpath).c_str(), (root + newpath).c_str()));
-	};
-	disorderfs_fuse_operations.chmod = [] (const char* path, mode_t mode) -> int {
-		Guard g;
-		return wrap(chmod((root + path).c_str(), mode));
-	};
-	disorderfs_fuse_operations.chown = [] (const char* path, uid_t uid, gid_t gid) -> int {
-		Guard g;
-		return wrap(lchown((root + path).c_str(), uid, gid));
-	};
-	disorderfs_fuse_operations.truncate = [] (const char* path, off_t length) -> int {
-		Guard g;
-		return wrap(truncate((root + path).c_str(), length));
-	};
-	disorderfs_fuse_operations.open = [] (const char* path, struct fuse_file_info* info) -> int {
-		Guard g;
-		const int fd{open((root + path).c_str(), info->flags)};
-		if (fd == -1) {
-			return -errno;
-		}
-		info->fh = fd;
-		return 0;
-	};
-	disorderfs_fuse_operations.read = [] (const char* path, char* buf, size_t sz, off_t off, struct fuse_file_info* info) -> int {
-		size_t bytes_read = 0;
-		while (bytes_read < sz) {
-			const ssize_t res = pread(info->fh, buf + bytes_read, sz - bytes_read, off + bytes_read);
-			if (res < 0) {
-				return -errno;
-			} else if (res == 0) {
-				break;
-			} else {
-				bytes_read += res;
-			}
-		}
-		return bytes_read;
-	};
-	disorderfs_fuse_operations.write = [] (const char* path, const char* buf, size_t sz, off_t off, struct fuse_file_info* info) -> int {
-		size_t bytes_written = 0;
-		while (bytes_written < sz) {
-			const ssize_t res = pwrite(info->fh, buf + bytes_written, sz - bytes_written, off + bytes_written);
-			if (res < 0) {
-				return -errno;
-			} else {
-				bytes_written += res;
-			}
-		}
-		return bytes_written;
-	};
-	disorderfs_fuse_operations.statfs = [] (const char* path, struct statvfs* f) -> int {
-		Guard g;
-		return wrap(statvfs((root + path).c_str(), f));
-	};
-	disorderfs_fuse_operations.flush = [] (const char* path, struct fuse_file_info* info) -> int {
-		return wrap(close(dup(info->fh)));
-	};
-	disorderfs_fuse_operations.release = [] (const char* path, struct fuse_file_info* info) -> int {
-		close(info->fh);
-		return 0; // return value is ignored
-	};
-	disorderfs_fuse_operations.fsync = [] (const char* path, int is_datasync, struct fuse_file_info* info) -> int {
-		return wrap(is_datasync ? fdatasync(info->fh) : fsync(info->fh));
-	};
-	disorderfs_fuse_operations.setxattr = [] (const char* path, const char* name, const char* value, size_t size, int flags) -> int {
-		Guard g;
-		return wrap(lsetxattr((root + path).c_str(), name, value, size, flags));
-	};
-	disorderfs_fuse_operations.getxattr = [] (const char* path, const char* name, char* value, size_t size) -> int {
-		Guard g;
-		ssize_t res = lgetxattr((root + path).c_str(), name, value, size);
-		return res >= 0 ? res : -errno;
-	};
-	disorderfs_fuse_operations.listxattr = [] (const char* path, char* list, size_t size) -> int {
-		Guard g;
-		ssize_t res = llistxattr((root + path).c_str(), list, size);
-		return res >= 0 ? res : -errno;
-	};
-	disorderfs_fuse_operations.removexattr = [] (const char* path, const char* name) -> int {
-		Guard g;
-		return wrap(lremovexattr((root + path).c_str(), name));
-	};
-	disorderfs_fuse_operations.opendir = [] (const char* path, struct fuse_file_info* info) -> int {
-		Guard g;
-		std::unique_ptr<Dirents> dirents{new Dirents};
+    disorderfs_fuse_operations.getattr = [] (const char* path, struct stat* st) -> int {
+        Guard g;
+        if (lstat((root + path).c_str(), st) == -1) {
+            return -errno;
+        }
+        st->st_blocks += config.pad_blocks;
+        return 0;
+    };
+    disorderfs_fuse_operations.readlink = [] (const char* path, char* buf, size_t sz) -> int {
+        Guard g;
+        const ssize_t len{readlink((root + path).c_str(), buf, sz - 1)}; // sz > 0, since it includes space for null terminator
+        if (len == -1) {
+            return -errno;
+        }
+        buf[len] = '\0';
+        return 0;
+    };
+    disorderfs_fuse_operations.mknod = [] (const char* path, mode_t mode, dev_t dev) -> int {
+        Guard g;
+        return wrap(mknod((root + path).c_str(), mode, dev));
+    };
+    disorderfs_fuse_operations.mkdir = [] (const char* path, mode_t mode) -> int {
+        Guard g;
+        return wrap(mkdir((root + path).c_str(), mode));
+    };
+    disorderfs_fuse_operations.unlink = [] (const char* path) -> int {
+        Guard g;
+        return wrap(unlink((root + path).c_str()));
+    };
+    disorderfs_fuse_operations.rmdir = [] (const char* path) -> int {
+        Guard g;
+        return wrap(rmdir((root + path).c_str()));
+    };
+    disorderfs_fuse_operations.symlink = [] (const char* target, const char* linkpath) -> int {
+        Guard g;
+        return wrap(symlink(target, (root + linkpath).c_str()));
+    };
+    disorderfs_fuse_operations.rename = [] (const char* oldpath, const char* newpath) -> int {
+        Guard g;
+        return wrap(rename((root + oldpath).c_str(), (root + newpath).c_str()));
+    };
+    disorderfs_fuse_operations.link = [] (const char* oldpath, const char* newpath) -> int {
+        Guard g;
+        return wrap(link((root + oldpath).c_str(), (root + newpath).c_str()));
+    };
+    disorderfs_fuse_operations.chmod = [] (const char* path, mode_t mode) -> int {
+        Guard g;
+        return wrap(chmod((root + path).c_str(), mode));
+    };
+    disorderfs_fuse_operations.chown = [] (const char* path, uid_t uid, gid_t gid) -> int {
+        Guard g;
+        return wrap(lchown((root + path).c_str(), uid, gid));
+    };
+    disorderfs_fuse_operations.truncate = [] (const char* path, off_t length) -> int {
+        Guard g;
+        return wrap(truncate((root + path).c_str(), length));
+    };
+    disorderfs_fuse_operations.open = [] (const char* path, struct fuse_file_info* info) -> int {
+        Guard g;
+        const int fd{open((root + path).c_str(), info->flags)};
+        if (fd == -1) {
+            return -errno;
+        }
+        info->fh = fd;
+        return 0;
+    };
+    disorderfs_fuse_operations.read = [] (const char* path, char* buf, size_t sz, off_t off, struct fuse_file_info* info) -> int {
+        size_t bytes_read = 0;
+        while (bytes_read < sz) {
+            const ssize_t res = pread(info->fh, buf + bytes_read, sz - bytes_read, off + bytes_read);
+            if (res < 0) {
+                return -errno;
+            } else if (res == 0) {
+                break;
+            } else {
+                bytes_read += res;
+            }
+        }
+        return bytes_read;
+    };
+    disorderfs_fuse_operations.write = [] (const char* path, const char* buf, size_t sz, off_t off, struct fuse_file_info* info) -> int {
+        size_t bytes_written = 0;
+        while (bytes_written < sz) {
+            const ssize_t res = pwrite(info->fh, buf + bytes_written, sz - bytes_written, off + bytes_written);
+            if (res < 0) {
+                return -errno;
+            } else {
+                bytes_written += res;
+            }
+        }
+        return bytes_written;
+    };
+    disorderfs_fuse_operations.statfs = [] (const char* path, struct statvfs* f) -> int {
+        Guard g;
+        return wrap(statvfs((root + path).c_str(), f));
+    };
+    disorderfs_fuse_operations.flush = [] (const char* path, struct fuse_file_info* info) -> int {
+        return wrap(close(dup(info->fh)));
+    };
+    disorderfs_fuse_operations.release = [] (const char* path, struct fuse_file_info* info) -> int {
+        close(info->fh);
+        return 0; // return value is ignored
+    };
+    disorderfs_fuse_operations.fsync = [] (const char* path, int is_datasync, struct fuse_file_info* info) -> int {
+        return wrap(is_datasync ? fdatasync(info->fh) : fsync(info->fh));
+    };
+    disorderfs_fuse_operations.setxattr = [] (const char* path, const char* name, const char* value, size_t size, int flags) -> int {
+        Guard g;
+        return wrap(lsetxattr((root + path).c_str(), name, value, size, flags));
+    };
+    disorderfs_fuse_operations.getxattr = [] (const char* path, const char* name, char* value, size_t size) -> int {
+        Guard g;
+        ssize_t res = lgetxattr((root + path).c_str(), name, value, size);
+        return res >= 0 ? res : -errno;
+    };
+    disorderfs_fuse_operations.listxattr = [] (const char* path, char* list, size_t size) -> int {
+        Guard g;
+        ssize_t res = llistxattr((root + path).c_str(), list, size);
+        return res >= 0 ? res : -errno;
+    };
+    disorderfs_fuse_operations.removexattr = [] (const char* path, const char* name) -> int {
+        Guard g;
+        return wrap(lremovexattr((root + path).c_str(), name));
+    };
+    disorderfs_fuse_operations.opendir = [] (const char* path, struct fuse_file_info* info) -> int {
+        Guard g;
+        std::unique_ptr<Dirents> dirents{new Dirents};
 
-		DIR* d = opendir((root + path).c_str());
-		if (!d) {
-			return -errno;
-		}
-		struct dirent*	dirent_p;
-		errno = 0;
-		while ((dirent_p = readdir(d)) != NULL) {
-			dirents->emplace_back(std::make_pair(dirent_p->d_name, dirent_p->d_ino));
-		}
-		if (errno != 0) {
-			return -errno;
-		}
-		if (config.sort_dirents) {
-			std::sort(dirents->begin(), dirents->end());
-		}
-		if (config.reverse_dirents) {
-			std::reverse(dirents->begin(), dirents->end());
-		}
-		closedir(d);
-		if (errno != 0) {
-			return -errno;
-		}
+        DIR* d = opendir((root + path).c_str());
+        if (!d) {
+            return -errno;
+        }
+        struct dirent*        dirent_p;
+        errno = 0;
+        while ((dirent_p = readdir(d)) != NULL) {
+            dirents->emplace_back(std::make_pair(dirent_p->d_name, dirent_p->d_ino));
+        }
+        if (errno != 0) {
+            return -errno;
+        }
+        if (config.sort_dirents) {
+            std::sort(dirents->begin(), dirents->end());
+        }
+        if (config.reverse_dirents) {
+            std::reverse(dirents->begin(), dirents->end());
+        }
+        closedir(d);
+        if (errno != 0) {
+            return -errno;
+        }
 
-		set_fuse_data<Dirents*>(info, dirents.release());
-		return 0;
-	};
-	disorderfs_fuse_operations.readdir = [] (const char* path, void* buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info* info) {
-		Dirents&		dirents = *get_fuse_data<Dirents*>(info);
-		struct stat		st;
-		memset(&st, 0, sizeof(st));
-		if (config.shuffle_dirents) {
-			std::random_device	rd;
-			std::mt19937		g(rd());
-			std::shuffle(dirents.begin(), dirents.end(), g);
-		}
+        set_fuse_data<Dirents*>(info, dirents.release());
+        return 0;
+    };
+    disorderfs_fuse_operations.readdir = [] (const char* path, void* buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info* info) {
+        Dirents&                dirents = *get_fuse_data<Dirents*>(info);
+        struct stat                st;
+        memset(&st, 0, sizeof(st));
+        if (config.shuffle_dirents) {
+            std::random_device        rd;
+            std::mt19937              g(rd());
+            std::shuffle(dirents.begin(), dirents.end(), g);
+        }
 
-		for (const auto dirent : dirents) {
-			st.st_ino = dirent.second;
-			if (filler(buf, dirent.first.c_str(), &st, 0) != 0) {
-				return -ENOMEM;
-			}
-		}
-		return 0;
-	};
-	disorderfs_fuse_operations.releasedir = [] (const char* path, struct fuse_file_info* info) -> int {
-		delete get_fuse_data<Dirents*>(info);
-		return 0;
-	};
-	disorderfs_fuse_operations.fsyncdir = [] (const char* path, int is_datasync, struct fuse_file_info* info) -> int {
-		// XXX: is it OK to just use fsync?  Not clear on why FUSE has a separate fsyncdir operation
-		wrap(is_datasync ? fdatasync(info->fh) : fsync(info->fh));
-		return 0; // return value is ignored
-	};
-	disorderfs_fuse_operations.create = [] (const char* path, mode_t mode, struct fuse_file_info* info) -> int {
-		Guard g;
-		// XXX: use info->flags?
-		const int fd{open((root + path).c_str(), info->flags | O_CREAT, mode)};
-		if (fd == -1) {
-			return -errno;
-		}
-		info->fh = fd;
-		return 0;
-	};
-	disorderfs_fuse_operations.ftruncate = [] (const char* path, off_t off, struct fuse_file_info* info) -> int {
-		return wrap(ftruncate(info->fh, off));
-	};
-	disorderfs_fuse_operations.fgetattr = [] (const char* path, struct stat* st, struct fuse_file_info* info) -> int {
-		if (fstat(info->fh, st) == -1) {
-			return -errno;
-		}
-		st->st_blocks += config.pad_blocks;
-		return 0;
-	};
-	if (config.share_locks) {
-		disorderfs_fuse_operations.lock = [] (const char* path, struct fuse_file_info* info, int cmd, struct flock* lock) -> int {
-			return ulockmgr_op(info->fh, cmd, lock, &info->lock_owner, sizeof(info->lock_owner));
-		};
-		disorderfs_fuse_operations.flock = [] (const char* path, struct fuse_file_info* info, int op) -> int {
-			return wrap(flock(info->fh, op));
-		};
-	}
-	disorderfs_fuse_operations.utimens = [] (const char* path, const struct timespec tv[2]) -> int {
-		Guard g;
-		return wrap(utimensat(AT_FDCWD, (root + path).c_str(), tv, AT_SYMLINK_NOFOLLOW));
-	};
-	/* Not applicable?
-	disorderfs_fuse_operations.bmap = [] (const char *, size_t blocksize, uint64_t *idx) -> int {
-	};
-	*/
-	/* Not needed?
-	disorderfs_fuse_operations.ioctl = [] (const char *, int cmd, void *arg, struct fuse_file_info *, unsigned int flags, void *data) -> int {
-	};
-	*/
-	/* ???
-	disorderfs_fuse_operations.poll = [] (const char *, struct fuse_file_info *, struct fuse_pollhandle *ph, unsigned *reventsp) -> int {
-	};
-	*/
-	disorderfs_fuse_operations.write_buf = [] (const char* path, struct fuse_bufvec* buf, off_t off, struct fuse_file_info* info) -> int {
-		struct fuse_bufvec dst;
-		dst.count = 1;
-		dst.idx = 0;
-		dst.off = 0;
-		dst.buf[0].size = fuse_buf_size(buf);
-		dst.buf[0].flags = static_cast<fuse_buf_flags>(FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK);
-		dst.buf[0].mem = nullptr;
-		dst.buf[0].fd = info->fh;
-		dst.buf[0].pos = off;
+        for (const auto dirent : dirents) {
+            st.st_ino = dirent.second;
+            if (filler(buf, dirent.first.c_str(), &st, 0) != 0) {
+                return -ENOMEM;
+            }
+        }
+        return 0;
+    };
+    disorderfs_fuse_operations.releasedir = [] (const char* path, struct fuse_file_info* info) -> int {
+        delete get_fuse_data<Dirents*>(info);
+        return 0;
+    };
+    disorderfs_fuse_operations.fsyncdir = [] (const char* path, int is_datasync, struct fuse_file_info* info) -> int {
+        // XXX: is it OK to just use fsync?  Not clear on why FUSE has a separate fsyncdir operation
+        wrap(is_datasync ? fdatasync(info->fh) : fsync(info->fh));
+        return 0; // return value is ignored
+    };
+    disorderfs_fuse_operations.create = [] (const char* path, mode_t mode, struct fuse_file_info* info) -> int {
+        Guard g;
+        // XXX: use info->flags?
+        const int fd{open((root + path).c_str(), info->flags | O_CREAT, mode)};
+        if (fd == -1) {
+            return -errno;
+        }
+        info->fh = fd;
+        return 0;
+    };
+    disorderfs_fuse_operations.ftruncate = [] (const char* path, off_t off, struct fuse_file_info* info) -> int {
+        return wrap(ftruncate(info->fh, off));
+    };
+    disorderfs_fuse_operations.fgetattr = [] (const char* path, struct stat* st, struct fuse_file_info* info) -> int {
+        if (fstat(info->fh, st) == -1) {
+            return -errno;
+        }
+        st->st_blocks += config.pad_blocks;
+        return 0;
+    };
+    if (config.share_locks) {
+        disorderfs_fuse_operations.lock = [] (const char* path, struct fuse_file_info* info, int cmd, struct flock* lock) -> int {
+            return ulockmgr_op(info->fh, cmd, lock, &info->lock_owner, sizeof(info->lock_owner));
+        };
+        disorderfs_fuse_operations.flock = [] (const char* path, struct fuse_file_info* info, int op) -> int {
+            return wrap(flock(info->fh, op));
+        };
+    }
+    disorderfs_fuse_operations.utimens = [] (const char* path, const struct timespec tv[2]) -> int {
+        Guard g;
+        return wrap(utimensat(AT_FDCWD, (root + path).c_str(), tv, AT_SYMLINK_NOFOLLOW));
+    };
+    /* Not applicable?
+    disorderfs_fuse_operations.bmap = [] (const char *, size_t blocksize, uint64_t *idx) -> int {
+    };
+    */
+    /* Not needed?
+    disorderfs_fuse_operations.ioctl = [] (const char *, int cmd, void *arg, struct fuse_file_info *, unsigned int flags, void *data) -> int {
+    };
+    */
+    /* ???
+    disorderfs_fuse_operations.poll = [] (const char *, struct fuse_file_info *, struct fuse_pollhandle *ph, unsigned *reventsp) -> int {
+    };
+    */
+    disorderfs_fuse_operations.write_buf = [] (const char* path, struct fuse_bufvec* buf, off_t off, struct fuse_file_info* info) -> int {
+        struct fuse_bufvec dst;
+        dst.count = 1;
+        dst.idx = 0;
+        dst.off = 0;
+        dst.buf[0].size = fuse_buf_size(buf);
+        dst.buf[0].flags = static_cast<fuse_buf_flags>(FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK);
+        dst.buf[0].mem = nullptr;
+        dst.buf[0].fd = info->fh;
+        dst.buf[0].pos = off;
 
-		return fuse_buf_copy(&dst, buf, FUSE_BUF_SPLICE_NONBLOCK);
-	};
-	disorderfs_fuse_operations.read_buf = [] (const char* path, struct fuse_bufvec** bufp, size_t size, off_t off, struct fuse_file_info* info) -> int {
-		struct fuse_bufvec* src = static_cast<struct fuse_bufvec*>(malloc(sizeof(struct fuse_bufvec)));
-		if (src == nullptr) {
-			return -ENOMEM;
-		}
+        return fuse_buf_copy(&dst, buf, FUSE_BUF_SPLICE_NONBLOCK);
+    };
+    disorderfs_fuse_operations.read_buf = [] (const char* path, struct fuse_bufvec** bufp, size_t size, off_t off, struct fuse_file_info* info) -> int {
+        struct fuse_bufvec* src = static_cast<struct fuse_bufvec*>(malloc(sizeof(struct fuse_bufvec)));
+        if (src == nullptr) {
+            return -ENOMEM;
+        }
 
-		src->count = 1;
-		src->idx = 0;
-		src->off = 0;
-		src->buf[0].size = size;
-		src->buf[0].flags = static_cast<fuse_buf_flags>(FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK);
-		src->buf[0].mem = nullptr;
-		src->buf[0].fd = info->fh;
-		src->buf[0].pos = off;
+        src->count = 1;
+        src->idx = 0;
+        src->off = 0;
+        src->buf[0].size = size;
+        src->buf[0].flags = static_cast<fuse_buf_flags>(FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK);
+        src->buf[0].mem = nullptr;
+        src->buf[0].fd = info->fh;
+        src->buf[0].pos = off;
 
-		*bufp = src;
+        *bufp = src;
 
-		return 0;
-	};
-	disorderfs_fuse_operations.fallocate = [] (const char* path, int mode, off_t off, off_t len, struct fuse_file_info* info) -> int {
-		return wrap(fallocate(info->fh, mode, off, len));
-	};
+        return 0;
+    };
+    disorderfs_fuse_operations.fallocate = [] (const char* path, int mode, off_t off, off_t len, struct fuse_file_info* info) -> int {
+        return wrap(fallocate(info->fh, mode, off, len));
+    };
 
-	return fuse_main(fargs.argc, fargs.argv, &disorderfs_fuse_operations, nullptr);
+    return fuse_main(fargs.argc, fargs.argv, &disorderfs_fuse_operations, nullptr);
 }



View it on GitLab: https://salsa.debian.org/reproducible-builds/disorderfs/-/compare/8ab69faa74fe90e7335f582adc17b4c88129713a...b38eac90c94918545c3022ca37b4b45b01ec14a8

-- 
View it on GitLab: https://salsa.debian.org/reproducible-builds/disorderfs/-/compare/8ab69faa74fe90e7335f582adc17b4c88129713a...b38eac90c94918545c3022ca37b4b45b01ec14a8
You're receiving this email because of your account on salsa.debian.org.


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.reproducible-builds.org/pipermail/rb-commits/attachments/20200521/fc71efff/attachment.htm>


More information about the rb-commits mailing list