Handle I/O errors in exfat_put_node().

[android-x86/external-exfat.git] / fuse / main.c

diff --git a/fuse/main.c b/fuse/main.c
index 284ec23..825fa19 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.
 
+       Free exFAT implementation.
        Copyright (C) 2010-2013  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
-       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,
@@ -14,8 +15,9 @@
        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.
 */
 
 #define FUSE_USE_VERSION 26
@@ -39,11 +41,7 @@
 #endif
 
 const char* default_options = "ro_fallback,allow_other,blkdev,big_writes,"
-               "defer_permissions"
-#ifdef __APPLE__
-               ",quiet"
-#endif
-               ;
+               "defer_permissions";
 
 struct exfat ef;
 
@@ -85,6 +83,13 @@ static int fuse_exfat_truncate(const char* path, off_t size)
                return rc;
 
        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;
 }
@@ -96,7 +101,7 @@ static int fuse_exfat_readdir(const char* path, void* buffer,
        struct exfat_node* node;
        struct exfat_iterator it;
        int rc;
-       char name[EXFAT_NAME_MAX + 1];
+       char name[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
 
        exfat_debug("[%s] %s", __func__, path);
 
@@ -122,7 +127,7 @@ static int fuse_exfat_readdir(const char* path, void* buffer,
        }
        while ((node = exfat_readdir(&ef, &it)))
        {
-               exfat_get_name(node, name, EXFAT_NAME_MAX);
+               exfat_get_name(node, name, sizeof(name) - 1);
                exfat_debug("[%s] %s: %s, %"PRId64" bytes, cluster 0x%x", __func__,
                                name, IS_CONTIGUOUS(*node) ? "contiguous" : "fragmented",
                                node->size, node->start_cluster);
@@ -153,7 +158,30 @@ static int fuse_exfat_release(const char* path, struct fuse_file_info* fi)
 {
        exfat_debug("[%s] %s", __func__, path);
        exfat_put_node(&ef, get_node(fi));
-       return 0;
+       return 0; /* FUSE ignores this return value */
+}
+
+static int fuse_exfat_flush(const char* path, struct fuse_file_info* fi)
+{
+       /*
+          This handler is called by FUSE on close(). FUSE also deals with removals
+          of open files, so we don't free clusters here but only on rmdir and
+          unlink.
+       */
+       exfat_debug("[%s] %s", __func__, path);
+       return exfat_flush_node(&ef, get_node(fi));
+}
+
+static int fuse_exfat_fsync(const char* path, int datasync,
+               struct fuse_file_info *fi)
+{
+       int rc;
+
+       exfat_debug("[%s] %s", __func__, path);
+       rc = exfat_flush(&ef);
+       if (rc != 0)
+               return rc;
+       return exfat_fsync(ef.dev);
 }
 
 static int fuse_exfat_read(const char* path, char* buffer, size_t size,
@@ -193,7 +221,9 @@ static int fuse_exfat_unlink(const char* path)
 
        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)
@@ -209,7 +239,9 @@ static int fuse_exfat_rmdir(const char* path)
 
        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)
@@ -248,14 +280,21 @@ static int fuse_exfat_utimens(const char* path, const struct timespec tv[2])
 
 static int fuse_exfat_chmod(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);
-       return ef.quiet ? 0 : -ENOSYS;
+       if (mode & ~VALID_MODE_MASK)
+               return -EPERM;
+       return 0;
 }
 
 static int fuse_exfat_chown(const char* path, uid_t uid, gid_t gid)
 {
        exfat_debug("[%s] %s %u:%u", __func__, path, uid, gid);
-       return ef.quiet ? 0 : -ENOSYS;
+       if (uid != ef.uid || gid != ef.gid)
+               return -EPERM;
+       return 0;
 }
 
 static int fuse_exfat_statfs(const char* path, struct statvfs* sfs)
@@ -310,6 +349,9 @@ static struct fuse_operations fuse_exfat_ops =
        .readdir        = fuse_exfat_readdir,
        .open           = fuse_exfat_open,
        .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,