Imported Upstream version 1.1.0

[sven/exfat-utils.git] / libexfat / mount.c

diff --git a/libexfat/mount.c b/libexfat/mount.c
index ec4f52e88a6d8561957bc45bc0f8aeb5f33d1850..2ebf43625315701e99eba3a543250420a44ce60c 100644 (file)
--- a/libexfat/mount.c
+++ b/libexfat/mount.c
@@ -2,11 +2,12 @@
        mount.c (22.10.09)
        exFAT file system implementation library.
 
        mount.c (22.10.09)
        exFAT file system implementation library.
 

-       Copyright (C) 2010-2013  Andrew Nayenko
+       Free exFAT implementation.
+       Copyright (C) 2010-2014  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,14 +15,16 @@
        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"
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 */
 
 #include "exfat.h"
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>

+#include <inttypes.h>

 #include <unistd.h>
 #include <sys/types.h>
 
 #include <unistd.h>
 #include <sys/types.h>
 


@@ -37,6 +40,12 @@ static uint64_t rootdir_size(const struct exfat* ef)
                   to indicate this */
                rootdir_cluster = exfat_next_cluster(ef, ef->root, rootdir_cluster);
        }
                   to indicate this */
                rootdir_cluster = exfat_next_cluster(ef, ef->root, rootdir_cluster);
        }

+       if (rootdir_cluster != EXFAT_CLUSTER_END)
+       {
+               exfat_error("bad cluster %#x while reading root directory",
+                               rootdir_cluster);
+               return 0;
+       }

        return clusters * CLUSTER_SIZE(*ef->sb);
 }
 
        return clusters * CLUSTER_SIZE(*ef->sb);
 }
 


@@ -89,34 +98,50 @@ static void parse_options(struct exfat* ef, const char* options)
        ef->noatime = match_option(options, "noatime");
 }
 
        ef->noatime = match_option(options, "noatime");
 }
 

-static int verify_vbr_checksum(struct exfat_dev* dev, void* sector,
+static bool verify_vbr_checksum(struct exfat_dev* dev, void* sector,

                off_t sector_size)
 {
        uint32_t vbr_checksum;
        int i;
 
                off_t sector_size)
 {
        uint32_t vbr_checksum;
        int i;
 

-       exfat_pread(dev, sector, sector_size, 0);
+       if (exfat_pread(dev, sector, sector_size, 0) < 0)
+       {
+               exfat_error("failed to read boot sector");
+               return false;
+       }

        vbr_checksum = exfat_vbr_start_checksum(sector, sector_size);
        for (i = 1; i < 11; i++)
        {
        vbr_checksum = exfat_vbr_start_checksum(sector, sector_size);
        for (i = 1; i < 11; i++)
        {

-               exfat_pread(dev, sector, sector_size, i * sector_size);
+               if (exfat_pread(dev, sector, sector_size, i * sector_size) < 0)
+               {
+                       exfat_error("failed to read VBR sector");
+                       return false;
+               }

                vbr_checksum = exfat_vbr_add_checksum(sector, sector_size,
                                vbr_checksum);
        }
                vbr_checksum = exfat_vbr_add_checksum(sector, sector_size,
                                vbr_checksum);
        }

-       exfat_pread(dev, sector, sector_size, i * sector_size);
+       if (exfat_pread(dev, sector, sector_size, i * sector_size) < 0)
+       {
+               exfat_error("failed to read VBR checksum sector");
+               return false;
+       }

        for (i = 0; i < sector_size / sizeof(vbr_checksum); i++)
                if (le32_to_cpu(((const le32_t*) sector)[i]) != vbr_checksum)
                {
                        exfat_error("invalid VBR checksum 0x%x (expected 0x%x)",
                                        le32_to_cpu(((const le32_t*) sector)[i]), vbr_checksum);
        for (i = 0; i < sector_size / sizeof(vbr_checksum); i++)
                if (le32_to_cpu(((const le32_t*) sector)[i]) != vbr_checksum)
                {
                        exfat_error("invalid VBR checksum 0x%x (expected 0x%x)",
                                        le32_to_cpu(((const le32_t*) sector)[i]), vbr_checksum);

-                       return 1;
+                       return false;

                }
                }

-       return 0;
+       return true;

 }
 
 static int commit_super_block(const struct exfat* ef)
 {
 }
 
 static int commit_super_block(const struct exfat* ef)
 {

-       exfat_pwrite(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0);
+       if (exfat_pwrite(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0) < 0)
+       {
+               exfat_error("failed to write super block");
+               return 1;
+       }

        return exfat_fsync(ef->dev);
 }
 
        return exfat_fsync(ef->dev);
 }
 


@@ -169,7 +194,13 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        }
        memset(ef->sb, 0, sizeof(struct exfat_super_block));
 
        }
        memset(ef->sb, 0, sizeof(struct exfat_super_block));
 

-       exfat_pread(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0);
+       if (exfat_pread(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0) < 0)
+       {
+               exfat_close(ef->dev);
+               free(ef->sb);
+               exfat_error("failed to read boot sector");
+               return -EIO;
+       }

        if (memcmp(ef->sb->oem_name, "EXFAT   ", 8) != 0)
        {
                exfat_close(ef->dev);
        if (memcmp(ef->sb->oem_name, "EXFAT   ", 8) != 0)
        {
                exfat_close(ef->dev);


@@ -177,8 +208,26 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
                exfat_error("exFAT file system is not found");
                return -EIO;
        }
                exfat_error("exFAT file system is not found");
                return -EIO;
        }

+       ef->zero_cluster = malloc(CLUSTER_SIZE(*ef->sb));
+       if (ef->zero_cluster == NULL)
+       {
+               exfat_close(ef->dev);
+               free(ef->sb);
+               exfat_error("failed to allocate zero sector");
+               return -ENOMEM;
+       }
+       /* use zero_cluster as a temporary buffer for VBR checksum verification */
+       if (!verify_vbr_checksum(ef->dev, ef->zero_cluster, SECTOR_SIZE(*ef->sb)))
+       {
+               free(ef->zero_cluster);
+               exfat_close(ef->dev);
+               free(ef->sb);
+               return -EIO;
+       }
+       memset(ef->zero_cluster, 0, CLUSTER_SIZE(*ef->sb));

        if (ef->sb->version.major != 1 || ef->sb->version.minor != 0)
        {
        if (ef->sb->version.major != 1 || ef->sb->version.minor != 0)
        {

+               free(ef->zero_cluster);

                exfat_close(ef->dev);
                exfat_error("unsupported exFAT version: %hhu.%hhu",
                                ef->sb->version.major, ef->sb->version.minor);
                exfat_close(ef->dev);
                exfat_error("unsupported exFAT version: %hhu.%hhu",
                                ef->sb->version.major, ef->sb->version.minor);


@@ -187,39 +236,34 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        }
        if (ef->sb->fat_count != 1)
        {
        }
        if (ef->sb->fat_count != 1)
        {

+               free(ef->zero_cluster);

                exfat_close(ef->dev);
                exfat_close(ef->dev);

-               free(ef->sb);

                exfat_error("unsupported FAT count: %hhu", ef->sb->fat_count);
                exfat_error("unsupported FAT count: %hhu", ef->sb->fat_count);

+               free(ef->sb);

                return -EIO;
        }
        /* officially exFAT supports cluster size up to 32 MB */
        if ((int) ef->sb->sector_bits + (int) ef->sb->spc_bits > 25)
        {
                return -EIO;
        }
        /* officially exFAT supports cluster size up to 32 MB */
        if ((int) ef->sb->sector_bits + (int) ef->sb->spc_bits > 25)
        {

+               free(ef->zero_cluster);

                exfat_close(ef->dev);
                exfat_close(ef->dev);

-               free(ef->sb);

                exfat_error("too big cluster size: 2^%d",
                                (int) ef->sb->sector_bits + (int) ef->sb->spc_bits);
                exfat_error("too big cluster size: 2^%d",
                                (int) ef->sb->sector_bits + (int) ef->sb->spc_bits);

-               return -EIO;
-       }
-
-       ef->zero_cluster = malloc(CLUSTER_SIZE(*ef->sb));
-       if (ef->zero_cluster == NULL)
-       {
-               exfat_close(ef->dev);

                free(ef->sb);
                free(ef->sb);

-               exfat_error("failed to allocate zero sector");
-               return -ENOMEM;
+               return -EIO;

        }
        }

-       /* use zero_cluster as a temporary buffer for VBR checksum verification */
-       if (verify_vbr_checksum(ef->dev, ef->zero_cluster,
-                       SECTOR_SIZE(*ef->sb)) != 0)
+       if (le64_to_cpu(ef->sb->sector_count) * SECTOR_SIZE(*ef->sb) >
+                       exfat_get_size(ef->dev))

        {
                free(ef->zero_cluster);
        {
                free(ef->zero_cluster);

+               exfat_error("file system is larger than underlying device: "
+                               "%"PRIu64" > %"PRIu64,
+                               le64_to_cpu(ef->sb->sector_count) * SECTOR_SIZE(*ef->sb),
+                               exfat_get_size(ef->dev));

                exfat_close(ef->dev);
                free(ef->sb);
                return -EIO;
        }
                exfat_close(ef->dev);
                free(ef->sb);
                return -EIO;
        }

-       memset(ef->zero_cluster, 0, CLUSTER_SIZE(*ef->sb));

 
        ef->root = malloc(sizeof(struct exfat_node));
        if (ef->root == NULL)
 
        ef->root = malloc(sizeof(struct exfat_node));
        if (ef->root == NULL)


@@ -236,6 +280,14 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        ef->root->fptr_cluster = ef->root->start_cluster;
        ef->root->name[0] = cpu_to_le16('\0');
        ef->root->size = rootdir_size(ef);
        ef->root->fptr_cluster = ef->root->start_cluster;
        ef->root->name[0] = cpu_to_le16('\0');
        ef->root->size = rootdir_size(ef);

+       if (ef->root->size == 0)
+       {
+               free(ef->root);
+               free(ef->zero_cluster);
+               exfat_close(ef->dev);
+               free(ef->sb);
+               return -EIO;
+       }

        /* exFAT does not have time attributes for the root directory */
        ef->root->mtime = 0;
        ef->root->atime = 0;
        /* exFAT does not have time attributes for the root directory */
        ef->root->mtime = 0;
        ef->root->atime = 0;


@@ -290,11 +342,12 @@ static void finalize_super_block(struct exfat* ef)
                ef->sb->allocated_percent = ((total - free) * 100 + total / 2) / total;
        }
 
                ef->sb->allocated_percent = ((total - free) * 100 + total / 2) / total;
        }
 

-       commit_super_block(ef);
+       commit_super_block(ef); /* ignore return code */

 }
 
 void exfat_unmount(struct exfat* ef)
 {
 }
 
 void exfat_unmount(struct exfat* ef)
 {

+       exfat_flush(ef);        /* ignore return code */

        exfat_put_node(ef, ef->root);
        exfat_reset_cache(ef);
        free(ef->root);
        exfat_put_node(ef, ef->root);
        exfat_reset_cache(ef);
        free(ef->root);