Mirror
/
mergerfs
mirror of https://github.com/trapexit/mergerfs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #577 from trapexit/modules 

remove libfuse modules
pull/579/head
trapexit 6 years ago
committed by GitHub
parent
cfd5d31338 65d3bfe84d
commit
401502579b
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 1 additions and 1623 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 10
      libfuse/lib/Makefile.am
  2. 178
      libfuse/lib/fuse.c
  3. 739
      libfuse/lib/modules/iconv.c
  4. 697
      libfuse/lib/modules/subdir.c

10
libfuse/lib/Makefile.am
View File

@ -12,12 +12,6 @@ else
mount_source = mount.c mount_util.c mount_util.h
endif
if ICONV
iconv_source = modules/iconv.c
else
iconv_source =
endif
libfuse_la_SOURCES = \
fuse.c \
fuse_i.h \
@ -32,9 +26,7 @@ libfuse_la_SOURCES = \
fuse_signals.c \
buffer.c \
cuse_lowlevel.c \
helper.c \
modules/subdir.c \
$(iconv_source) \
helper.c \
$(mount_source)
libfuse_la_LDFLAGS = -pthread @libfuse_libs@ -version-number 2:9:7 \

178
libfuse/lib/fuse.c
View File

@ -75,13 +75,11 @@ struct fuse_config {
int intr;
int intr_signal;
int help;
char *modules;
int threads;
};
struct fuse_fs {
struct fuse_operations op;
struct fuse_module *m;
void *user_data;
int compat;
int debug;
@ -222,104 +220,6 @@ struct fuse_context_i {
static pthread_key_t fuse_context_key;
static pthread_mutex_t fuse_context_lock = PTHREAD_MUTEX_INITIALIZER;
static int fuse_context_ref;
static struct fusemod_so *fuse_current_so;
static struct fuse_module *fuse_modules;
static int fuse_load_so_name(const char *soname)
{
struct fusemod_so *so;
so = calloc(1, sizeof(struct fusemod_so));
if (!so) {
fprintf(stderr, "fuse: memory allocation failed\n");
return -1;
}
fuse_current_so = so;
so->handle = dlopen(soname, RTLD_NOW);
fuse_current_so = NULL;
if (!so->handle) {
fprintf(stderr, "fuse: %s\n", dlerror());
goto err;
}
if (!so->ctr) {
fprintf(stderr, "fuse: %s did not register any modules\n",
soname);
goto err;
}
return 0;
err:
if (so->handle)
dlclose(so->handle);
free(so);
return -1;
}
static int fuse_load_so_module(const char *module)
{
int res;
char *soname = malloc(strlen(module) + 64);
if (!soname) {
fprintf(stderr, "fuse: memory allocation failed\n");
return -1;
}
sprintf(soname, "libfusemod_%s.so", module);
res = fuse_load_so_name(soname);
free(soname);
return res;
}
static struct fuse_module *fuse_find_module(const char *module)
{
struct fuse_module *m;
for (m = fuse_modules; m; m = m->next) {
if (strcmp(module, m->name) == 0) {
m->ctr++;
break;
}
}
return m;
}
static struct fuse_module *fuse_get_module(const char *module)
{
struct fuse_module *m;
pthread_mutex_lock(&fuse_context_lock);
m = fuse_find_module(module);
if (!m) {
int err = fuse_load_so_module(module);
if (!err)
m = fuse_find_module(module);
}
pthread_mutex_unlock(&fuse_context_lock);
return m;
}
static void fuse_put_module(struct fuse_module *m)
{
pthread_mutex_lock(&fuse_context_lock);
assert(m->ctr > 0);
m->ctr--;
if (!m->ctr && m->so) {
struct fusemod_so *so = m->so;
assert(so->ctr > 0);
so->ctr--;
if (!so->ctr) {
struct fuse_module **mp;
for (mp = &fuse_modules; *mp;) {
if ((*mp)->so == so)
*mp = (*mp)->next;
else
mp = &(*mp)->next;
}
dlclose(so->handle);
free(so);
}
}
pthread_mutex_unlock(&fuse_context_lock);
}
static void init_list_head(struct list_head *list)
{
@ -2612,8 +2512,6 @@ void fuse_fs_destroy(struct fuse_fs *fs)
fuse_get_context()->private_data = fs->user_data;
if (fs->op.destroy)
fs->op.destroy(fs->user_data);
if (fs->m)
fuse_put_module(fs->m);
free(fs);
}
@ -4399,7 +4297,6 @@ static const struct fuse_opt fuse_lib_opts[] = {
FUSE_LIB_OPT("nopath", nopath, 1),
FUSE_LIB_OPT("intr", intr, 1),
FUSE_LIB_OPT("intr_signal=%d", intr_signal, 0),
FUSE_LIB_OPT("modules=%s", modules, 0),
FUSE_LIB_OPT("threads=%d", threads, 0),
FUSE_OPT_END
};
@ -4424,33 +4321,12 @@ static void fuse_lib_help(void)
" -o nopath don't supply path if not necessary\n"
" -o intr allow requests to be interrupted\n"
" -o intr_signal=NUM signal to send on interrupt (%i)\n"
" -o modules=M1[:M2...] names of modules to push onto filesystem stack\n"
" -o threads=NUM number of worker threads. 0 = autodetect.\n"
" Negative values autodetect then divide by\n"
" absolute value. default = 0\n"
"\n", FUSE_DEFAULT_INTR_SIGNAL);
}
static void fuse_lib_help_modules(void)
{
struct fuse_module *m;
fprintf(stderr, "\nModule options:\n");
pthread_mutex_lock(&fuse_context_lock);
for (m = fuse_modules; m; m = m->next) {
struct fuse_fs *fs = NULL;
struct fuse_fs *newfs;
struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
if (fuse_opt_add_arg(&args, "") != -1 &&
fuse_opt_add_arg(&args, "-h") != -1) {
fprintf(stderr, "\n[%s]\n", m->name);
newfs = m->factory(&args, &fs);
assert(newfs == NULL);
}
fuse_opt_free_args(&args);
}
pthread_mutex_unlock(&fuse_context_lock);
}
static int fuse_lib_opt_proc(void *data, const char *arg, int key,
struct fuse_args *outargs)
{
@ -4506,29 +4382,6 @@ static void fuse_restore_intr_signal(int signum)
}
static int fuse_push_module(struct fuse *f, const char *module,
struct fuse_args *args)
{
struct fuse_fs *fs[2] = { f->fs, NULL };
struct fuse_fs *newfs;
struct fuse_module *m = fuse_get_module(module);
if (!m)
return -1;
newfs = m->factory(args, fs);
if (!newfs) {
fuse_put_module(m);
return -1;
}
newfs->m = m;
f->fs = newfs;
f->nullpath_ok = newfs->op.flag_nullpath_ok && f->nullpath_ok;
f->conf.nopath = newfs->op.flag_nopath && f->conf.nopath;
f->utime_omit_ok = newfs->op.flag_utime_omit_ok && f->utime_omit_ok;
return 0;
}
struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size,
void *user_data)
{
@ -4643,21 +4496,6 @@ struct fuse *fuse_new_common(struct fuse_chan *ch, struct fuse_args *args,
fuse_lib_opt_proc) == -1)
goto out_free_fs;
if (f->conf.modules) {
char *module;
char *next;
for (module = f->conf.modules; module; module = next) {
char *p;
for (p = module; *p && *p != ':'; p++);
next = *p ? p + 1 : NULL;
*p = '\0';
if (module[0] &&
fuse_push_module(f, module, args) == -1)
goto out_free_fs;
}
}
if (!f->conf.ac_attr_timeout_set)
f->conf.ac_attr_timeout = f->conf.attr_timeout;
@ -4676,8 +4514,6 @@ struct fuse *fuse_new_common(struct fuse_chan *ch, struct fuse_args *args,
f->se = fuse_lowlevel_new_common(args, &llop, sizeof(llop), f);
if (f->se == NULL) {
if (f->conf.help)
fuse_lib_help_modules();
goto out_free_fs;
}
@ -4739,7 +4575,6 @@ out_free_fs:
called on the filesystem without init being called first */
fs->op.destroy = NULL;
fuse_fs_destroy(f->fs);
free(f->conf.modules);
out_free:
free(f);
out_delete_context_key:
@ -4800,7 +4635,6 @@ void fuse_destroy(struct fuse *f)
free(f->name_table.array);
pthread_mutex_destroy(&f->lock);
fuse_session_destroy(f->se);
free(f->conf.modules);
free(f);
fuse_delete_context_key();
}
@ -4818,18 +4652,6 @@ static struct fuse *fuse_new_common_compat25(int fd, struct fuse_args *args,
return f;
}
/* called with fuse_context_lock held or during initialization (before
main() has been called) */
void fuse_register_module(struct fuse_module *mod)
{
mod->ctr = 0;
mod->so = fuse_current_so;
if (mod->so)
mod->so->ctr++;
mod->next = fuse_modules;
fuse_modules = mod;
}
#if !defined(__FreeBSD__) && !defined(__NetBSD__)
static struct fuse *fuse_new_common_compat(int fd, const char *opts,

739
libfuse/lib/modules/iconv.c
View File

@ -1,739 +0,0 @@
/*
fuse iconv module: file name charset conversion
Copyright (C) 2007 Miklos Szeredi <miklos@szeredi.hu>
This program can be distributed under the terms of the GNU LGPLv2.
See the file COPYING.LIB
*/
#define FUSE_USE_VERSION 26
#include <fuse.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <errno.h>
#include <iconv.h>
#include <pthread.h>
#include <locale.h>
#include <langinfo.h>
struct iconv {
struct fuse_fs *next;
pthread_mutex_t lock;
char *from_code;
char *to_code;
iconv_t tofs;
iconv_t fromfs;
};
struct iconv_dh {
struct iconv *ic;
void *prev_buf;
fuse_fill_dir_t prev_filler;
};
static struct iconv *iconv_get(void)
{
return fuse_get_context()->private_data;
}
static int iconv_convpath(struct iconv *ic, const char *path, char **newpathp,
int fromfs)
{
size_t pathlen;
size_t newpathlen;
char *newpath;
size_t plen;
char *p;
size_t res;
int err;
if (path == NULL) {
*newpathp = NULL;
return 0;
}
pathlen = strlen(path);
newpathlen = pathlen * 4;
newpath = malloc(newpathlen + 1);
if (!newpath)
return -ENOMEM;
plen = newpathlen;
p = newpath;
pthread_mutex_lock(&ic->lock);
do {
res = iconv(fromfs ? ic->fromfs : ic->tofs, (char **) &path,
&pathlen, &p, &plen);
if (res == (size_t) -1) {
char *tmp;
size_t inc;
err = -EILSEQ;
if (errno != E2BIG)
goto err;
inc = (pathlen + 1) * 4;
newpathlen += inc;
tmp = realloc(newpath, newpathlen + 1);
err = -ENOMEM;
if (!tmp)
goto err;
p = tmp + (p - newpath);
plen += inc;
newpath = tmp;
}
} while (res == (size_t) -1);
pthread_mutex_unlock(&ic->lock);
*p = '\0';
*newpathp = newpath;
return 0;
err:
iconv(fromfs ? ic->fromfs : ic->tofs, NULL, NULL, NULL, NULL);
pthread_mutex_unlock(&ic->lock);
free(newpath);
return err;
}
static int iconv_getattr(const char *path, struct stat *stbuf)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_getattr(ic->next, newpath, stbuf);
free(newpath);
}
return err;
}
static int iconv_fgetattr(const char *path, struct stat *stbuf,
struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_fgetattr(ic->next, newpath, stbuf, fi);
free(newpath);
}
return err;
}
static int iconv_access(const char *path, int mask)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_access(ic->next, newpath, mask);
free(newpath);
}
return err;
}
static int iconv_readlink(const char *path, char *buf, size_t size)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_readlink(ic->next, newpath, buf, size);
if (!err) {
char *newlink;
err = iconv_convpath(ic, buf, &newlink, 1);
if (!err) {
strncpy(buf, newlink, size - 1);
buf[size - 1] = '\0';
free(newlink);
}
}
free(newpath);
}
return err;
}
static int iconv_opendir(const char *path, struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_opendir(ic->next, newpath, fi);
free(newpath);
}
return err;
}
static int iconv_dir_fill(void *buf, const char *name,
const struct stat *stbuf, off_t off)
{
struct iconv_dh *dh = buf;
char *newname;
int res = 0;
if (iconv_convpath(dh->ic, name, &newname, 1) == 0) {
res = dh->prev_filler(dh->prev_buf, newname, stbuf, off);
free(newname);
}
return res;
}
static int iconv_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
struct iconv_dh dh;
dh.ic = ic;
dh.prev_buf = buf;
dh.prev_filler = filler;
err = fuse_fs_readdir(ic->next, newpath, &dh, iconv_dir_fill,
offset, fi);
free(newpath);
}
return err;
}
static int iconv_releasedir(const char *path, struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_releasedir(ic->next, newpath, fi);
free(newpath);
}
return err;
}
static int iconv_mknod(const char *path, mode_t mode, dev_t rdev)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_mknod(ic->next, newpath, mode, rdev);
free(newpath);
}
return err;
}
static int iconv_mkdir(const char *path, mode_t mode)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_mkdir(ic->next, newpath, mode);
free(newpath);
}
return err;
}
static int iconv_unlink(const char *path)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_unlink(ic->next, newpath);
free(newpath);
}
return err;
}
static int iconv_rmdir(const char *path)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_rmdir(ic->next, newpath);
free(newpath);
}
return err;
}
static int iconv_symlink(const char *from, const char *to)
{
struct iconv *ic = iconv_get();
char *newfrom;
char *newto;
int err = iconv_convpath(ic, from, &newfrom, 0);
if (!err) {
err = iconv_convpath(ic, to, &newto, 0);
if (!err) {
err = fuse_fs_symlink(ic->next, newfrom, newto);
free(newto);
}
free(newfrom);
}
return err;
}
static int iconv_rename(const char *from, const char *to)
{
struct iconv *ic = iconv_get();
char *newfrom;
char *newto;
int err = iconv_convpath(ic, from, &newfrom, 0);
if (!err) {
err = iconv_convpath(ic, to, &newto, 0);
if (!err) {
err = fuse_fs_rename(ic->next, newfrom, newto);
free(newto);
}
free(newfrom);
}
return err;
}
static int iconv_link(const char *from, const char *to)
{
struct iconv *ic = iconv_get();
char *newfrom;
char *newto;
int err = iconv_convpath(ic, from, &newfrom, 0);
if (!err) {
err = iconv_convpath(ic, to, &newto, 0);
if (!err) {
err = fuse_fs_link(ic->next, newfrom, newto);
free(newto);
}
free(newfrom);
}
return err;
}
static int iconv_chmod(const char *path, mode_t mode)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_chmod(ic->next, newpath, mode);
free(newpath);
}
return err;
}
static int iconv_chown(const char *path, uid_t uid, gid_t gid)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_chown(ic->next, newpath, uid, gid);
free(newpath);
}
return err;
}
static int iconv_truncate(const char *path, off_t size)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_truncate(ic->next, newpath, size);
free(newpath);
}
return err;
}
static int iconv_ftruncate(const char *path, off_t size,
struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_ftruncate(ic->next, newpath, size, fi);
free(newpath);
}
return err;
}
static int iconv_utimens(const char *path, const struct timespec ts[2])
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_utimens(ic->next, newpath, ts);
free(newpath);
}
return err;
}
static int iconv_create(const char *path, mode_t mode,
struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_create(ic->next, newpath, mode, fi);
free(newpath);
}
return err;
}
static int iconv_open_file(const char *path, struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_open(ic->next, newpath, fi);
free(newpath);
}
return err;
}
static int iconv_read_buf(const char *path, struct fuse_bufvec **bufp,
size_t size, off_t offset, struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_read_buf(ic->next, newpath, bufp, size, offset, fi);
free(newpath);
}
return err;
}
static int iconv_write_buf(const char *path, struct fuse_bufvec *buf,
off_t offset, struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_write_buf(ic->next, newpath, buf, offset, fi);
free(newpath);
}
return err;
}
static int iconv_statfs(const char *path, struct statvfs *stbuf)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_statfs(ic->next, newpath, stbuf);
free(newpath);
}
return err;
}
static int iconv_flush(const char *path, struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_flush(ic->next, newpath, fi);
free(newpath);
}
return err;
}
static int iconv_release(const char *path, struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_release(ic->next, newpath, fi);
free(newpath);
}
return err;
}
static int iconv_fsync(const char *path, int isdatasync,
struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_fsync(ic->next, newpath, isdatasync, fi);
free(newpath);
}
return err;
}
static int iconv_fsyncdir(const char *path, int isdatasync,
struct fuse_file_info *fi)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_fsyncdir(ic->next, newpath, isdatasync, fi);
free(newpath);
}
return err;
}
static int iconv_setxattr(const char *path, const char *name,
const char *value, size_t size, int flags)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_setxattr(ic->next, newpath, name, value, size,
flags);
free(newpath);
}
return err;
}
static int iconv_getxattr(const char *path, const char *name, char *value,
size_t size)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_getxattr(ic->next, newpath, name, value, size);
free(newpath);
}
return err;
}
static int iconv_listxattr(const char *path, char *list, size_t size)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_listxattr(ic->next, newpath, list, size);
free(newpath);
}
return err;
}
static int iconv_removexattr(const char *path, const char *name)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_removexattr(ic->next, newpath, name);
free(newpath);
}
return err;
}
static int iconv_lock(const char *path, struct fuse_file_info *fi, int cmd,
struct flock *lock)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_lock(ic->next, newpath, fi, cmd, lock);
free(newpath);
}
return err;
}
static int iconv_flock(const char *path, struct fuse_file_info *fi, int op)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_flock(ic->next, newpath, fi, op);
free(newpath);
}
return err;
}
static int iconv_bmap(const char *path, size_t blocksize, uint64_t *idx)
{
struct iconv *ic = iconv_get();
char *newpath;
int err = iconv_convpath(ic, path, &newpath, 0);
if (!err) {
err = fuse_fs_bmap(ic->next, newpath, blocksize, idx);
free(newpath);
}
return err;
}
static void *iconv_init(struct fuse_conn_info *conn)
{
struct iconv *ic = iconv_get();
fuse_fs_init(ic->next, conn);
return ic;
}
static void iconv_destroy(void *data)
{
struct iconv *ic = data;
fuse_fs_destroy(ic->next);
iconv_close(ic->tofs);
iconv_close(ic->fromfs);
pthread_mutex_destroy(&ic->lock);
free(ic->from_code);
free(ic->to_code);
free(ic);
}
static const struct fuse_operations iconv_oper = {
.destroy = iconv_destroy,
.init = iconv_init,
.getattr = iconv_getattr,
.fgetattr = iconv_fgetattr,
.access = iconv_access,
.readlink = iconv_readlink,
.opendir = iconv_opendir,
.readdir = iconv_readdir,
.releasedir = iconv_releasedir,
.mknod = iconv_mknod,
.mkdir = iconv_mkdir,
.symlink = iconv_symlink,
.unlink = iconv_unlink,
.rmdir = iconv_rmdir,
.rename = iconv_rename,
.link = iconv_link,
.chmod = iconv_chmod,
.chown = iconv_chown,
.truncate = iconv_truncate,
.ftruncate = iconv_ftruncate,
.utimens = iconv_utimens,
.create = iconv_create,
.open = iconv_open_file,
.read_buf = iconv_read_buf,
.write_buf = iconv_write_buf,
.statfs = iconv_statfs,
.flush = iconv_flush,
.release = iconv_release,
.fsync = iconv_fsync,
.fsyncdir = iconv_fsyncdir,
.setxattr = iconv_setxattr,
.getxattr = iconv_getxattr,
.listxattr = iconv_listxattr,
.removexattr = iconv_removexattr,
.lock = iconv_lock,
.flock = iconv_flock,
.bmap = iconv_bmap,
.flag_nullpath_ok = 1,
.flag_nopath = 1,
};
static const struct fuse_opt iconv_opts[] = {
FUSE_OPT_KEY("-h", 0),
FUSE_OPT_KEY("--help", 0),
{ "from_code=%s", offsetof(struct iconv, from_code), 0 },
{ "to_code=%s", offsetof(struct iconv, to_code), 1 },
FUSE_OPT_END
};
static void iconv_help(void)
{
char *old = strdup(setlocale(LC_CTYPE, ""));
char *charmap = strdup(nl_langinfo(CODESET));
setlocale(LC_CTYPE, old);
free(old);
fprintf(stderr,
" -o from_code=CHARSET original encoding of file names (default: UTF-8)\n"
" -o to_code=CHARSET new encoding of the file names (default: %s)\n",
charmap);
free(charmap);
}
static int iconv_opt_proc(void *data, const char *arg, int key,
struct fuse_args *outargs)
{
(void) data; (void) arg; (void) outargs;
if (!key) {
iconv_help();
return -1;
}
return 1;
}
static struct fuse_fs *iconv_new(struct fuse_args *args,
struct fuse_fs *next[])
{
struct fuse_fs *fs;
struct iconv *ic;
char *old = NULL;
const char *from;
const char *to;
ic = calloc(1, sizeof(struct iconv));
if (ic == NULL) {
fprintf(stderr, "fuse-iconv: memory allocation failed\n");
return NULL;
}
if (fuse_opt_parse(args, ic, iconv_opts, iconv_opt_proc) == -1)
goto out_free;
if (!next[0] || next[1]) {
fprintf(stderr, "fuse-iconv: exactly one next filesystem required\n");
goto out_free;
}
from = ic->from_code ? ic->from_code : "UTF-8";
to = ic->to_code ? ic->to_code : "";
/* FIXME: detect charset equivalence? */
if (!to[0])
old = strdup(setlocale(LC_CTYPE, ""));
ic->tofs = iconv_open(from, to);
if (ic->tofs == (iconv_t) -1) {
fprintf(stderr, "fuse-iconv: cannot convert from %s to %s\n",
to, from);
goto out_free;
}
ic->fromfs = iconv_open(to, from);
if (ic->tofs == (iconv_t) -1) {
fprintf(stderr, "fuse-iconv: cannot convert from %s to %s\n",
from, to);
goto out_iconv_close_to;
}
if (old) {
setlocale(LC_CTYPE, old);
free(old);
}
ic->next = next[0];
fs = fuse_fs_new(&iconv_oper, sizeof(iconv_oper), ic);
if (!fs)
goto out_iconv_close_from;
return fs;
out_iconv_close_from:
iconv_close(ic->fromfs);
out_iconv_close_to:
iconv_close(ic->tofs);
out_free:
free(ic->from_code);
free(ic->to_code);
free(ic);
if (old) {
setlocale(LC_CTYPE, old);
free(old);
}
return NULL;
}
FUSE_REGISTER_MODULE(iconv, iconv_new);

697
libfuse/lib/modules/subdir.c
View File

@ -1,697 +0,0 @@
/*
fuse subdir module: offset paths with a base directory
Copyright (C) 2007 Miklos Szeredi <miklos@szeredi.hu>
This program can be distributed under the terms of the GNU LGPLv2.
See the file COPYING.LIB
*/
#define FUSE_USE_VERSION 26
#include <fuse.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <errno.h>
struct subdir {
char *base;
size_t baselen;
int rellinks;
struct fuse_fs *next;
};
static struct subdir *subdir_get(void)
{
return fuse_get_context()->private_data;
}
static int subdir_addpath(struct subdir *d, const char *path, char **newpathp)
{
char *newpath = NULL;
if (path != NULL) {
unsigned newlen = d->baselen + strlen(path);
newpath = malloc(newlen + 2);
if (!newpath)
return -ENOMEM;
if (path[0] == '/')
path++;
strcpy(newpath, d->base);
strcpy(newpath + d->baselen, path);
if (!newpath[0])
strcpy(newpath, ".");
}
*newpathp = newpath;
return 0;
}
static int subdir_getattr(const char *path, struct stat *stbuf)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_getattr(d->next, newpath, stbuf);
free(newpath);
}
return err;
}
static int subdir_fgetattr(const char *path, struct stat *stbuf,
struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_fgetattr(d->next, newpath, stbuf, fi);
free(newpath);
}
return err;
}
static int subdir_access(const char *path, int mask)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_access(d->next, newpath, mask);
free(newpath);
}
return err;
}
static int count_components(const char *p)
{
int ctr;
for (; *p == '/'; p++);
for (ctr = 0; *p; ctr++) {
for (; *p && *p != '/'; p++);
for (; *p == '/'; p++);
}
return ctr;
}
static void strip_common(const char **sp, const char **tp)
{
const char *s = *sp;
const char *t = *tp;
do {
for (; *s == '/'; s++);
for (; *t == '/'; t++);
*tp = t;
*sp = s;
for (; *s == *t && *s && *s != '/'; s++, t++);
} while ((*s == *t && *s) || (!*s && *t == '/') || (*s == '/' && !*t));
}
static void transform_symlink(struct subdir *d, const char *path,
char *buf, size_t size)
{
const char *l = buf;
size_t llen;
char *s;
int dotdots;
int i;
if (l[0] != '/' || d->base[0] != '/')
return;
strip_common(&l, &path);
if (l - buf < (long) d->baselen)
return;
dotdots = count_components(path);
if (!dotdots)
return;
dotdots--;
llen = strlen(l);
if (dotdots * 3 + llen + 2 > size)
return;
s = buf + dotdots * 3;
if (llen)
memmove(s, l, llen + 1);
else if (!dotdots)
strcpy(s, ".");
else
*s = '\0';
for (s = buf, i = 0; i < dotdots; i++, s += 3)
memcpy(s, "../", 3);
}
static int subdir_readlink(const char *path, char *buf, size_t size)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_readlink(d->next, newpath, buf, size);
if (!err && d->rellinks)
transform_symlink(d, newpath, buf, size);
free(newpath);
}
return err;
}
static int subdir_opendir(const char *path, struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_opendir(d->next, newpath, fi);
free(newpath);
}
return err;
}
static int subdir_readdir(const char *path, void *buf,
fuse_fill_dir_t filler, off_t offset,
struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_readdir(d->next, newpath, buf, filler, offset,
fi);
free(newpath);
}
return err;
}
static int subdir_releasedir(const char *path, struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_releasedir(d->next, newpath, fi);
free(newpath);
}
return err;
}
static int subdir_mknod(const char *path, mode_t mode, dev_t rdev)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_mknod(d->next, newpath, mode, rdev);
free(newpath);
}
return err;
}
static int subdir_mkdir(const char *path, mode_t mode)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_mkdir(d->next, newpath, mode);
free(newpath);
}
return err;
}
static int subdir_unlink(const char *path)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_unlink(d->next, newpath);
free(newpath);
}
return err;
}
static int subdir_rmdir(const char *path)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_rmdir(d->next, newpath);
free(newpath);
}
return err;
}
static int subdir_symlink(const char *from, const char *path)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_symlink(d->next, from, newpath);
free(newpath);
}
return err;
}
static int subdir_rename(const char *from, const char *to)
{
struct subdir *d = subdir_get();
char *newfrom;
char *newto;
int err = subdir_addpath(d, from, &newfrom);
if (!err) {
err = subdir_addpath(d, to, &newto);
if (!err) {
err = fuse_fs_rename(d->next, newfrom, newto);
free(newto);
}
free(newfrom);
}
return err;
}
static int subdir_link(const char *from, const char *to)
{
struct subdir *d = subdir_get();
char *newfrom;
char *newto;
int err = subdir_addpath(d, from, &newfrom);
if (!err) {
err = subdir_addpath(d, to, &newto);
if (!err) {
err = fuse_fs_link(d->next, newfrom, newto);
free(newto);
}
free(newfrom);
}
return err;
}
static int subdir_chmod(const char *path, mode_t mode)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_chmod(d->next, newpath, mode);
free(newpath);
}
return err;
}
static int subdir_chown(const char *path, uid_t uid, gid_t gid)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_chown(d->next, newpath, uid, gid);
free(newpath);
}
return err;
}
static int subdir_truncate(const char *path, off_t size)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_truncate(d->next, newpath, size);
free(newpath);
}
return err;
}
static int subdir_ftruncate(const char *path, off_t size,
struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_ftruncate(d->next, newpath, size, fi);
free(newpath);
}
return err;
}
static int subdir_utimens(const char *path, const struct timespec ts[2])
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_utimens(d->next, newpath, ts);
free(newpath);
}
return err;
}
static int subdir_create(const char *path, mode_t mode,
struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_create(d->next, newpath, mode, fi);
free(newpath);
}
return err;
}
static int subdir_open(const char *path, struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_open(d->next, newpath, fi);
free(newpath);
}
return err;
}
static int subdir_read_buf(const char *path, struct fuse_bufvec **bufp,
size_t size, off_t offset, struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_read_buf(d->next, newpath, bufp, size, offset, fi);
free(newpath);
}
return err;
}
static int subdir_write_buf(const char *path, struct fuse_bufvec *buf,
off_t offset, struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_write_buf(d->next, newpath, buf, offset, fi);
free(newpath);
}
return err;
}
static int subdir_statfs(const char *path, struct statvfs *stbuf)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_statfs(d->next, newpath, stbuf);
free(newpath);
}
return err;
}
static int subdir_flush(const char *path, struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_flush(d->next, newpath, fi);
free(newpath);
}
return err;
}
static int subdir_release(const char *path, struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_release(d->next, newpath, fi);
free(newpath);
}
return err;
}
static int subdir_fsync(const char *path, int isdatasync,
struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_fsync(d->next, newpath, isdatasync, fi);
free(newpath);
}
return err;
}
static int subdir_fsyncdir(const char *path, int isdatasync,
struct fuse_file_info *fi)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_fsyncdir(d->next, newpath, isdatasync, fi);
free(newpath);
}
return err;
}
static int subdir_setxattr(const char *path, const char *name,
const char *value, size_t size, int flags)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_setxattr(d->next, newpath, name, value, size,
flags);
free(newpath);
}
return err;
}
static int subdir_getxattr(const char *path, const char *name, char *value,
size_t size)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_getxattr(d->next, newpath, name, value, size);
free(newpath);
}
return err;
}
static int subdir_listxattr(const char *path, char *list, size_t size)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_listxattr(d->next, newpath, list, size);
free(newpath);
}
return err;
}
static int subdir_removexattr(const char *path, const char *name)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_removexattr(d->next, newpath, name);
free(newpath);
}
return err;
}
static int subdir_lock(const char *path, struct fuse_file_info *fi, int cmd,
struct flock *lock)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_lock(d->next, newpath, fi, cmd, lock);
free(newpath);
}
return err;
}
static int subdir_flock(const char *path, struct fuse_file_info *fi, int op)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_flock(d->next, newpath, fi, op);
free(newpath);
}
return err;
}
static int subdir_bmap(const char *path, size_t blocksize, uint64_t *idx)
{
struct subdir *d = subdir_get();
char *newpath;
int err = subdir_addpath(d, path, &newpath);
if (!err) {
err = fuse_fs_bmap(d->next, newpath, blocksize, idx);
free(newpath);
}
return err;
}
static void *subdir_init(struct fuse_conn_info *conn)
{
struct subdir *d = subdir_get();
fuse_fs_init(d->next, conn);
return d;
}
static void subdir_destroy(void *data)
{
struct subdir *d = data;
fuse_fs_destroy(d->next);
free(d->base);
free(d);
}
static const struct fuse_operations subdir_oper = {
.destroy = subdir_destroy,
.init = subdir_init,
.getattr = subdir_getattr,
.fgetattr = subdir_fgetattr,
.access = subdir_access,
.readlink = subdir_readlink,
.opendir = subdir_opendir,
.readdir = subdir_readdir,
.releasedir = subdir_releasedir,
.mknod = subdir_mknod,
.mkdir = subdir_mkdir,
.symlink = subdir_symlink,
.unlink = subdir_unlink,
.rmdir = subdir_rmdir,
.rename = subdir_rename,
.link = subdir_link,
.chmod = subdir_chmod,
.chown = subdir_chown,
.truncate = subdir_truncate,
.ftruncate = subdir_ftruncate,
.utimens = subdir_utimens,
.create = subdir_create,
.open = subdir_open,
.read_buf = subdir_read_buf,
.write_buf = subdir_write_buf,
.statfs = subdir_statfs,
.flush = subdir_flush,
.release = subdir_release,
.fsync = subdir_fsync,
.fsyncdir = subdir_fsyncdir,
.setxattr = subdir_setxattr,
.getxattr = subdir_getxattr,
.listxattr = subdir_listxattr,
.removexattr = subdir_removexattr,
.lock = subdir_lock,
.flock = subdir_flock,
.bmap = subdir_bmap,
.flag_nullpath_ok = 1,
.flag_nopath = 1,
};
static const struct fuse_opt subdir_opts[] = {
FUSE_OPT_KEY("-h", 0),
FUSE_OPT_KEY("--help", 0),
{ "subdir=%s", offsetof(struct subdir, base), 0 },
{ "rellinks", offsetof(struct subdir, rellinks), 1 },
{ "norellinks", offsetof(struct subdir, rellinks), 0 },
FUSE_OPT_END
};
static void subdir_help(void)
{
fprintf(stderr,
" -o subdir=DIR prepend this directory to all paths (mandatory)\n"
" -o [no]rellinks transform absolute symlinks to relative\n");
}
static int subdir_opt_proc(void *data, const char *arg, int key,
struct fuse_args *outargs)
{
(void) data; (void) arg; (void) outargs;
if (!key) {
subdir_help();
return -1;
}
return 1;
}
static struct fuse_fs *subdir_new(struct fuse_args *args,
struct fuse_fs *next[])
{
struct fuse_fs *fs;
struct subdir *d;
d = calloc(1, sizeof(struct subdir));
if (d == NULL) {
fprintf(stderr, "fuse-subdir: memory allocation failed\n");
return NULL;
}
if (fuse_opt_parse(args, d, subdir_opts, subdir_opt_proc) == -1)
goto out_free;
if (!next[0] || next[1]) {
fprintf(stderr, "fuse-subdir: exactly one next filesystem required\n");
goto out_free;
}
if (!d->base) {
fprintf(stderr, "fuse-subdir: missing 'subdir' option\n");
goto out_free;
}
if (d->base[0] && d->base[strlen(d->base)-1] != '/') {
char *tmp = realloc(d->base, strlen(d->base) + 2);
if (!tmp) {
fprintf(stderr, "fuse-subdir: memory allocation failed\n");
goto out_free;
}
d->base = tmp;
strcat(d->base, "/");
}
d->baselen = strlen(d->base);
d->next = next[0];
fs = fuse_fs_new(&subdir_oper, sizeof(subdir_oper), d);
if (!fs)
goto out_free;
return fs;
out_free:
free(d->base);
free(d);
return NULL;
}
FUSE_REGISTER_MODULE(subdir, subdir_new);
Write Preview
Loading…
Cancel
Save