New upstream version 1.3.0+git20220115

[sven/fuse-exfat.git] / fuse / main.c

diff --git a/fuse/main.c b/fuse/main.c
index fe5666beabab1fe0657ef670aa7ed357a8829fc3..3143693cb6048324ba4f196d1d269b445e9fd64b 100644 (file)
--- a/fuse/main.c
+++ b/fuse/main.c
@@ -2,11 +2,12 @@
        main.c (01.09.09)
        FUSE-based exFAT implementation. Requires FUSE 2.6 or later.
 
        main.c (01.09.09)
        FUSE-based exFAT implementation. Requires FUSE 2.6 or later.
 

-       Copyright (C) 2009, 2010  Andrew Nayenko
+       Free exFAT implementation.
+       Copyright (C) 2010-2018  Andrew Nayenko

 
 

-       This program is free software: you can redistribute it and/or modify
+       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
        it under the terms of the GNU General Public License as published by

-       the Free Software Foundation, either version 3 of the License, or
+       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,
        (at your option) any later version.
 
        This program is distributed in the hope that it will be useful,


@@ -14,31 +15,33 @@
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
 
        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, see <http://www.gnu.org/licenses/>.
+       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, Fifth Floor, Boston, MA 02110-1301 USA.

 */
 
 */
 

+#include <exfat.h>
+#define FUSE_USE_VERSION 26

 #include <fuse.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <fuse.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

-#include <exfat.h>

 #include <inttypes.h>
 #include <limits.h>
 #include <sys/types.h>
 #include <pwd.h>
 #include <unistd.h>
 
 #include <inttypes.h>
 #include <limits.h>
 #include <sys/types.h>
 #include <pwd.h>
 #include <unistd.h>
 

-#define exfat_debug(format, ...)
+#ifndef DEBUG
+       #define exfat_debug(format, ...) do {} while (0)
+#endif

 
 #if !defined(FUSE_VERSION) || (FUSE_VERSION < 26)
        #error FUSE 2.6 or later is required
 #endif
 
 
 #if !defined(FUSE_VERSION) || (FUSE_VERSION < 26)
        #error FUSE 2.6 or later is required
 #endif
 

-const char* default_options = "allow_other,blkdev";
-

 struct exfat ef;
 
 static struct exfat_node* get_node(const struct fuse_file_info* fi)
 struct exfat ef;
 
 static struct exfat_node* get_node(const struct fuse_file_info* fi)


@@ -49,6 +52,7 @@ static struct exfat_node* get_node(const struct fuse_file_info* fi)
 static void set_node(struct fuse_file_info* fi, struct exfat_node* node)
 {
        fi->fh = (uint64_t) (size_t) node;
 static void set_node(struct fuse_file_info* fi, struct exfat_node* node)
 {
        fi->fh = (uint64_t) (size_t) node;

+       fi->keep_cache = 1;

 }
 
 static int fuse_exfat_getattr(const char* path, struct stat* stbuf)
 }
 
 static int fuse_exfat_getattr(const char* path, struct stat* stbuf)


@@ -56,7 +60,7 @@ static int fuse_exfat_getattr(const char* path, struct stat* stbuf)
        struct exfat_node* node;
        int rc;
 
        struct exfat_node* node;
        int rc;
 

-       exfat_debug("[fuse_exfat_getattr] %s", path);
+       exfat_debug("[%s] %s", __func__, path);

 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)
 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)


@@ -72,35 +76,44 @@ static int fuse_exfat_truncate(const char* path, off_t size)
        struct exfat_node* node;
        int rc;
 
        struct exfat_node* node;
        int rc;
 

-       exfat_debug("[fuse_exfat_truncate] %s, %"PRIu64, path, (uint64_t) size);
+       exfat_debug("[%s] %s, %"PRId64, __func__, path, size);

 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)
                return rc;
 
 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)
                return rc;
 

-       rc = exfat_truncate(&ef, node, size);
+       rc = exfat_truncate(&ef, node, size, true);
+       if (rc != 0)
+       {
+               exfat_flush_node(&ef, node);    /* ignore return code */
+               exfat_put_node(&ef, node);
+               return rc;
+       }
+       rc = exfat_flush_node(&ef, node);

        exfat_put_node(&ef, node);
        return rc;
 }
 
 static int fuse_exfat_readdir(const char* path, void* buffer,
        exfat_put_node(&ef, node);
        return rc;
 }
 
 static int fuse_exfat_readdir(const char* path, void* buffer,

-               fuse_fill_dir_t filler, off_t offset, struct fuse_file_info* fi)
+               fuse_fill_dir_t filler, UNUSED off_t offset,
+               UNUSED struct fuse_file_info* fi)

 {
        struct exfat_node* parent;
        struct exfat_node* node;
        struct exfat_iterator it;
        int rc;
 {
        struct exfat_node* parent;
        struct exfat_node* node;
        struct exfat_iterator it;
        int rc;

-       char name[EXFAT_NAME_MAX + 1];
+       char name[EXFAT_UTF8_NAME_BUFFER_MAX];
+       struct stat stbuf;

 
 

-       exfat_debug("[fuse_exfat_readdir] %s", path);
+       exfat_debug("[%s] %s", __func__, path);

 
        rc = exfat_lookup(&ef, &parent, path);
        if (rc != 0)
                return rc;
 
        rc = exfat_lookup(&ef, &parent, path);
        if (rc != 0)
                return rc;

-       if (!(parent->flags & EXFAT_ATTRIB_DIR))
+       if (!(parent->attrib & EXFAT_ATTRIB_DIR))

        {
                exfat_put_node(&ef, parent);
        {
                exfat_put_node(&ef, parent);

-               exfat_error("`%s' is not a directory (0x%x)", path, parent->flags);
+               exfat_error("'%s' is not a directory (%#hx)", path, parent->attrib);

                return -ENOTDIR;
        }
 
                return -ENOTDIR;
        }
 


@@ -111,16 +124,17 @@ static int fuse_exfat_readdir(const char* path, void* buffer,
        if (rc != 0)
        {
                exfat_put_node(&ef, parent);
        if (rc != 0)
        {
                exfat_put_node(&ef, parent);

-               exfat_error("failed to open directory `%s'", path);
+               exfat_error("failed to open directory '%s'", path);

                return rc;
        }
                return rc;
        }

-       while ((node = exfat_readdir(&ef, &it)))
+       while ((node = exfat_readdir(&it)))

        {
        {

-               exfat_get_name(node, name, EXFAT_NAME_MAX);
-               exfat_debug("[fuse_exfat_readdir] %s: %s, %"PRIu64" bytes, cluster %u",
-                               name, IS_CONTIGUOUS(*node) ? "contiguous" : "fragmented",
-                               (uint64_t) node->size, node->start_cluster);
-               filler(buffer, name, NULL, 0);
+               exfat_get_name(node, name);
+               exfat_debug("[%s] %s: %s, %"PRId64" bytes, cluster 0x%x", __func__,
+                               name, node->is_contiguous ? "contiguous" : "fragmented",
+                               node->size, node->start_cluster);
+               exfat_stat(&ef, node, &stbuf);
+               filler(buffer, name, &stbuf, 0);

                exfat_put_node(&ef, node);
        }
        exfat_closedir(&ef, &it);
                exfat_put_node(&ef, node);
        }
        exfat_closedir(&ef, &it);


@@ -133,34 +147,87 @@ static int fuse_exfat_open(const char* path, struct fuse_file_info* fi)
        struct exfat_node* node;
        int rc;
 
        struct exfat_node* node;
        int rc;
 

-       exfat_debug("[fuse_exfat_open] %s", path);
+       exfat_debug("[%s] %s", __func__, path);

 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)
                return rc;
        set_node(fi, node);
 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)
                return rc;
        set_node(fi, node);

-       fi->keep_cache = 1;

        return 0;
 }
 
        return 0;
 }
 

-static int fuse_exfat_release(const char* path, struct fuse_file_info* fi)
+static int fuse_exfat_create(const char* path, UNUSED mode_t mode,
+               struct fuse_file_info* fi)

 {
 {

-       exfat_put_node(&ef, get_node(fi));
+       struct exfat_node* node;
+       int rc;
+
+       exfat_debug("[%s] %s 0%ho", __func__, path, mode);
+
+       rc = exfat_mknod(&ef, path);
+       if (rc != 0)
+               return rc;
+       rc = exfat_lookup(&ef, &node, path);
+       if (rc != 0)
+               return rc;
+       set_node(fi, node);

        return 0;
 }
 
        return 0;
 }
 

-static int fuse_exfat_read(const char* path, char* buffer, size_t size,
-               off_t offset, struct fuse_file_info* fi)
+static int fuse_exfat_release(UNUSED const char* path,
+               struct fuse_file_info* fi)
+{
+       /*
+          This handler is called by FUSE on close() syscall. If the FUSE
+          implementation does not call flush handler, we will flush node here.
+          But in this case we will not be able to return an error to the caller.
+          See fuse_exfat_flush() below.
+       */
+       exfat_debug("[%s] %s", __func__, path);
+       exfat_flush_node(&ef, get_node(fi));
+       exfat_put_node(&ef, get_node(fi));
+       return 0; /* FUSE ignores this return value */
+}
+
+static int fuse_exfat_flush(UNUSED const char* path, struct fuse_file_info* fi)
+{
+       /*
+          This handler may be called by FUSE on close() syscall. FUSE also deals
+          with removals of open files, so we don't free clusters on close but
+          only on rmdir and unlink. If the FUSE implementation does not call this
+          handler we will flush node on release. See fuse_exfat_relase() above.
+       */
+       exfat_debug("[%s] %s", __func__, path);
+       return exfat_flush_node(&ef, get_node(fi));
+}
+
+static int fuse_exfat_fsync(UNUSED const char* path, UNUSED int datasync,
+               UNUSED struct fuse_file_info *fi)

 {
 {

-       exfat_debug("[fuse_exfat_read] %s (%zu bytes)", path, size);
-       return exfat_read(&ef, get_node(fi), buffer, size, offset);
+       int rc;
+
+       exfat_debug("[%s] %s", __func__, path);
+       rc = exfat_flush_nodes(&ef);
+       if (rc != 0)
+               return rc;
+       rc = exfat_flush(&ef);
+       if (rc != 0)
+               return rc;
+       return exfat_fsync(ef.dev);
+}
+
+static int fuse_exfat_read(UNUSED const char* path, char* buffer,
+               size_t size, off_t offset, struct fuse_file_info* fi)
+{
+       exfat_debug("[%s] %s (%zu bytes)", __func__, path, size);
+       return exfat_generic_pread(&ef, get_node(fi), buffer, size, offset);

 }
 
 }
 

-static int fuse_exfat_write(const char* path, const char* buffer, size_t size,
-               off_t offset, struct fuse_file_info* fi)
+static int fuse_exfat_write(UNUSED const char* path, const char* buffer,
+               size_t size, off_t offset, struct fuse_file_info* fi)

 {
 {

-       exfat_debug("[fuse_exfat_write] %s (%zu bytes)", path, size);
-       return exfat_write(&ef, get_node(fi), buffer, size, offset);
+       exfat_debug("[%s] %s (%zu bytes)", __func__, path, size);
+       return exfat_generic_pwrite(&ef, get_node(fi), buffer, size, offset);

 }
 
 static int fuse_exfat_unlink(const char* path)
 }
 
 static int fuse_exfat_unlink(const char* path)


@@ -168,7 +235,7 @@ static int fuse_exfat_unlink(const char* path)
        struct exfat_node* node;
        int rc;
 
        struct exfat_node* node;
        int rc;
 

-       exfat_debug("[fuse_exfat_unlink] %s", path);
+       exfat_debug("[%s] %s", __func__, path);

 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)
 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)


@@ -176,7 +243,9 @@ static int fuse_exfat_unlink(const char* path)
 
        rc = exfat_unlink(&ef, node);
        exfat_put_node(&ef, node);
 
        rc = exfat_unlink(&ef, node);
        exfat_put_node(&ef, node);

-       return rc;
+       if (rc != 0)
+               return rc;
+       return exfat_cleanup_node(&ef, node);

 }
 
 static int fuse_exfat_rmdir(const char* path)
 }
 
 static int fuse_exfat_rmdir(const char* path)


@@ -184,7 +253,7 @@ static int fuse_exfat_rmdir(const char* path)
        struct exfat_node* node;
        int rc;
 
        struct exfat_node* node;
        int rc;
 

-       exfat_debug("[fuse_exfat_rmdir] %s", path);
+       exfat_debug("[%s] %s", __func__, path);

 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)
 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)


@@ -192,24 +261,27 @@ static int fuse_exfat_rmdir(const char* path)
 
        rc = exfat_rmdir(&ef, node);
        exfat_put_node(&ef, node);
 
        rc = exfat_rmdir(&ef, node);
        exfat_put_node(&ef, node);

-       return rc;
+       if (rc != 0)
+               return rc;
+       return exfat_cleanup_node(&ef, node);

 }
 
 }
 

-static int fuse_exfat_mknod(const char* path, mode_t mode, dev_t dev)
+static int fuse_exfat_mknod(const char* path, UNUSED mode_t mode,
+               UNUSED dev_t dev)

 {
 {

-       exfat_debug("[fuse_exfat_mknod] %s", path);
+       exfat_debug("[%s] %s 0%ho", __func__, path, mode);

        return exfat_mknod(&ef, path);
 }
 
        return exfat_mknod(&ef, path);
 }
 

-static int fuse_exfat_mkdir(const char* path, mode_t mode)
+static int fuse_exfat_mkdir(const char* path, UNUSED mode_t mode)

 {
 {

-       exfat_debug("[fuse_exfat_mkdir] %s", path);
+       exfat_debug("[%s] %s 0%ho", __func__, path, mode);

        return exfat_mkdir(&ef, path);
 }
 
 static int fuse_exfat_rename(const char* old_path, const char* new_path)
 {
        return exfat_mkdir(&ef, path);
 }
 
 static int fuse_exfat_rename(const char* old_path, const char* new_path)
 {

-       exfat_debug("[fuse_exfat_rename] %s => %s", old_path, new_path);
+       exfat_debug("[%s] %s => %s", __func__, old_path, new_path);

        return exfat_rename(&ef, old_path, new_path);
 }
 
        return exfat_rename(&ef, old_path, new_path);
 }
 


@@ -218,19 +290,41 @@ static int fuse_exfat_utimens(const char* path, const struct timespec tv[2])
        struct exfat_node* node;
        int rc;
 
        struct exfat_node* node;
        int rc;
 

-       exfat_debug("[fuse_exfat_utimens] %s", path);
+       exfat_debug("[%s] %s", __func__, path);

 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)
                return rc;
 
        exfat_utimes(node, tv);
 
        rc = exfat_lookup(&ef, &node, path);
        if (rc != 0)
                return rc;
 
        exfat_utimes(node, tv);

+       rc = exfat_flush_node(&ef, node);

        exfat_put_node(&ef, node);
        exfat_put_node(&ef, node);

+       return rc;
+}
+
+static int fuse_exfat_chmod(UNUSED const char* path, mode_t mode)
+{
+       const mode_t VALID_MODE_MASK = S_IFREG | S_IFDIR |
+                       S_IRWXU | S_IRWXG | S_IRWXO;
+
+       exfat_debug("[%s] %s 0%ho", __func__, path, mode);
+       if (mode & ~VALID_MODE_MASK)
+               return -EPERM;
+       return 0;
+}
+
+static int fuse_exfat_chown(UNUSED const char* path, uid_t uid, gid_t gid)
+{
+       exfat_debug("[%s] %s %u:%u", __func__, path, uid, gid);
+       if (uid != ef.uid || gid != ef.gid)
+               return -EPERM;

        return 0;
 }
 
        return 0;
 }
 

-static int fuse_exfat_statfs(const char* path, struct statvfs* sfs)
+static int fuse_exfat_statfs(UNUSED const char* path, struct statvfs* sfs)

 {
 {

+       exfat_debug("[%s]", __func__);
+

        sfs->f_bsize = CLUSTER_SIZE(*ef.sb);
        sfs->f_frsize = CLUSTER_SIZE(*ef.sb);
        sfs->f_blocks = le64_to_cpu(ef.sb->sector_count) >> ef.sb->spc_bits;
        sfs->f_bsize = CLUSTER_SIZE(*ef.sb);
        sfs->f_frsize = CLUSTER_SIZE(*ef.sb);
        sfs->f_blocks = le64_to_cpu(ef.sb->sector_count) >> ef.sb->spc_bits;


@@ -244,21 +338,35 @@ static int fuse_exfat_statfs(const char* path, struct statvfs* sfs)
           b) no such thing as inode;
           So here we assume that inode = cluster.
        */
           b) no such thing as inode;
           So here we assume that inode = cluster.
        */

-       sfs->f_files = (sfs->f_blocks - sfs->f_bfree) >> ef.sb->spc_bits;
+       sfs->f_files = le32_to_cpu(ef.sb->cluster_count);

        sfs->f_favail = sfs->f_bfree >> ef.sb->spc_bits;
        sfs->f_ffree = sfs->f_bavail;
 
        return 0;
 }
 
        sfs->f_favail = sfs->f_bfree >> ef.sb->spc_bits;
        sfs->f_ffree = sfs->f_bavail;
 
        return 0;
 }
 

-static void fuse_exfat_destroy(void* unused)
+static void* fuse_exfat_init(struct fuse_conn_info* fci)

 {
 {

+       exfat_debug("[%s]", __func__);
+#ifdef FUSE_CAP_BIG_WRITES
+       fci->want |= FUSE_CAP_BIG_WRITES;
+#endif
+
+       /* mark super block as dirty; failure isn't a big deal */
+       exfat_soil_super_block(&ef);
+
+       return NULL;
+}
+
+static void fuse_exfat_destroy(UNUSED void* unused)
+{
+       exfat_debug("[%s]", __func__);

        exfat_unmount(&ef);
 }
 
 static void usage(const char* prog)
 {
        exfat_unmount(&ef);
 }
 
 static void usage(const char* prog)
 {

-       fprintf(stderr, "Usage: %s [-d] [-o options] [-v] <device> <dir>\n", prog);
+       fprintf(stderr, "Usage: %s [-d] [-o options] [-V] <device> <dir>\n", prog);

        exit(1);
 }
 
        exit(1);
 }
 


@@ -268,7 +376,11 @@ static struct fuse_operations fuse_exfat_ops =
        .truncate       = fuse_exfat_truncate,
        .readdir        = fuse_exfat_readdir,
        .open           = fuse_exfat_open,
        .truncate       = fuse_exfat_truncate,
        .readdir        = fuse_exfat_readdir,
        .open           = fuse_exfat_open,

+       .create         = fuse_exfat_create,

        .release        = fuse_exfat_release,
        .release        = fuse_exfat_release,

+       .flush          = fuse_exfat_flush,
+       .fsync          = fuse_exfat_fsync,
+       .fsyncdir       = fuse_exfat_fsync,

        .read           = fuse_exfat_read,
        .write          = fuse_exfat_write,
        .unlink         = fuse_exfat_unlink,
        .read           = fuse_exfat_read,
        .write          = fuse_exfat_write,
        .unlink         = fuse_exfat_unlink,


@@ -277,13 +389,17 @@ static struct fuse_operations fuse_exfat_ops =
        .mkdir          = fuse_exfat_mkdir,
        .rename         = fuse_exfat_rename,
        .utimens        = fuse_exfat_utimens,
        .mkdir          = fuse_exfat_mkdir,
        .rename         = fuse_exfat_rename,
        .utimens        = fuse_exfat_utimens,

+       .chmod          = fuse_exfat_chmod,
+       .chown          = fuse_exfat_chown,

        .statfs         = fuse_exfat_statfs,
        .statfs         = fuse_exfat_statfs,

+       .init           = fuse_exfat_init,

        .destroy        = fuse_exfat_destroy,
 };
 
 static char* add_option(char* options, const char* name, const char* value)
 {
        size_t size;
        .destroy        = fuse_exfat_destroy,
 };
 
 static char* add_option(char* options, const char* name, const char* value)
 {
        size_t size;

+       char* optionsf = options;

 
        if (value)
                size = strlen(options) + strlen(name) + strlen(value) + 3;
 
        if (value)
                size = strlen(options) + strlen(name) + strlen(value) + 3;


@@ -293,6 +409,7 @@ static char* add_option(char* options, const char* name, const char* value)
        options = realloc(options, size);
        if (options == NULL)
        {
        options = realloc(options, size);
        if (options == NULL)
        {

+               free(optionsf);

                exfat_error("failed to reallocate options string");
                return NULL;
        }
                exfat_error("failed to reallocate options string");
                return NULL;
        }


@@ -306,19 +423,42 @@ static char* add_option(char* options, const char* name, const char* value)
        return options;
 }
 
        return options;
 }
 

+static void escape(char* escaped, const char* orig)
+{
+       do
+       {
+               if (*orig == ',' || *orig == '\\')
+                       *escaped++ = '\\';
+       }
+       while ((*escaped++ = *orig++));
+}
+

 static char* add_fsname_option(char* options, const char* spec)
 {
 static char* add_fsname_option(char* options, const char* spec)
 {

-       char spec_abs[PATH_MAX];
+       /* escaped string cannot be more than twice as big as the original one */
+       char* escaped = malloc(strlen(spec) * 2 + 1);

 
 

-       if (realpath(spec, spec_abs) == NULL)
+       if (escaped == NULL)

        {
                free(options);
        {
                free(options);

-               exfat_error("failed to get absolute path for `%s'", spec);
+               exfat_error("failed to allocate escaped string for %s", spec);

                return NULL;
        }
                return NULL;
        }

-       return add_option(options, "fsname", spec_abs);
+
+       /* on some platforms (e.g. Android, Solaris) device names can contain
+          commas */
+       escape(escaped, spec);
+       options = add_option(options, "fsname", escaped);
+       free(escaped);
+       return options;

 }
 
 }
 

+static char* add_ro_option(char* options, bool ro)
+{
+       return ro ? add_option(options, "ro", NULL) : options;
+}
+
+#if defined(__linux__)

 static char* add_user_option(char* options)
 {
        struct passwd* pw;
 static char* add_user_option(char* options)
 {
        struct passwd* pw;


@@ -335,7 +475,9 @@ static char* add_user_option(char* options)
        }
        return add_option(options, "user", pw->pw_name);
 }
        }
        return add_option(options, "user", pw->pw_name);
 }

+#endif

 
 

+#if defined(__linux__)

 static char* add_blksize_option(char* options, long cluster_size)
 {
        long page_size = sysconf(_SC_PAGESIZE);
 static char* add_blksize_option(char* options, long cluster_size)
 {
        long page_size = sysconf(_SC_PAGESIZE);


@@ -347,151 +489,156 @@ static char* add_blksize_option(char* options, long cluster_size)
        snprintf(blksize, sizeof(blksize), "%ld", MIN(page_size, cluster_size));
        return add_option(options, "blksize", blksize);
 }
        snprintf(blksize, sizeof(blksize), "%ld", MIN(page_size, cluster_size));
        return add_option(options, "blksize", blksize);
 }

+#endif

 
 

-static char* add_fuse_options(char* options, const char* spec)
+static char* add_fuse_options(char* options, const char* spec, bool ro)

 {
        options = add_fsname_option(options, spec);
        if (options == NULL)
                return NULL;
 {
        options = add_fsname_option(options, spec);
        if (options == NULL)
                return NULL;

+       options = add_ro_option(options, ro);
+       if (options == NULL)
+               return NULL;
+#if defined(__linux__)

        options = add_user_option(options);
        if (options == NULL)
                return NULL;
        options = add_blksize_option(options, CLUSTER_SIZE(*ef.sb));
        if (options == NULL)
                return NULL;
        options = add_user_option(options);
        if (options == NULL)
                return NULL;
        options = add_blksize_option(options, CLUSTER_SIZE(*ef.sb));
        if (options == NULL)
                return NULL;

-
+#endif

        return options;
 }
 
        return options;
 }
 

+static char* add_passthrough_fuse_options(char* fuse_options,
+               const char* options)
+{
+       const char* passthrough_list[] =
+       {
+#if defined(__FreeBSD__)
+               "automounted",
+#endif
+               "nonempty",
+               NULL
+       };
+       int i;
+
+       for (i = 0; passthrough_list[i] != NULL; i++)
+               if (exfat_match_option(options, passthrough_list[i]))
+               {
+                       fuse_options = add_option(fuse_options, passthrough_list[i], NULL);
+                       if (fuse_options == NULL)
+                               return NULL;
+               }
+
+       return fuse_options;
+}
+
+static int fuse_exfat_main(char* mount_options, char* mount_point)
+{
+       char* argv[] = {"exfat", "-s", "-o", mount_options, mount_point, NULL};
+       return fuse_main(sizeof(argv) / sizeof(argv[0]) - 1, argv,
+                       &fuse_exfat_ops, NULL);
+}
+

 int main(int argc, char* argv[])
 {
 int main(int argc, char* argv[])
 {

-       struct fuse_args mount_args = FUSE_ARGS_INIT(0, NULL);
-       struct fuse_args newfs_args = FUSE_ARGS_INIT(0, NULL);

        const char* spec = NULL;
        const char* spec = NULL;

-       const char* mount_point = NULL;
-       char* mount_options;
-       int debug = 0;
-       struct fuse_chan* fc = NULL;
-       struct fuse* fh = NULL;
-       char** pp;
-
-       printf("FUSE exfat %u.%u.%u\n",
-                       EXFAT_VERSION_MAJOR, EXFAT_VERSION_MINOR, EXFAT_VERSION_PATCH);
-
-       mount_options = strdup(default_options);
-       if (mount_options == NULL)
+       char* mount_point = NULL;
+       char* fuse_options;
+       char* exfat_options;
+       int opt;
+       int rc;
+
+       printf("FUSE exfat %s\n", VERSION);
+
+       fuse_options = strdup("allow_other,"
+#if defined(__linux__) || defined(__FreeBSD__)
+                       "big_writes,"
+#endif
+#if defined(__linux__)
+                       "blkdev,"
+#endif
+                       "default_permissions");
+       exfat_options = strdup("ro_fallback");
+       if (fuse_options == NULL || exfat_options == NULL)

        {
        {

+               free(fuse_options);
+               free(exfat_options);

                exfat_error("failed to allocate options string");
                return 1;
        }
 
                exfat_error("failed to allocate options string");
                return 1;
        }
 

-       for (pp = argv + 1; *pp; pp++)
+       while ((opt = getopt(argc, argv, "dno:Vv")) != -1)

        {
        {

-               if (strcmp(*pp, "-o") == 0)
+               switch (opt)

                {
                {

-                       pp++;
-                       if (*pp == NULL)
-                               usage(argv[0]);
-                       mount_options = add_option(mount_options, *pp, NULL);
-                       if (mount_options == NULL)
+               case 'd':
+                       fuse_options = add_option(fuse_options, "debug", NULL);
+                       if (fuse_options == NULL)
+                       {
+                               free(exfat_options);

                                return 1;
                                return 1;

-               }
-               else if (strcmp(*pp, "-d") == 0)
-                       debug = 1;
-               else if (strcmp(*pp, "-v") == 0)
-               {
-                       free(mount_options);
-                       puts("Copyright (C) 2009  Andrew Nayenko");
+                       }
+                       break;
+               case 'n':
+                       break;
+               case 'o':
+                       exfat_options = add_option(exfat_options, optarg, NULL);
+                       if (exfat_options == NULL)
+                       {
+                               free(fuse_options);
+                               return 1;
+                       }
+                       fuse_options = add_passthrough_fuse_options(fuse_options, optarg);
+                       if (fuse_options == NULL)
+                       {
+                               free(exfat_options);
+                               return 1;
+                       }
+                       break;
+               case 'V':
+                       free(exfat_options);
+                       free(fuse_options);
+                       puts("Copyright (C) 2010-2018  Andrew Nayenko");

                        return 0;
                        return 0;

-               }
-               else if (spec == NULL)
-                       spec = *pp;
-               else if (mount_point == NULL)
-                       mount_point = *pp;
-               else
-               {
-                       free(mount_options);
+               case 'v':
+                       break;
+               default:
+                       free(exfat_options);
+                       free(fuse_options);

                        usage(argv[0]);
                        usage(argv[0]);

+                       break;

                }
        }
                }
        }

-       if (spec == NULL || mount_point == NULL)
+       if (argc - optind != 2)

        {
        {

-               free(mount_options);
+               free(exfat_options);
+               free(fuse_options);

                usage(argv[0]);
        }
                usage(argv[0]);
        }

+       spec = argv[optind];
+       mount_point = argv[optind + 1];

 
 

-       if (exfat_mount(&ef, spec, mount_options) != 0)
-       {
-               free(mount_options);
-               return 1;
-       }
-
-       mount_options = add_fuse_options(mount_options, spec);
-       if (mount_options == NULL)
-       {
-               exfat_unmount(&ef);
-               return 1;
-       }
-
-       /* create arguments for fuse_mount() */
-       if (fuse_opt_add_arg(&mount_args, "exfat") != 0 ||
-               fuse_opt_add_arg(&mount_args, "-o") != 0 ||
-               fuse_opt_add_arg(&mount_args, mount_options) != 0)
-       {
-               exfat_unmount(&ef);
-               free(mount_options);
-               return 1;
-       }
-
-       free(mount_options);
-
-       /* create FUSE mount point */
-       fc = fuse_mount(mount_point, &mount_args);
-       fuse_opt_free_args(&mount_args);
-       if (fc == NULL)
-       {
-               exfat_unmount(&ef);
-               return 1;
-       }
-
-       /* create arguments for fuse_new() */
-       if (fuse_opt_add_arg(&newfs_args, "") != 0 ||
-               (debug && fuse_opt_add_arg(&newfs_args, "-d") != 0))
+       if (exfat_mount(&ef, spec, exfat_options) != 0)

        {
        {

-               fuse_unmount(mount_point, fc);
-               exfat_unmount(&ef);
+               free(exfat_options);
+               free(fuse_options);

                return 1;
        }
 
                return 1;
        }
 

-       /* create new FUSE file system */
-       fh = fuse_new(fc, &newfs_args, &fuse_exfat_ops,
-                       sizeof(struct fuse_operations), NULL);
-       fuse_opt_free_args(&newfs_args);
-       if (fh == NULL)
-       {
-               fuse_unmount(mount_point, fc);
-               exfat_unmount(&ef);
-               return 1;
-       }
+       free(exfat_options);

 
 

-       /* exit session on HUP, TERM and INT signals and ignore PIPE signal */
-       if (fuse_set_signal_handlers(fuse_get_session(fh)))
+       fuse_options = add_fuse_options(fuse_options, spec, ef.ro != 0);
+       if (fuse_options == NULL)

        {
        {

-               fuse_unmount(mount_point, fc);
-               fuse_destroy(fh);

                exfat_unmount(&ef);
                return 1;
        }
 
                exfat_unmount(&ef);
                return 1;
        }
 

-       /* go to background unless "-d" option is passed */
-       fuse_daemonize(debug);
-
-       /* FUSE main loop */
-       fuse_loop(fh);
+       /* let FUSE do all its wizardry */
+       rc = fuse_exfat_main(fuse_options, mount_point);

 
 

-       /* it's quite illogical but fuse_unmount() must be called BEFORE
-          fuse_destroy() */
-       fuse_unmount(mount_point, fc);
-       fuse_destroy(fh);
-       return 0;
+       free(fuse_options);
+       return rc;

 }
 }