From: Sven Hoexter Date: Sun, 25 Jun 2017 08:02:43 +0000 (+0200) Subject: New upstream version 1.2.7 X-Git-Tag: upstream/1.2.7^0 X-Git-Url: https://git.sven.stormbind.net/?a=commitdiff_plain;h=7c1f592481792ea54bfdefd3d881ded0202ccb26;p=sven%2Ffuse-exfat.git New upstream version 1.2.7 --- diff --git a/ChangeLog b/ChangeLog index 639972e..1d3e3c4 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,4 +1,21 @@ +1.2.7 (2017-06-05) + +* Fixed handling of two last clusters: operations with files that occupy these +clusters could fail. +* Fixed crash when started with stdin, stdout or stderr closed. + +1.2.6 (2017-01-28) + +* Operations with directories (except initial listing) now make less +read/write system calls. +* Fixed handling of files with optional tail entries (0xe0-0xff): videoclip +files created by Sony cameras were missing. +* Write operations now correctly return ENOSPC (instead of EIO) when there is +no free disk space left. +* Fixed max file name length: it's 255 16-bit code units (not 256). + 1.2.5 (2016-12-05) + * Added an option for dumpexfat to show file fragments [Daniel Drake]. * Fixed crash when directory starts with an invalid cluster. * Daylight saving time in now properly reflected in file timestamps. diff --git a/Makefile.am b/Makefile.am index 4a04532..2042e63 100644 --- a/Makefile.am +++ b/Makefile.am @@ -3,7 +3,7 @@ # Automake source. # # Free exFAT implementation. -# Copyright (C) 2010-2016 Andrew Nayenko +# Copyright (C) 2010-2017 Andrew Nayenko # # 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 diff --git a/Makefile.in b/Makefile.in index 55986d2..f13159e 100644 --- a/Makefile.in +++ b/Makefile.in @@ -19,7 +19,7 @@ # Automake source. # # Free exFAT implementation. -# Copyright (C) 2010-2016 Andrew Nayenko +# Copyright (C) 2010-2017 Andrew Nayenko # # 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 @@ -521,7 +521,7 @@ distdir: $(DISTFILES) ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \ || chmod -R a+r "$(distdir)" dist-gzip: distdir - tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz + tardir=$(distdir) && $(am__tar) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).tar.gz $(am__post_remove_distdir) dist-bzip2: distdir @@ -547,7 +547,7 @@ dist-shar: distdir @echo WARNING: "Support for shar distribution archives is" \ "deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 - shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz + shar $(distdir) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).shar.gz $(am__post_remove_distdir) dist-zip: distdir @@ -565,7 +565,7 @@ dist dist-all: distcheck: dist case '$(DIST_ARCHIVES)' in \ *.tar.gz*) \ - GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\ + eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).tar.gz | $(am__untar) ;;\ *.tar.bz2*) \ bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ *.tar.lz*) \ @@ -575,7 +575,7 @@ distcheck: dist *.tar.Z*) \ uncompress -c $(distdir).tar.Z | $(am__untar) ;;\ *.shar.gz*) \ - GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\ + eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).shar.gz | unshar ;;\ *.zip*) \ unzip $(distdir).zip ;;\ esac diff --git a/aclocal.m4 b/aclocal.m4 index 21aae2c..3018c54 100644 --- a/aclocal.m4 +++ b/aclocal.m4 @@ -21,7 +21,7 @@ If you have problems, you may need to regenerate the build system entirely. To do so, use the procedure documented by the package, typically 'autoreconf'.])]) dnl pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- -dnl serial 11 (pkg-config-0.29) +dnl serial 11 (pkg-config-0.29.1) dnl dnl Copyright © 2004 Scott James Remnant . dnl Copyright © 2012-2015 Dan Nicholson @@ -63,7 +63,7 @@ dnl dnl See the "Since" comment for each macro you use to see what version dnl of the macros you require. m4_defun([PKG_PREREQ], -[m4_define([PKG_MACROS_VERSION], [0.29]) +[m4_define([PKG_MACROS_VERSION], [0.29.1]) m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1, [m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])]) ])dnl PKG_PREREQ diff --git a/configure b/configure index f4de9e5..5e88088 100755 --- a/configure +++ b/configure @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69 for Free exFAT implementation 1.2.5. +# Generated by GNU Autoconf 2.69 for Free exFAT implementation 1.2.7. # # Report bugs to . # @@ -579,8 +579,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='Free exFAT implementation' PACKAGE_TARNAME='fuse-exfat' -PACKAGE_VERSION='1.2.5' -PACKAGE_STRING='Free exFAT implementation 1.2.5' +PACKAGE_VERSION='1.2.7' +PACKAGE_STRING='Free exFAT implementation 1.2.7' PACKAGE_BUGREPORT='relan@users.noreply.github.com' PACKAGE_URL='https://github.com/relan/exfat' @@ -1238,7 +1238,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures Free exFAT implementation 1.2.5 to adapt to many kinds of systems. +\`configure' configures Free exFAT implementation 1.2.7 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1304,7 +1304,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of Free exFAT implementation 1.2.5:";; + short | recursive ) echo "Configuration of Free exFAT implementation 1.2.7:";; esac cat <<\_ACEOF @@ -1403,7 +1403,7 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -Free exFAT implementation configure 1.2.5 +Free exFAT implementation configure 1.2.7 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. @@ -1458,7 +1458,7 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by Free exFAT implementation $as_me 1.2.5, which was +It was created by Free exFAT implementation $as_me 1.2.7, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -2321,7 +2321,7 @@ fi # Define the identity of the package. PACKAGE='fuse-exfat' - VERSION='1.2.5' + VERSION='1.2.7' cat >>confdefs.h <<_ACEOF @@ -4839,7 +4839,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by Free exFAT implementation $as_me 1.2.5, which was +This file was extended by Free exFAT implementation $as_me 1.2.7, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -4906,7 +4906,7 @@ _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -Free exFAT implementation config.status 1.2.5 +Free exFAT implementation config.status 1.2.7 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" diff --git a/configure.ac b/configure.ac index c75e9c0..4c2a09d 100644 --- a/configure.ac +++ b/configure.ac @@ -3,7 +3,7 @@ # Autoconf source. # # Free exFAT implementation. -# Copyright (C) 2010-2016 Andrew Nayenko +# Copyright (C) 2010-2017 Andrew Nayenko # # 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 @@ -21,7 +21,7 @@ # AC_INIT([Free exFAT implementation], - [1.2.5], + [1.2.7], [relan@users.noreply.github.com], [fuse-exfat], [https://github.com/relan/exfat]) diff --git a/fuse/Makefile.am b/fuse/Makefile.am index 8f69cf4..c9fdca6 100644 --- a/fuse/Makefile.am +++ b/fuse/Makefile.am @@ -3,7 +3,7 @@ # Automake source. # # Free exFAT implementation. -# Copyright (C) 2010-2016 Andrew Nayenko +# Copyright (C) 2010-2017 Andrew Nayenko # # 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 diff --git a/fuse/Makefile.in b/fuse/Makefile.in index 8af7876..a16cfad 100644 --- a/fuse/Makefile.in +++ b/fuse/Makefile.in @@ -19,7 +19,7 @@ # Automake source. # # Free exFAT implementation. -# Copyright (C) 2010-2016 Andrew Nayenko +# Copyright (C) 2010-2017 Andrew Nayenko # # 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 diff --git a/fuse/main.c b/fuse/main.c index bc0faf3..a37b451 100644 --- a/fuse/main.c +++ b/fuse/main.c @@ -3,7 +3,7 @@ FUSE-based exFAT implementation. Requires FUSE 2.6 or later. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 @@ -104,17 +104,17 @@ static int fuse_exfat_readdir(const char* path, void* buffer, struct exfat_node* node; struct exfat_iterator it; int rc; - char name[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; + char name[EXFAT_UTF8_NAME_BUFFER_MAX]; exfat_debug("[%s] %s", __func__, path); 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_error("'%s' is not a directory (0x%x)", path, parent->flags); + exfat_error("'%s' is not a directory (%#hx)", path, parent->attrib); return -ENOTDIR; } @@ -128,11 +128,11 @@ static int fuse_exfat_readdir(const char* path, void* buffer, exfat_error("failed to open directory '%s'", path); return rc; } - while ((node = exfat_readdir(&ef, &it))) + while ((node = exfat_readdir(&it))) { - exfat_get_name(node, name, sizeof(name) - 1); + exfat_get_name(node, name); exfat_debug("[%s] %s: %s, %"PRId64" bytes, cluster 0x%x", __func__, - name, IS_CONTIGUOUS(*node) ? "contiguous" : "fragmented", + name, node->is_contiguous ? "contiguous" : "fragmented", node->size, node->start_cluster); filler(buffer, name, NULL, 0); exfat_put_node(&ef, node); @@ -218,25 +218,15 @@ static int fuse_exfat_fsync(const char* path, int datasync, static int fuse_exfat_read(const char* path, char* buffer, size_t size, off_t offset, struct fuse_file_info* fi) { - ssize_t ret; - exfat_debug("[%s] %s (%zu bytes)", __func__, path, size); - ret = exfat_generic_pread(&ef, get_node(fi), buffer, size, offset); - if (ret < 0) - return -EIO; - return ret; + 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) { - ssize_t ret; - exfat_debug("[%s] %s (%zu bytes)", __func__, path, size); - ret = exfat_generic_pwrite(&ef, get_node(fi), buffer, size, offset); - if (ret < 0) - return -EIO; - return ret; + return exfat_generic_pwrite(&ef, get_node(fi), buffer, size, offset); } static int fuse_exfat_unlink(const char* path) @@ -538,7 +528,7 @@ int main(int argc, char* argv[]) break; case 'V': free(mount_options); - puts("Copyright (C) 2010-2016 Andrew Nayenko"); + puts("Copyright (C) 2010-2017 Andrew Nayenko"); return 0; case 'v': break; diff --git a/libexfat/Makefile.am b/libexfat/Makefile.am index 102d89d..08ed347 100644 --- a/libexfat/Makefile.am +++ b/libexfat/Makefile.am @@ -3,7 +3,7 @@ # Automake source. # # Free exFAT implementation. -# Copyright (C) 2010-2016 Andrew Nayenko +# Copyright (C) 2010-2017 Andrew Nayenko # # 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 diff --git a/libexfat/Makefile.in b/libexfat/Makefile.in index f10c73a..2f037c0 100644 --- a/libexfat/Makefile.in +++ b/libexfat/Makefile.in @@ -19,7 +19,7 @@ # Automake source. # # Free exFAT implementation. -# Copyright (C) 2010-2016 Andrew Nayenko +# Copyright (C) 2010-2017 Andrew Nayenko # # 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 diff --git a/libexfat/byteorder.h b/libexfat/byteorder.h index e417ad6..173b250 100644 --- a/libexfat/byteorder.h +++ b/libexfat/byteorder.h @@ -3,7 +3,7 @@ Endianness stuff. exFAT uses little-endian byte order. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 diff --git a/libexfat/cluster.c b/libexfat/cluster.c index 34f027c..5a26133 100644 --- a/libexfat/cluster.c +++ b/libexfat/cluster.c @@ -3,7 +3,7 @@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 @@ -79,7 +79,7 @@ cluster_t exfat_next_cluster(const struct exfat* ef, if (cluster < EXFAT_FIRST_DATA_CLUSTER) exfat_bug("bad cluster 0x%x", cluster); - if (IS_CONTIGUOUS(*node)) + if (node->is_contiguous) return cluster + 1; fat_offset = s2o(ef, le32_to_cpu(ef->sb->fat_sector_start)) + cluster * sizeof(cluster_t); @@ -103,7 +103,7 @@ cluster_t exfat_advance_cluster(const struct exfat* ef, for (i = node->fptr_index; i < count; i++) { node->fptr_cluster = exfat_next_cluster(ef, node, node->fptr_cluster); - if (CLUSTER_INVALID(node->fptr_cluster)) + if (CLUSTER_INVALID(*ef->sb, node->fptr_cluster)) break; /* the caller should handle this and print appropriate error message */ } @@ -214,10 +214,8 @@ static cluster_t allocate_cluster(struct exfat* ef, cluster_t hint) static void free_cluster(struct exfat* ef, cluster_t cluster) { - if (CLUSTER_INVALID(cluster)) - exfat_bug("freeing invalid cluster 0x%x", cluster); if (cluster - EXFAT_FIRST_DATA_CLUSTER >= ef->cmap.size) - exfat_bug("freeing non-existing cluster 0x%x (0x%x)", cluster, + exfat_bug("caller must check cluster validity (%#x, %#x)", cluster, ef->cmap.size); BMAP_CLR(ef->cmap.chunk, cluster - EXFAT_FIRST_DATA_CLUSTER); @@ -252,7 +250,7 @@ static int grow_file(struct exfat* ef, struct exfat_node* node, { /* get the last cluster of the file */ previous = exfat_advance_cluster(ef, node, current - 1); - if (CLUSTER_INVALID(previous)) + if (CLUSTER_INVALID(*ef->sb, previous)) { exfat_error("invalid cluster 0x%x while growing", previous); return -EIO; @@ -265,39 +263,39 @@ static int grow_file(struct exfat* ef, struct exfat_node* node, /* file does not have clusters (i.e. is empty), allocate the first one for it */ previous = allocate_cluster(ef, 0); - if (CLUSTER_INVALID(previous)) + if (CLUSTER_INVALID(*ef->sb, previous)) return -ENOSPC; node->fptr_cluster = node->start_cluster = previous; allocated = 1; /* file consists of only one cluster, so it's contiguous */ - node->flags |= EXFAT_ATTRIB_CONTIGUOUS; + node->is_contiguous = true; } while (allocated < difference) { next = allocate_cluster(ef, previous + 1); - if (CLUSTER_INVALID(next)) + if (CLUSTER_INVALID(*ef->sb, next)) { if (allocated != 0) shrink_file(ef, node, current + allocated, allocated); return -ENOSPC; } - if (next != previous - 1 && IS_CONTIGUOUS(*node)) + if (next != previous - 1 && node->is_contiguous) { /* it's a pity, but we are not able to keep the file contiguous anymore */ if (!make_noncontiguous(ef, node->start_cluster, previous)) return -EIO; - node->flags &= ~EXFAT_ATTRIB_CONTIGUOUS; - node->flags |= EXFAT_ATTRIB_DIRTY; + node->is_contiguous = false; + node->is_dirty = true; } - if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, next)) + if (!set_next_cluster(ef, node->is_contiguous, previous, next)) return -EIO; previous = next; allocated++; } - if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, + if (!set_next_cluster(ef, node->is_contiguous, previous, EXFAT_CLUSTER_END)) return -EIO; return 0; @@ -321,13 +319,13 @@ static int shrink_file(struct exfat* ef, struct exfat_node* node, { cluster_t last = exfat_advance_cluster(ef, node, current - difference - 1); - if (CLUSTER_INVALID(last)) + if (CLUSTER_INVALID(*ef->sb, last)) { exfat_error("invalid cluster 0x%x while shrinking", last); return -EIO; } previous = exfat_next_cluster(ef, node, last); - if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), last, + if (!set_next_cluster(ef, node->is_contiguous, last, EXFAT_CLUSTER_END)) return -EIO; } @@ -335,7 +333,7 @@ static int shrink_file(struct exfat* ef, struct exfat_node* node, { previous = node->start_cluster; node->start_cluster = EXFAT_CLUSTER_FREE; - node->flags |= EXFAT_ATTRIB_DIRTY; + node->is_dirty = true; } node->fptr_index = 0; node->fptr_cluster = node->start_cluster; @@ -343,14 +341,15 @@ static int shrink_file(struct exfat* ef, struct exfat_node* node, /* free remaining clusters */ while (difference--) { - if (CLUSTER_INVALID(previous)) + if (CLUSTER_INVALID(*ef->sb, previous)) { exfat_error("invalid cluster 0x%x while freeing after shrink", previous); return -EIO; } + next = exfat_next_cluster(ef, node, previous); - if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, + if (!set_next_cluster(ef, node->is_contiguous, previous, EXFAT_CLUSTER_FREE)) return -EIO; free_cluster(ef, previous); @@ -381,7 +380,7 @@ static int erase_range(struct exfat* ef, struct exfat_node* node, cluster_boundary = (begin | (CLUSTER_SIZE(*ef->sb) - 1)) + 1; cluster = exfat_advance_cluster(ef, node, begin / CLUSTER_SIZE(*ef->sb)); - if (CLUSTER_INVALID(cluster)) + if (CLUSTER_INVALID(*ef->sb, cluster)) { exfat_error("invalid cluster 0x%x while erasing", cluster); return -EIO; @@ -395,7 +394,7 @@ static int erase_range(struct exfat* ef, struct exfat_node* node, { cluster = exfat_next_cluster(ef, node, cluster); /* the cluster cannot be invalid because we have just allocated it */ - if (CLUSTER_INVALID(cluster)) + if (CLUSTER_INVALID(*ef->sb, cluster)) exfat_bug("invalid cluster 0x%x after allocation", cluster); if (!erase_raw(ef, CLUSTER_SIZE(*ef->sb), exfat_c2o(ef, cluster))) return -EIO; @@ -434,7 +433,7 @@ int exfat_truncate(struct exfat* ef, struct exfat_node* node, uint64_t size, exfat_update_mtime(node); node->size = size; - node->flags |= EXFAT_ATTRIB_DIRTY; + node->is_dirty = true; return 0; } diff --git a/libexfat/compiler.h b/libexfat/compiler.h index b590d01..e4f40de 100644 --- a/libexfat/compiler.h +++ b/libexfat/compiler.h @@ -4,7 +4,7 @@ showstopper. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 diff --git a/libexfat/exfat.h b/libexfat/exfat.h index 75cb6e6..b913ca2 100644 --- a/libexfat/exfat.h +++ b/libexfat/exfat.h @@ -4,7 +4,7 @@ implementation. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 @@ -34,22 +34,22 @@ #include #include -#define EXFAT_NAME_MAX 256 -#define EXFAT_ATTRIB_CONTIGUOUS 0x10000 -#define EXFAT_ATTRIB_CACHED 0x20000 -#define EXFAT_ATTRIB_DIRTY 0x40000 -#define EXFAT_ATTRIB_UNLINKED 0x80000 -#define IS_CONTIGUOUS(node) (((node).flags & EXFAT_ATTRIB_CONTIGUOUS) != 0) +#define EXFAT_NAME_MAX 255 +/* UTF-16 encodes code points up to U+FFFF as single 16-bit code units. + UTF-8 uses up to 3 bytes (i.e. 8-bit code units) to encode code points + up to U+FFFF. One additional character is for null terminator. */ +#define EXFAT_UTF8_NAME_BUFFER_MAX (EXFAT_NAME_MAX * 3 + 1) +#define EXFAT_UTF8_ENAME_BUFFER_MAX (EXFAT_ENAME_MAX * 3 + 1) + #define SECTOR_SIZE(sb) (1 << (sb).sector_bits) #define CLUSTER_SIZE(sb) (SECTOR_SIZE(sb) << (sb).spc_bits) -#define CLUSTER_INVALID(c) \ - ((c) < EXFAT_FIRST_DATA_CLUSTER || (c) > EXFAT_LAST_DATA_CLUSTER) +#define CLUSTER_INVALID(sb, c) ((c) < EXFAT_FIRST_DATA_CLUSTER || \ + (c) - EXFAT_FIRST_DATA_CLUSTER >= le32_to_cpu((sb).cluster_count)) #define MIN(a, b) ((a) < (b) ? (a) : (b)) #define MAX(a, b) ((a) > (b) ? (a) : (b)) #define DIV_ROUND_UP(x, d) (((x) + (d) - 1) / (d)) #define ROUND_UP(x, d) (DIV_ROUND_UP(x, d) * (d)) -#define UTF8_BYTES(c) ((c) * 6) /* UTF-8 character can occupy up to 6 bytes */ #define BMAP_SIZE(count) (ROUND_UP(count, sizeof(bitmap_t) * 8) / 8) #define BMAP_BLOCK(index) ((index) / sizeof(bitmap_t) / 8) @@ -75,10 +75,14 @@ struct exfat_node int references; uint32_t fptr_index; cluster_t fptr_cluster; - cluster_t entry_cluster; off_t entry_offset; cluster_t start_cluster; - int flags; + uint16_t attrib; + uint8_t continuations; + bool is_contiguous : 1; + bool is_cached : 1; + bool is_dirty : 1; + bool is_unlinked : 1; uint64_t size; time_t mtime, atime; le16_t name[EXFAT_NAME_MAX + 1]; @@ -108,7 +112,7 @@ struct exfat bool dirty; } cmap; - char label[UTF8_BYTES(EXFAT_ENAME_MAX) + 1]; + char label[EXFAT_UTF8_ENAME_BUFFER_MAX]; void* zero_cluster; int dmask, fmask; uid_t uid; @@ -157,7 +161,7 @@ ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node, int exfat_opendir(struct exfat* ef, struct exfat_node* dir, struct exfat_iterator* it); void exfat_closedir(struct exfat* ef, struct exfat_iterator* it); -struct exfat_node* exfat_readdir(struct exfat* ef, struct exfat_iterator* it); +struct exfat_node* exfat_readdir(struct exfat_iterator* it); int exfat_lookup(struct exfat* ef, struct exfat_node** node, const char* path); int exfat_split(struct exfat* ef, struct exfat_node** parent, @@ -177,14 +181,15 @@ int exfat_find_used_sectors(const struct exfat* ef, off_t* a, off_t* b); void exfat_stat(const struct exfat* ef, const struct exfat_node* node, struct stat* stbuf); -void exfat_get_name(const struct exfat_node* node, char* buffer, size_t n); +void exfat_get_name(const struct exfat_node* node, + char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]); uint16_t exfat_start_checksum(const struct exfat_entry_meta1* entry); uint16_t exfat_add_checksum(const void* entry, uint16_t sum); -le16_t exfat_calc_checksum(const struct exfat_entry_meta1* meta1, - const struct exfat_entry_meta2* meta2, const le16_t* name); +le16_t exfat_calc_checksum(const struct exfat_entry* entries, int n); uint32_t exfat_vbr_start_checksum(const void* sector, size_t size); uint32_t exfat_vbr_add_checksum(const void* sector, size_t size, uint32_t sum); -le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name); +le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name, + size_t length); void exfat_humanize_bytes(uint64_t value, struct exfat_human_bytes* hb); void exfat_print_info(const struct exfat_super_block* sb, uint32_t free_clusters); diff --git a/libexfat/exfatfs.h b/libexfat/exfatfs.h index c155312..84c6f97 100644 --- a/libexfat/exfatfs.h +++ b/libexfat/exfatfs.h @@ -3,7 +3,7 @@ Definitions of structures and constants used in exFAT file system. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 @@ -78,6 +78,9 @@ STATIC_ASSERT(sizeof(struct exfat_super_block) == 512); #define EXFAT_ENTRY_FILE (0x05 | EXFAT_ENTRY_VALID) #define EXFAT_ENTRY_FILE_INFO (0x00 | EXFAT_ENTRY_VALID | EXFAT_ENTRY_CONTINUED) #define EXFAT_ENTRY_FILE_NAME (0x01 | EXFAT_ENTRY_VALID | EXFAT_ENTRY_CONTINUED) +#define EXFAT_ENTRY_FILE_TAIL (0x00 | EXFAT_ENTRY_VALID \ + | EXFAT_ENTRY_CONTINUED \ + | EXFAT_ENTRY_OPTIONAL) struct exfat_entry /* common container for all entries */ { diff --git a/libexfat/io.c b/libexfat/io.c index 60f28e2..63ccfdb 100644 --- a/libexfat/io.c +++ b/libexfat/io.c @@ -3,7 +3,7 @@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 @@ -45,6 +45,11 @@ struct exfat_dev off_t size; /* in bytes */ }; +static bool is_open(int fd) +{ + return fcntl(fd, F_GETFD) != -1; +} + static int open_ro(const char* spec) { return open(spec, O_RDONLY); @@ -75,6 +80,24 @@ struct exfat_dev* exfat_open(const char* spec, enum exfat_mode mode) struct exfat_dev* dev; struct stat stbuf; + /* The system allocates file descriptors sequentially. If we have been + started with stdin (0), stdout (1) or stderr (2) closed, the system + will give us descriptor 0, 1 or 2 later when we open block device, + FUSE communication pipe, etc. As a result, functions using stdin, + stdout or stderr will actualy work with a different thing and can + corrupt it. Protect descriptors 0, 1 and 2 from such misuse. */ + while (!is_open(STDIN_FILENO) + || !is_open(STDOUT_FILENO) + || !is_open(STDERR_FILENO)) + { + /* we don't need those descriptors, let them leak */ + if (open("/dev/null", O_RDWR) == -1) + { + exfat_error("failed to open /dev/null"); + return NULL; + } + } + dev = malloc(sizeof(struct exfat_dev)); if (dev == NULL) { @@ -289,34 +312,34 @@ ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node, return 0; cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb)); - if (CLUSTER_INVALID(cluster)) + if (CLUSTER_INVALID(*ef->sb, cluster)) { exfat_error("invalid cluster 0x%x while reading", cluster); - return -1; + return -EIO; } loffset = offset % CLUSTER_SIZE(*ef->sb); remainder = MIN(size, node->size - offset); while (remainder > 0) { - if (CLUSTER_INVALID(cluster)) + if (CLUSTER_INVALID(*ef->sb, cluster)) { exfat_error("invalid cluster 0x%x while reading", cluster); - return -1; + return -EIO; } lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder); if (exfat_pread(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset) < 0) { exfat_error("failed to read cluster %#x", cluster); - return -1; + return -EIO; } bufp += lsize; loffset = 0; remainder -= lsize; cluster = exfat_next_cluster(ef, node, cluster); } - if (!ef->ro && !ef->noatime) + if (!(node->attrib & EXFAT_ATTRIB_DIR) && !ef->ro && !ef->noatime) exfat_update_atime(node); return MIN(size, node->size - offset) - remainder; } @@ -324,47 +347,57 @@ ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node, ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node, const void* buffer, size_t size, off_t offset) { + int rc; cluster_t cluster; const char* bufp = buffer; off_t lsize, loffset, remainder; if (offset > node->size) - if (exfat_truncate(ef, node, offset, true) != 0) - return -1; + { + rc = exfat_truncate(ef, node, offset, true); + if (rc != 0) + return rc; + } if (offset + size > node->size) - if (exfat_truncate(ef, node, offset + size, false) != 0) - return -1; + { + rc = exfat_truncate(ef, node, offset + size, false); + if (rc != 0) + return rc; + } if (size == 0) return 0; cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb)); - if (CLUSTER_INVALID(cluster)) + if (CLUSTER_INVALID(*ef->sb, cluster)) { exfat_error("invalid cluster 0x%x while writing", cluster); - return -1; + return -EIO; } loffset = offset % CLUSTER_SIZE(*ef->sb); remainder = size; while (remainder > 0) { - if (CLUSTER_INVALID(cluster)) + if (CLUSTER_INVALID(*ef->sb, cluster)) { exfat_error("invalid cluster 0x%x while writing", cluster); - return -1; + return -EIO; } lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder); if (exfat_pwrite(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset) < 0) { exfat_error("failed to write cluster %#x", cluster); - return -1; + return -EIO; } bufp += lsize; loffset = 0; remainder -= lsize; cluster = exfat_next_cluster(ef, node, cluster); } - exfat_update_mtime(node); + if (!(node->attrib & EXFAT_ATTRIB_DIR)) + /* directory's mtime should be updated by the caller only when it + creates or removes something in this directory */ + exfat_update_mtime(node); return size - remainder; } diff --git a/libexfat/log.c b/libexfat/log.c index e37b0d8..5d99d30 100644 --- a/libexfat/log.c +++ b/libexfat/log.c @@ -3,7 +3,7 @@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 diff --git a/libexfat/lookup.c b/libexfat/lookup.c index 30b6410..137a84a 100644 --- a/libexfat/lookup.c +++ b/libexfat/lookup.c @@ -3,7 +3,7 @@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 @@ -46,7 +46,7 @@ void exfat_closedir(struct exfat* ef, struct exfat_iterator* it) it->current = NULL; } -struct exfat_node* exfat_readdir(struct exfat* ef, struct exfat_iterator* it) +struct exfat_node* exfat_readdir(struct exfat_iterator* it) { if (it->current == NULL) it->current = it->parent->child; @@ -86,14 +86,14 @@ static int lookup_name(struct exfat* ef, struct exfat_node* parent, *node = NULL; - rc = utf8_to_utf16(buffer, name, EXFAT_NAME_MAX, n); + rc = utf8_to_utf16(buffer, name, EXFAT_NAME_MAX + 1, n); if (rc != 0) return rc; rc = exfat_opendir(ef, parent, &it); if (rc != 0) return rc; - while ((*node = exfat_readdir(ef, &it))) + while ((*node = exfat_readdir(&it))) { if (compare_name(ef, buffer, (*node)->name) == 0) { @@ -194,7 +194,7 @@ int exfat_split(struct exfat* ef, struct exfat_node** parent, exfat_put_node(ef, *parent); return -ENOENT; } - rc = utf8_to_utf16(name, p, EXFAT_NAME_MAX, n); + rc = utf8_to_utf16(name, p, EXFAT_NAME_MAX + 1, n); if (rc != 0) { exfat_put_node(ef, *parent); diff --git a/libexfat/mount.c b/libexfat/mount.c index b1ce654..43c79eb 100644 --- a/libexfat/mount.c +++ b/libexfat/mount.c @@ -3,7 +3,7 @@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 @@ -44,7 +44,7 @@ static uint64_t rootdir_size(const struct exfat* ef) clusters); return 0; } - if (CLUSTER_INVALID(rootdir_cluster)) + if (CLUSTER_INVALID(*ef->sb, rootdir_cluster)) { exfat_error("bad cluster %#x while reading root directory", rootdir_cluster); @@ -165,6 +165,22 @@ static int prepare_super_block(const struct exfat* ef) return commit_super_block(ef); } +static void exfat_free(struct exfat* ef) +{ + exfat_close(ef->dev); /* first of all, close the descriptor */ + ef->dev = NULL; /* struct exfat_dev is freed by exfat_close() */ + free(ef->root); + ef->root = NULL; + free(ef->zero_cluster); + ef->zero_cluster = NULL; + free(ef->cmap.chunk); + ef->cmap.chunk = NULL; + free(ef->upcase); + ef->upcase = NULL; + free(ef->sb); + ef->sb = NULL; +} + int exfat_mount(struct exfat* ef, const char* spec, const char* options) { int rc; @@ -195,75 +211,64 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options) ef->sb = malloc(sizeof(struct exfat_super_block)); if (ef->sb == NULL) { - exfat_close(ef->dev); exfat_error("failed to allocate memory for the super block"); + exfat_free(ef); return -ENOMEM; } memset(ef->sb, 0, sizeof(struct exfat_super_block)); 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"); + exfat_free(ef); return -EIO; } if (memcmp(ef->sb->oem_name, "EXFAT ", 8) != 0) { - exfat_close(ef->dev); - free(ef->sb); exfat_error("exFAT file system is not found"); + exfat_free(ef); return -EIO; } /* sector cannot be smaller than 512 bytes */ if (ef->sb->sector_bits < 9) { - exfat_close(ef->dev); exfat_error("too small sector size: 2^%hhd", ef->sb->sector_bits); - free(ef->sb); + exfat_free(ef); return -EIO; } /* officially exFAT supports cluster size up to 32 MB */ if ((int) ef->sb->sector_bits + (int) ef->sb->spc_bits > 25) { - exfat_close(ef->dev); exfat_error("too big cluster size: 2^(%hhd+%hhd)", ef->sb->sector_bits, ef->sb->spc_bits); - free(ef->sb); + exfat_free(ef); 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"); + exfat_free(ef); 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); + exfat_free(ef); return -EIO; } memset(ef->zero_cluster, 0, CLUSTER_SIZE(*ef->sb)); 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); - free(ef->sb); + exfat_free(ef); return -EIO; } if (ef->sb->fat_count != 1) { - free(ef->zero_cluster); - exfat_close(ef->dev); exfat_error("unsupported FAT count: %hhu", ef->sb->fat_count); - free(ef->sb); + exfat_free(ef); return -EIO; } if (le64_to_cpu(ef->sb->sector_count) * SECTOR_SIZE(*ef->sb) > @@ -271,33 +276,38 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options) { /* this can cause I/O errors later but we don't fail mounting to let user rescue data */ - exfat_warn("file system is larger than underlying device: " - "%"PRIu64" > %"PRIu64, - le64_to_cpu(ef->sb->sector_count) * SECTOR_SIZE(*ef->sb), + exfat_warn("file system in sectors is larger than device: " + "%"PRIu64" * %d > %"PRIu64, + le64_to_cpu(ef->sb->sector_count), SECTOR_SIZE(*ef->sb), exfat_get_size(ef->dev)); } + if ((off_t) le32_to_cpu(ef->sb->cluster_count) * CLUSTER_SIZE(*ef->sb) > + exfat_get_size(ef->dev)) + { + exfat_error("file system in clusters is larger than device: " + "%u * %d > %"PRIu64, + le32_to_cpu(ef->sb->cluster_count), CLUSTER_SIZE(*ef->sb), + exfat_get_size(ef->dev)); + exfat_free(ef); + return -EIO; + } ef->root = malloc(sizeof(struct exfat_node)); if (ef->root == NULL) { - free(ef->zero_cluster); - exfat_close(ef->dev); - free(ef->sb); exfat_error("failed to allocate root node"); + exfat_free(ef); return -ENOMEM; } memset(ef->root, 0, sizeof(struct exfat_node)); - ef->root->flags = EXFAT_ATTRIB_DIR; + ef->root->attrib = EXFAT_ATTRIB_DIR; ef->root->start_cluster = le32_to_cpu(ef->sb->rootdir_cluster); 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); + exfat_free(ef); return -EIO; } /* exFAT does not have time attributes for the root directory */ @@ -328,10 +338,7 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options) error: exfat_put_node(ef, ef->root); exfat_reset_cache(ef); - free(ef->root); - free(ef->zero_cluster); - exfat_close(ef->dev); - free(ef->sb); + exfat_free(ef); return -EIO; } @@ -363,17 +370,6 @@ 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); - ef->root = NULL; finalize_super_block(ef); - exfat_close(ef->dev); /* close descriptor immediately after fsync */ - ef->dev = NULL; - free(ef->zero_cluster); - ef->zero_cluster = NULL; - free(ef->cmap.chunk); - ef->cmap.chunk = NULL; - free(ef->sb); - ef->sb = NULL; - free(ef->upcase); - ef->upcase = NULL; + exfat_free(ef); /* will close the descriptor */ } diff --git a/libexfat/node.c b/libexfat/node.c index 90002eb..b544bd9 100644 --- a/libexfat/node.c +++ b/libexfat/node.c @@ -3,7 +3,7 @@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 @@ -25,13 +25,7 @@ #include #include -/* on-disk nodes iterator */ -struct iterator -{ - cluster_t cluster; - off_t offset; - char* chunk; -}; +#define EXFAT_ENTRY_NONE (-1) struct exfat_node* exfat_get_node(struct exfat_node* node) { @@ -43,19 +37,19 @@ struct exfat_node* exfat_get_node(struct exfat_node* node) void exfat_put_node(struct exfat* ef, struct exfat_node* node) { - char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; + char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]; --node->references; if (node->references < 0) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_bug("reference counter of '%s' is below zero", buffer); } else if (node->references == 0 && node != ef->root) { - if (node->flags & EXFAT_ATTRIB_DIRTY) + if (node->is_dirty) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_warn("dirty node '%s' with zero references", buffer); } } @@ -73,7 +67,7 @@ int exfat_cleanup_node(struct exfat* ef, struct exfat_node* node) exfat_bug("unable to cleanup a node with %d references", node->references); - if (node->flags & EXFAT_ATTRIB_UNLINKED) + if (node->is_unlinked) { /* free all clusters and node structure itself */ rc = exfat_truncate(ef, node, 0, true); @@ -83,87 +77,44 @@ int exfat_cleanup_node(struct exfat* ef, struct exfat_node* node) return rc; } -/** - * Cluster + offset from the beginning of the directory to absolute offset. - */ -static off_t co2o(struct exfat* ef, cluster_t cluster, off_t offset) -{ - return exfat_c2o(ef, cluster) + offset % CLUSTER_SIZE(*ef->sb); -} - -static int opendir(struct exfat* ef, const struct exfat_node* dir, - struct iterator* it) +static int read_entries(struct exfat* ef, struct exfat_node* dir, + struct exfat_entry* entries, int n, off_t offset) { - char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; - - if (!(dir->flags & EXFAT_ATTRIB_DIR)) - { - exfat_get_name(dir, buffer, sizeof(buffer) - 1); - exfat_bug("'%s' is not a directory", buffer); - } - if (CLUSTER_INVALID(dir->start_cluster)) - { - exfat_get_name(dir, buffer, sizeof(buffer) - 1); - exfat_error("'%s' directory starts with invalid cluster %#x", buffer, - dir->start_cluster); - return -EIO; - } - it->cluster = dir->start_cluster; - it->offset = 0; - it->chunk = malloc(CLUSTER_SIZE(*ef->sb)); - if (it->chunk == NULL) - { - exfat_error("failed to allocate memory for directory cluster"); - return -ENOMEM; - } - if (exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb), - exfat_c2o(ef, it->cluster)) < 0) - { - free(it->chunk); - exfat_get_name(dir, buffer, sizeof(buffer) - 1); - exfat_error("failed to read '%s' directory cluster %#x", buffer, - it->cluster); + ssize_t size; + + if (!(dir->attrib & EXFAT_ATTRIB_DIR)) + exfat_bug("attempted to read entries from a file"); + + size = exfat_generic_pread(ef, dir, entries, + sizeof(struct exfat_entry[n]), offset); + if (size == sizeof(struct exfat_entry[n])) + return 0; /* success */ + if (size == 0) + return -ENOENT; + if (size < 0) return -EIO; - } - return 0; + exfat_error("read %zd bytes instead of %zu bytes", size, + sizeof(struct exfat_entry[n])); + return -EIO; } -static void closedir(struct iterator* it) +static int write_entries(struct exfat* ef, struct exfat_node* dir, + const struct exfat_entry* entries, int n, off_t offset) { - it->cluster = 0; - it->offset = 0; - free(it->chunk); - it->chunk = NULL; -} + ssize_t size; -static bool fetch_next_entry(struct exfat* ef, const struct exfat_node* parent, - struct iterator* it) -{ - /* move iterator to the next entry in the directory */ - it->offset += sizeof(struct exfat_entry); - /* fetch the next cluster if needed */ - if ((it->offset & (CLUSTER_SIZE(*ef->sb) - 1)) == 0) - { - /* reached the end of directory; the caller should check this - condition too */ - if (it->offset >= parent->size) - return true; - it->cluster = exfat_next_cluster(ef, parent, it->cluster); - if (CLUSTER_INVALID(it->cluster)) - { - exfat_error("invalid cluster 0x%x while reading directory", - it->cluster); - return false; - } - if (exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb), - exfat_c2o(ef, it->cluster)) < 0) - { - exfat_error("failed to read the next directory cluster %#x", - it->cluster); - return false; - } - } - return true; + if (!(dir->attrib & EXFAT_ATTRIB_DIR)) + exfat_bug("attempted to write entries into a file"); + + size = exfat_generic_pwrite(ef, dir, entries, + sizeof(struct exfat_entry[n]), offset); + if (size == sizeof(struct exfat_entry[n])) + return 0; /* success */ + if (size < 0) + return -EIO; + exfat_error("wrote %zd bytes instead of %zu bytes", size, + sizeof(struct exfat_entry[n])); + return -EIO; } static struct exfat_node* allocate_node(void) @@ -181,7 +132,8 @@ static struct exfat_node* allocate_node(void) static void init_node_meta1(struct exfat_node* node, const struct exfat_entry_meta1* meta1) { - node->flags = le16_to_cpu(meta1->attrib); + node->attrib = le16_to_cpu(meta1->attrib); + node->continuations = meta1->continuations; node->mtime = exfat_exfat2unix(meta1->mdate, meta1->mtime, meta1->mtime_cs); /* there is no centiseconds field for atime */ @@ -194,32 +146,83 @@ static void init_node_meta2(struct exfat_node* node, node->size = le64_to_cpu(meta2->size); node->start_cluster = le32_to_cpu(meta2->start_cluster); node->fptr_cluster = node->start_cluster; - if (meta2->flags & EXFAT_FLAG_CONTIGUOUS) - node->flags |= EXFAT_ATTRIB_CONTIGUOUS; + node->is_contiguous = ((meta2->flags & EXFAT_FLAG_CONTIGUOUS) != 0); } -static const struct exfat_entry* get_entry_ptr(const struct exfat* ef, - const struct iterator* it) +static void init_node_name(struct exfat_node* node, + const struct exfat_entry* entries, int n) { - return (const struct exfat_entry*) - (it->chunk + it->offset % CLUSTER_SIZE(*ef->sb)); + int i; + + for (i = 0; i < n; i++) + memcpy(node->name + i * EXFAT_ENAME_MAX, + ((const struct exfat_entry_name*) &entries[i])->name, + EXFAT_ENAME_MAX * sizeof(le16_t)); } -static bool check_node(const struct exfat_node* node, uint16_t actual_checksum, - uint16_t reference_checksum, uint64_t valid_size, int cluster_size) +static bool check_entries(const struct exfat_entry* entry, int n) { - char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; + int previous = EXFAT_ENTRY_NONE; + int current; + int i; + + /* check transitions between entries types */ + for (i = 0; i < n + 1; previous = current, i++) + { + bool valid = false; + + current = (i < n) ? entry[i].type : EXFAT_ENTRY_NONE; + switch (previous) + { + case EXFAT_ENTRY_NONE: + valid = (current == EXFAT_ENTRY_FILE); + break; + case EXFAT_ENTRY_FILE: + valid = (current == EXFAT_ENTRY_FILE_INFO); + break; + case EXFAT_ENTRY_FILE_INFO: + valid = (current == EXFAT_ENTRY_FILE_NAME); + break; + case EXFAT_ENTRY_FILE_NAME: + valid = (current == EXFAT_ENTRY_FILE_NAME || + current == EXFAT_ENTRY_NONE || + current >= EXFAT_ENTRY_FILE_TAIL); + break; + case EXFAT_ENTRY_FILE_TAIL ... 0xff: + valid = (current >= EXFAT_ENTRY_FILE_TAIL || + current == EXFAT_ENTRY_NONE); + break; + } + + if (!valid) + { + exfat_error("unexpected entry type %#x after %#x at %d/%d", + current, previous, i, n); + return false; + } + } + return true; +} + +static bool check_node(const struct exfat* ef, struct exfat_node* node, + le16_t actual_checksum, const struct exfat_entry_meta1* meta1, + const struct exfat_entry_meta2* meta2) +{ + int cluster_size = CLUSTER_SIZE(*ef->sb); + uint64_t clusters_heap_size = + (uint64_t) le32_to_cpu(ef->sb->cluster_count) * cluster_size; + char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]; bool ret = true; /* Validate checksum first. If it's invalid all other fields probably contain just garbage. */ - if (actual_checksum != reference_checksum) + if (le16_to_cpu(actual_checksum) != le16_to_cpu(meta1->checksum)) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_error("'%s' has invalid checksum (%#hx != %#hx)", buffer, - actual_checksum, reference_checksum); + le16_to_cpu(actual_checksum), le16_to_cpu(meta1->checksum)); ret = false; } @@ -229,48 +232,58 @@ static bool check_node(const struct exfat_node* node, uint16_t actual_checksum, cannot be greater than file size. See SetFileValidData() function description in MSDN. */ - if (valid_size > node->size) + if (le64_to_cpu(meta2->valid_size) > node->size) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_error("'%s' has valid size (%"PRIu64") greater than size " - "(%"PRIu64")", buffer, valid_size, node->size); + "(%"PRIu64")", buffer, le64_to_cpu(meta2->valid_size), + node->size); ret = false; } /* Empty file must have zero start cluster. Non-empty file must start with a valid cluster. Directories cannot be empty (i.e. must always - have a valid start cluster), but we will check this later in opendir() - to give user a chance to read current directory. + have a valid start cluster), but we will check this later while + reading that directory to give user a chance to read this directory. */ if (node->size == 0 && node->start_cluster != EXFAT_CLUSTER_FREE) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_error("'%s' is empty but start cluster is %#x", buffer, node->start_cluster); ret = false; } - if (node->size > 0 && CLUSTER_INVALID(node->start_cluster)) + if (node->size > 0 && CLUSTER_INVALID(*ef->sb, node->start_cluster)) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_error("'%s' points to invalid cluster %#x", buffer, node->start_cluster); ret = false; } + /* File or directory cannot be larger than clusters heap. */ + if (node->size > clusters_heap_size) + { + exfat_get_name(node, buffer); + exfat_error("'%s' is larger than clusters heap: %"PRIu64" > %"PRIu64, + buffer, node->size, clusters_heap_size); + ret = false; + } + /* Empty file or directory must be marked as non-contiguous. */ - if (node->size == 0 && (node->flags & EXFAT_ATTRIB_CONTIGUOUS)) + if (node->size == 0 && node->is_contiguous) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); - exfat_error("'%s' is empty but marked as contiguous (%#x)", buffer, - node->flags); + exfat_get_name(node, buffer); + exfat_error("'%s' is empty but marked as contiguous (%#hx)", buffer, + node->attrib); ret = false; } /* Directory size must be aligned on at cluster boundary. */ - if ((node->flags & EXFAT_ATTRIB_DIR) && node->size % cluster_size != 0) + if ((node->attrib & EXFAT_ATTRIB_DIR) && node->size % cluster_size != 0) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_error("'%s' directory size %"PRIu64" is not divisible by %d", buffer, node->size, cluster_size); ret = false; @@ -279,6 +292,73 @@ static bool check_node(const struct exfat_node* node, uint16_t actual_checksum, return ret; } +static int parse_file_entries(struct exfat* ef, struct exfat_node* node, + const struct exfat_entry* entries, int n) +{ + const struct exfat_entry_meta1* meta1; + const struct exfat_entry_meta2* meta2; + int mandatory_entries; + + if (!check_entries(entries, n)) + return -EIO; + + meta1 = (const struct exfat_entry_meta1*) &entries[0]; + if (meta1->continuations < 2) + { + exfat_error("too few continuations (%hhu)", meta1->continuations); + return -EIO; + } + meta2 = (const struct exfat_entry_meta2*) &entries[1]; + if (meta2->flags & ~(EXFAT_FLAG_ALWAYS1 | EXFAT_FLAG_CONTIGUOUS)) + { + exfat_error("unknown flags in meta2 (%#hhx)", meta2->flags); + return -EIO; + } + mandatory_entries = 2 + DIV_ROUND_UP(meta2->name_length, EXFAT_ENAME_MAX); + if (meta1->continuations < mandatory_entries - 1) + { + exfat_error("too few continuations (%hhu < %d)", + meta1->continuations, mandatory_entries - 1); + return -EIO; + } + + init_node_meta1(node, meta1); + init_node_meta2(node, meta2); + init_node_name(node, entries + 2, mandatory_entries - 2); + + if (!check_node(ef, node, exfat_calc_checksum(entries, n), meta1, meta2)) + return -EIO; + + return 0; +} + +static int parse_file_entry(struct exfat* ef, struct exfat_node* parent, + struct exfat_node** node, off_t* offset, int n) +{ + struct exfat_entry entries[n]; + int rc; + + rc = read_entries(ef, parent, entries, n, *offset); + if (rc != 0) + return rc; + + /* a new node has zero references */ + *node = allocate_node(); + if (*node == NULL) + return -ENOMEM; + (*node)->entry_offset = *offset; + + rc = parse_file_entries(ef, *node, entries, n); + if (rc != 0) + { + free(*node); + return rc; + } + + *offset += sizeof(struct exfat_entry[n]); + return 0; +} + static void decompress_upcase(uint16_t* output, const le16_t* source, size_t size) { @@ -300,135 +380,43 @@ static void decompress_upcase(uint16_t* output, const le16_t* source, } /* - * Reads one entry in directory at position pointed by iterator and fills - * node structure. + * Read one entry in a directory at offset position and build a new node + * structure. */ -static int readdir(struct exfat* ef, const struct exfat_node* parent, - struct exfat_node** node, struct iterator* it) +static int readdir(struct exfat* ef, struct exfat_node* parent, + struct exfat_node** node, off_t* offset) { - int rc = -EIO; - const struct exfat_entry* entry; + int rc; + struct exfat_entry entry; const struct exfat_entry_meta1* meta1; - const struct exfat_entry_meta2* meta2; - const struct exfat_entry_name* file_name; const struct exfat_entry_upcase* upcase; const struct exfat_entry_bitmap* bitmap; const struct exfat_entry_label* label; - uint8_t continuations = 0; - le16_t* namep = NULL; - uint16_t reference_checksum = 0; - uint16_t actual_checksum = 0; - uint64_t valid_size = 0; uint64_t upcase_size = 0; le16_t* upcase_comp = NULL; - *node = NULL; - for (;;) { - if (it->offset >= parent->size) - { - if (continuations != 0) - { - exfat_error("expected %hhu continuations", continuations); - goto error; - } - return -ENOENT; /* that's OK, means end of directory */ - } + rc = read_entries(ef, parent, &entry, 1, *offset); + if (rc != 0) + return rc; - entry = get_entry_ptr(ef, it); - switch (entry->type) + switch (entry.type) { case EXFAT_ENTRY_FILE: - if (continuations != 0) - { - exfat_error("expected %hhu continuations before new entry", - continuations); - goto error; - } - meta1 = (const struct exfat_entry_meta1*) entry; - continuations = meta1->continuations; - /* each file entry must have at least 2 continuations: - info and name */ - if (continuations < 2) - { - exfat_error("too few continuations (%hhu)", continuations); - goto error; - } - if (continuations > 1 + - DIV_ROUND_UP(EXFAT_NAME_MAX, EXFAT_ENAME_MAX)) - { - exfat_error("too many continuations (%hhu)", continuations); - goto error; - } - reference_checksum = le16_to_cpu(meta1->checksum); - actual_checksum = exfat_start_checksum(meta1); - *node = allocate_node(); - if (*node == NULL) - { - rc = -ENOMEM; - goto error; - } - /* new node has zero reference counter */ - (*node)->entry_cluster = it->cluster; - (*node)->entry_offset = it->offset; - init_node_meta1(*node, meta1); - namep = (*node)->name; - break; - - case EXFAT_ENTRY_FILE_INFO: - if (continuations < 2) - { - exfat_error("unexpected continuation (%hhu)", - continuations); - goto error; - } - meta2 = (const struct exfat_entry_meta2*) entry; - if (meta2->flags & ~(EXFAT_FLAG_ALWAYS1 | EXFAT_FLAG_CONTIGUOUS)) - { - exfat_error("unknown flags in meta2 (0x%hhx)", meta2->flags); - goto error; - } - init_node_meta2(*node, meta2); - actual_checksum = exfat_add_checksum(entry, actual_checksum); - valid_size = le64_to_cpu(meta2->valid_size); - --continuations; - break; - - case EXFAT_ENTRY_FILE_NAME: - if (continuations == 0) - { - exfat_error("unexpected continuation"); - goto error; - } - file_name = (const struct exfat_entry_name*) entry; - actual_checksum = exfat_add_checksum(entry, actual_checksum); - - memcpy(namep, file_name->name, - MIN(EXFAT_ENAME_MAX, - ((*node)->name + EXFAT_NAME_MAX - namep)) * - sizeof(le16_t)); - namep += EXFAT_ENAME_MAX; - if (--continuations == 0) - { - if (!check_node(*node, actual_checksum, reference_checksum, - valid_size, CLUSTER_SIZE(*ef->sb))) - goto error; - if (!fetch_next_entry(ef, parent, it)) - goto error; - return 0; /* entry completed */ - } - break; + meta1 = (const struct exfat_entry_meta1*) &entry; + return parse_file_entry(ef, parent, node, offset, + 1 + meta1->continuations); case EXFAT_ENTRY_UPCASE: if (ef->upcase != NULL) break; - upcase = (const struct exfat_entry_upcase*) entry; - if (CLUSTER_INVALID(le32_to_cpu(upcase->start_cluster))) + upcase = (const struct exfat_entry_upcase*) &entry; + if (CLUSTER_INVALID(*ef->sb, le32_to_cpu(upcase->start_cluster))) { exfat_error("invalid cluster 0x%x in upcase table", le32_to_cpu(upcase->start_cluster)); - goto error; + return -EIO; } upcase_size = le64_to_cpu(upcase->size); if (upcase_size == 0 || @@ -437,15 +425,14 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, { exfat_error("bad upcase table size (%"PRIu64" bytes)", upcase_size); - goto error; + return -EIO; } upcase_comp = malloc(upcase_size); if (upcase_comp == NULL) { exfat_error("failed to allocate upcase table (%"PRIu64" bytes)", upcase_size); - rc = -ENOMEM; - goto error; + return -ENOMEM; } /* read compressed upcase table */ @@ -457,7 +444,7 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, "(%"PRIu64" bytes starting at cluster %#x)", upcase_size, le32_to_cpu(upcase->start_cluster)); - goto error; + return -EIO; } /* decompress upcase table */ @@ -466,8 +453,7 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, { free(upcase_comp); exfat_error("failed to allocate decompressed upcase table"); - rc = -ENOMEM; - goto error; + return -ENOMEM; } decompress_upcase(ef->upcase, upcase_comp, upcase_size / sizeof(uint16_t)); @@ -475,23 +461,22 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, break; case EXFAT_ENTRY_BITMAP: - bitmap = (const struct exfat_entry_bitmap*) entry; + bitmap = (const struct exfat_entry_bitmap*) &entry; ef->cmap.start_cluster = le32_to_cpu(bitmap->start_cluster); - if (CLUSTER_INVALID(ef->cmap.start_cluster)) + if (CLUSTER_INVALID(*ef->sb, ef->cmap.start_cluster)) { exfat_error("invalid cluster 0x%x in clusters bitmap", ef->cmap.start_cluster); - goto error; + return -EIO; } - ef->cmap.size = le32_to_cpu(ef->sb->cluster_count) - - EXFAT_FIRST_DATA_CLUSTER; + ef->cmap.size = le32_to_cpu(ef->sb->cluster_count); if (le64_to_cpu(bitmap->size) < DIV_ROUND_UP(ef->cmap.size, 8)) { exfat_error("invalid clusters bitmap size: %"PRIu64 " (expected at least %u)", le64_to_cpu(bitmap->size), DIV_ROUND_UP(ef->cmap.size, 8)); - goto error; + return -EIO; } /* FIXME bitmap can be rather big, up to 512 MB */ ef->cmap.chunk_size = ef->cmap.size; @@ -500,8 +485,7 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, { exfat_error("failed to allocate clusters bitmap chunk " "(%"PRIu64" bytes)", le64_to_cpu(bitmap->size)); - rc = -ENOMEM; - goto error; + return -ENOMEM; } if (exfat_pread(ef->dev, ef->cmap.chunk, @@ -511,66 +495,45 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, exfat_error("failed to read clusters bitmap " "(%"PRIu64" bytes starting at cluster %#x)", le64_to_cpu(bitmap->size), ef->cmap.start_cluster); - goto error; + return -EIO; } break; case EXFAT_ENTRY_LABEL: - label = (const struct exfat_entry_label*) entry; + label = (const struct exfat_entry_label*) &entry; if (label->length > EXFAT_ENAME_MAX) { exfat_error("too long label (%hhu chars)", label->length); - goto error; + return -EIO; } if (utf16_to_utf8(ef->label, label->name, - sizeof(ef->label) - 1, EXFAT_ENAME_MAX) != 0) - goto error; + sizeof(ef->label), EXFAT_ENAME_MAX) != 0) + return -EIO; break; default: - if (!(entry->type & EXFAT_ENTRY_VALID)) + if (!(entry.type & EXFAT_ENTRY_VALID)) break; /* deleted entry, ignore it */ - if (!(entry->type & EXFAT_ENTRY_OPTIONAL)) - { - exfat_error("unknown entry type %#hhx", entry->type); - goto error; - } - /* optional entry, warn and skip */ - exfat_warn("unknown entry type %#hhx", entry->type); - if (continuations == 0) - { - exfat_error("unexpected continuation"); - goto error; - } - --continuations; - break; - } - if (!fetch_next_entry(ef, parent, it)) - goto error; + exfat_error("unknown entry type %#hhx", entry.type); + return -EIO; + } + *offset += sizeof(entry); } /* we never reach here */ - -error: - free(*node); - *node = NULL; - return rc; } int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir) { - struct iterator it; + off_t offset = 0; int rc; struct exfat_node* node; struct exfat_node* current = NULL; - if (dir->flags & EXFAT_ATTRIB_CACHED) + if (dir->is_cached) return 0; /* already cached */ - rc = opendir(ef, dir, &it); - if (rc != 0) - return rc; - while ((rc = readdir(ef, dir, &node, &it)) == 0) + while ((rc = readdir(ef, dir, &node, &offset)) == 0) { node->parent = dir; if (current != NULL) @@ -583,7 +546,6 @@ int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir) current = node; } - closedir(&it); if (rc != -ENOENT) { @@ -597,7 +559,7 @@ int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir) return rc; } - dir->flags |= EXFAT_ATTRIB_CACHED; + dir->is_cached = true; return 0; } @@ -627,7 +589,7 @@ static void tree_detach(struct exfat_node* node) static void reset_cache(struct exfat* ef, struct exfat_node* node) { - char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; + char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]; while (node->child) { @@ -636,16 +598,16 @@ static void reset_cache(struct exfat* ef, struct exfat_node* node) tree_detach(p); free(p); } - node->flags &= ~EXFAT_ATTRIB_CACHED; + node->is_cached = false; if (node->references != 0) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_warn("non-zero reference counter (%d) for '%s'", node->references, buffer); } - if (node != ef->root && (node->flags & EXFAT_ATTRIB_DIRTY)) + if (node != ef->root && node->is_dirty) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_bug("node '%s' is dirty", buffer); } while (node->references) @@ -657,32 +619,14 @@ void exfat_reset_cache(struct exfat* ef) reset_cache(ef, ef->root); } -static bool next_entry(struct exfat* ef, const struct exfat_node* parent, - cluster_t* cluster, off_t* offset) -{ - *offset += sizeof(struct exfat_entry); - if (*offset % CLUSTER_SIZE(*ef->sb) == 0) - { - *cluster = exfat_next_cluster(ef, parent, *cluster); - if (CLUSTER_INVALID(*cluster)) - { - exfat_error("invalid cluster %#x while getting next entry", - *cluster); - return false; - } - } - return true; -} - int exfat_flush_node(struct exfat* ef, struct exfat_node* node) { - cluster_t cluster; - off_t offset; - off_t meta1_offset, meta2_offset; - struct exfat_entry_meta1 meta1; - struct exfat_entry_meta2 meta2; + struct exfat_entry entries[1 + node->continuations]; + struct exfat_entry_meta1* meta1 = (struct exfat_entry_meta1*) &entries[0]; + struct exfat_entry_meta2* meta2 = (struct exfat_entry_meta2*) &entries[1]; + int rc; - if (!(node->flags & EXFAT_ATTRIB_DIRTY)) + if (!node->is_dirty) return 0; /* no need to flush */ if (ef->ro) @@ -691,92 +635,65 @@ int exfat_flush_node(struct exfat* ef, struct exfat_node* node) if (node->parent == NULL) return 0; /* do not flush unlinked node */ - cluster = node->entry_cluster; - offset = node->entry_offset; - meta1_offset = co2o(ef, cluster, offset); - if (!next_entry(ef, node->parent, &cluster, &offset)) - return -EIO; - meta2_offset = co2o(ef, cluster, offset); - - if (exfat_pread(ef->dev, &meta1, sizeof(meta1), meta1_offset) < 0) - { - exfat_error("failed to read meta1 entry on flush"); + rc = read_entries(ef, node->parent, entries, 1 + node->continuations, + node->entry_offset); + if (rc != 0) + return rc; + if (!check_entries(entries, 1 + node->continuations)) return -EIO; - } - if (meta1.type != EXFAT_ENTRY_FILE) - exfat_bug("invalid type of meta1: 0x%hhx", meta1.type); - meta1.attrib = cpu_to_le16(node->flags); - exfat_unix2exfat(node->mtime, &meta1.mdate, &meta1.mtime, &meta1.mtime_cs); - exfat_unix2exfat(node->atime, &meta1.adate, &meta1.atime, NULL); - if (exfat_pread(ef->dev, &meta2, sizeof(meta2), meta2_offset) < 0) - { - exfat_error("failed to read meta2 entry on flush"); - return -EIO; - } - if (meta2.type != EXFAT_ENTRY_FILE_INFO) - exfat_bug("invalid type of meta2: 0x%hhx", meta2.type); - meta2.size = meta2.valid_size = cpu_to_le64(node->size); - meta2.start_cluster = cpu_to_le32(node->start_cluster); - meta2.flags = EXFAT_FLAG_ALWAYS1; + meta1->attrib = cpu_to_le16(node->attrib); + exfat_unix2exfat(node->mtime, &meta1->mdate, &meta1->mtime, + &meta1->mtime_cs); + exfat_unix2exfat(node->atime, &meta1->adate, &meta1->atime, NULL); + meta2->size = meta2->valid_size = cpu_to_le64(node->size); + meta2->start_cluster = cpu_to_le32(node->start_cluster); + meta2->flags = EXFAT_FLAG_ALWAYS1; /* empty files must not be marked as contiguous */ - if (node->size != 0 && IS_CONTIGUOUS(*node)) - meta2.flags |= EXFAT_FLAG_CONTIGUOUS; + if (node->size != 0 && node->is_contiguous) + meta2->flags |= EXFAT_FLAG_CONTIGUOUS; /* name hash remains unchanged, no need to recalculate it */ - meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name); - - if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1), meta1_offset) < 0) - { - exfat_error("failed to write meta1 entry on flush"); - return -EIO; - } - if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2), meta2_offset) < 0) - { - exfat_error("failed to write meta2 entry on flush"); - return -EIO; - } + meta1->checksum = exfat_calc_checksum(entries, 1 + node->continuations); + rc = write_entries(ef, node->parent, entries, 1 + node->continuations, + node->entry_offset); + if (rc != 0) + return rc; - node->flags &= ~EXFAT_ATTRIB_DIRTY; + node->is_dirty = false; return exfat_flush(ef); } -static bool erase_entry(struct exfat* ef, struct exfat_node* node) +static int erase_entries(struct exfat* ef, struct exfat_node* dir, int n, + off_t offset) { - cluster_t cluster = node->entry_cluster; - off_t offset = node->entry_offset; - int name_entries = DIV_ROUND_UP(utf16_length(node->name), EXFAT_ENAME_MAX); - uint8_t entry_type; + struct exfat_entry entries[n]; + int rc; + int i; - entry_type = EXFAT_ENTRY_FILE & ~EXFAT_ENTRY_VALID; - if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to erase meta1 entry"); - return false; - } + rc = read_entries(ef, dir, entries, n, offset); + if (rc != 0) + return rc; + for (i = 0; i < n; i++) + entries[i].type &= ~EXFAT_ENTRY_VALID; + return write_entries(ef, dir, entries, n, offset); +} - if (!next_entry(ef, node->parent, &cluster, &offset)) - return false; - entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID; - if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to erase meta2 entry"); - return false; - } +static int erase_node(struct exfat* ef, struct exfat_node* node) +{ + int rc; - while (name_entries--) + exfat_get_node(node->parent); + rc = erase_entries(ef, node->parent, 1 + node->continuations, + node->entry_offset); + if (rc != 0) { - if (!next_entry(ef, node->parent, &cluster, &offset)) - return false; - entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID; - if (exfat_pwrite(ef->dev, &entry_type, 1, - co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to erase name entry"); - return false; - } + exfat_put_node(ef, node->parent); + return rc; } - return true; + rc = exfat_flush_node(ef, node->parent); + exfat_put_node(ef, node->parent); + return rc; } static int shrink_directory(struct exfat* ef, struct exfat_node* dir, @@ -787,9 +704,9 @@ static int shrink_directory(struct exfat* ef, struct exfat_node* dir, uint64_t entries = 0; uint64_t new_size; - if (!(dir->flags & EXFAT_ATTRIB_DIR)) + if (!(dir->attrib & EXFAT_ATTRIB_DIR)) exfat_bug("attempted to shrink a file"); - if (!(dir->flags & EXFAT_ATTRIB_CACHED)) + if (!dir->is_cached) exfat_bug("attempted to shrink uncached directory"); for (last_node = node = dir->child; node; node = node->next) @@ -831,21 +748,22 @@ static int delete(struct exfat* ef, struct exfat_node* node) int rc; exfat_get_node(parent); - if (!erase_entry(ef, node)) + rc = erase_node(ef, node); + if (rc != 0) { exfat_put_node(ef, parent); - return -EIO; + return rc; } - exfat_update_mtime(parent); tree_detach(node); rc = shrink_directory(ef, parent, deleted_offset); - node->flags |= EXFAT_ATTRIB_UNLINKED; + node->is_unlinked = true; if (rc != 0) { exfat_flush_node(ef, parent); exfat_put_node(ef, parent); return rc; } + exfat_update_mtime(parent); rc = exfat_flush_node(ef, parent); exfat_put_node(ef, parent); return rc; @@ -853,7 +771,7 @@ static int delete(struct exfat* ef, struct exfat_node* node) int exfat_unlink(struct exfat* ef, struct exfat_node* node) { - if (node->flags & EXFAT_ATTRIB_DIR) + if (node->attrib & EXFAT_ATTRIB_DIR) return -EISDIR; return delete(ef, node); } @@ -862,7 +780,7 @@ int exfat_rmdir(struct exfat* ef, struct exfat_node* node) { int rc; - if (!(node->flags & EXFAT_ATTRIB_DIR)) + if (!(node->attrib & EXFAT_ATTRIB_DIR)) return -ENOTDIR; /* check that directory is empty */ rc = exfat_cache_directory(ef, node); @@ -873,130 +791,143 @@ int exfat_rmdir(struct exfat* ef, struct exfat_node* node) return delete(ef, node); } -static int grow_directory(struct exfat* ef, struct exfat_node* dir, - uint64_t asize, uint32_t difference) +static int check_slot(struct exfat* ef, struct exfat_node* dir, off_t offset, + int n) { - return exfat_truncate(ef, dir, - DIV_ROUND_UP(asize + difference, CLUSTER_SIZE(*ef->sb)) - * CLUSTER_SIZE(*ef->sb), true); + struct exfat_entry entries[n]; + int rc; + size_t i; + + /* Root directory contains entries, that don't have any nodes associated + with them (clusters bitmap, upper case table, label). We need to be + careful not to overwrite them. */ + if (dir != ef->root) + return 0; + + rc = read_entries(ef, dir, entries, n, offset); + if (rc != 0) + return rc; + for (i = 0; i < n; i++) + if (entries[i].type & EXFAT_ENTRY_VALID) + return -EINVAL; + return 0; } static int find_slot(struct exfat* ef, struct exfat_node* dir, - cluster_t* cluster, off_t* offset, int subentries) + off_t* offset, int n) { - struct iterator it; - int rc; - const struct exfat_entry* entry; + bitmap_t* dmap; + struct exfat_node* p; + size_t i; int contiguous = 0; - rc = opendir(ef, dir, &it); - if (rc != 0) - return rc; - for (;;) + if (!dir->is_cached) + exfat_bug("directory is not cached"); + + /* build a bitmap of valid entries in the directory */ + dmap = calloc(BMAP_SIZE(dir->size / sizeof(struct exfat_entry)), + sizeof(bitmap_t)); + if (dmap == NULL) + { + exfat_error("failed to allocate directory bitmap (%"PRIu64")", + dir->size / sizeof(struct exfat_entry)); + return -ENOMEM; + } + for (p = dir->child; p != NULL; p = p->next) + for (i = 0; i < 1 + p->continuations; i++) + BMAP_SET(dmap, p->entry_offset / sizeof(struct exfat_entry) + i); + + /* find a slot in the directory entries bitmap */ + for (i = 0; i < dir->size / sizeof(struct exfat_entry); i++) { - if (contiguous == 0) + if (BMAP_GET(dmap, i) == 0) { - *cluster = it.cluster; - *offset = it.offset; + if (contiguous++ == 0) + *offset = (off_t) i * sizeof(struct exfat_entry); + if (contiguous == n) + /* suitable slot is found, check that it's not occupied */ + switch (check_slot(ef, dir, *offset, n)) + { + case 0: + free(dmap); + return 0; + case -EIO: + free(dmap); + return -EIO; + case -EINVAL: + /* slot is occupied, continue searching */ + contiguous = 0; + break; + } } - entry = get_entry_ptr(ef, &it); - if (entry->type & EXFAT_ENTRY_VALID) - contiguous = 0; else - contiguous++; - if (contiguous == subentries) - break; /* suitable slot is found */ - if (it.offset + sizeof(struct exfat_entry) >= dir->size) - { - rc = grow_directory(ef, dir, dir->size, - (subentries - contiguous) * sizeof(struct exfat_entry)); - if (rc != 0) - { - closedir(&it); - return rc; - } - } - if (!fetch_next_entry(ef, dir, &it)) - { - closedir(&it); - return -EIO; - } + contiguous = 0; } - closedir(&it); - return 0; + free(dmap); + + /* no suitable slots found, extend the directory */ + if (contiguous == 0) + *offset = dir->size; + return exfat_truncate(ef, dir, + ROUND_UP(dir->size + sizeof(struct exfat_entry[n - contiguous]), + CLUSTER_SIZE(*ef->sb)), + true); } -static int write_entry(struct exfat* ef, struct exfat_node* dir, - const le16_t* name, cluster_t cluster, off_t offset, uint16_t attrib) +static int commit_entry(struct exfat* ef, struct exfat_node* dir, + const le16_t* name, off_t offset, uint16_t attrib) { struct exfat_node* node; - struct exfat_entry_meta1 meta1; - struct exfat_entry_meta2 meta2; const size_t name_length = utf16_length(name); const int name_entries = DIV_ROUND_UP(name_length, EXFAT_ENAME_MAX); + struct exfat_entry entries[2 + name_entries]; + struct exfat_entry_meta1* meta1 = (struct exfat_entry_meta1*) &entries[0]; + struct exfat_entry_meta2* meta2 = (struct exfat_entry_meta2*) &entries[1]; int i; + int rc; - node = allocate_node(); - if (node == NULL) - return -ENOMEM; - node->entry_cluster = cluster; - node->entry_offset = offset; - memcpy(node->name, name, name_length * sizeof(le16_t)); + memset(entries, 0, sizeof(struct exfat_entry[2])); + + meta1->type = EXFAT_ENTRY_FILE; + meta1->continuations = 1 + name_entries; + meta1->attrib = cpu_to_le16(attrib); + exfat_unix2exfat(time(NULL), &meta1->crdate, &meta1->crtime, + &meta1->crtime_cs); + meta1->adate = meta1->mdate = meta1->crdate; + meta1->atime = meta1->mtime = meta1->crtime; + meta1->mtime_cs = meta1->crtime_cs; /* there is no atime_cs */ + + meta2->type = EXFAT_ENTRY_FILE_INFO; + meta2->flags = EXFAT_FLAG_ALWAYS1; + meta2->name_length = name_length; + meta2->name_hash = exfat_calc_name_hash(ef, name, name_length); + meta2->start_cluster = cpu_to_le32(EXFAT_CLUSTER_FREE); - memset(&meta1, 0, sizeof(meta1)); - meta1.type = EXFAT_ENTRY_FILE; - meta1.continuations = 1 + name_entries; - meta1.attrib = cpu_to_le16(attrib); - exfat_unix2exfat(time(NULL), &meta1.crdate, &meta1.crtime, - &meta1.crtime_cs); - meta1.adate = meta1.mdate = meta1.crdate; - meta1.atime = meta1.mtime = meta1.crtime; - meta1.mtime_cs = meta1.crtime_cs; /* there is no atime_cs */ - - memset(&meta2, 0, sizeof(meta2)); - meta2.type = EXFAT_ENTRY_FILE_INFO; - meta2.flags = EXFAT_FLAG_ALWAYS1; - meta2.name_length = name_length; - meta2.name_hash = exfat_calc_name_hash(ef, node->name); - meta2.start_cluster = cpu_to_le32(EXFAT_CLUSTER_FREE); - - meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name); - - if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1), - co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to write meta1 entry"); - return -EIO; - } - if (!next_entry(ef, dir, &cluster, &offset)) - return -EIO; - if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2), - co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to write meta2 entry"); - return -EIO; - } for (i = 0; i < name_entries; i++) { - struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0}; - memcpy(name_entry.name, node->name + i * EXFAT_ENAME_MAX, - MIN(EXFAT_ENAME_MAX, EXFAT_NAME_MAX - i * EXFAT_ENAME_MAX) * - sizeof(le16_t)); - if (!next_entry(ef, dir, &cluster, &offset)) - return -EIO; - if (exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry), - co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to write name entry"); - return -EIO; - } + struct exfat_entry_name* name_entry; + + name_entry = (struct exfat_entry_name*) &entries[2 + i]; + name_entry->type = EXFAT_ENTRY_FILE_NAME; + name_entry->__unknown = 0; + memcpy(name_entry->name, name + i * EXFAT_ENAME_MAX, + EXFAT_ENAME_MAX * sizeof(le16_t)); } - init_node_meta1(node, &meta1); - init_node_meta2(node, &meta2); + meta1->checksum = exfat_calc_checksum(entries, 2 + name_entries); + rc = write_entries(ef, dir, entries, 2 + name_entries, offset); + if (rc != 0) + return rc; + + node = allocate_node(); + if (node == NULL) + return -ENOMEM; + node->entry_offset = offset; + memcpy(node->name, name, name_length * sizeof(le16_t)); + init_node_meta1(node, meta1); + init_node_meta2(node, meta2); tree_attach(dir, node); - exfat_update_mtime(dir); return 0; } @@ -1004,7 +935,6 @@ static int create(struct exfat* ef, const char* path, uint16_t attrib) { struct exfat_node* dir; struct exfat_node* existing; - cluster_t cluster = EXFAT_CLUSTER_BAD; off_t offset = -1; le16_t name[EXFAT_NAME_MAX + 1]; int rc; @@ -1019,19 +949,20 @@ static int create(struct exfat* ef, const char* path, uint16_t attrib) return -EEXIST; } - rc = find_slot(ef, dir, &cluster, &offset, + rc = find_slot(ef, dir, &offset, 2 + DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX)); if (rc != 0) { exfat_put_node(ef, dir); return rc; } - rc = write_entry(ef, dir, name, cluster, offset, attrib); + rc = commit_entry(ef, dir, name, offset, attrib); if (rc != 0) { exfat_put_node(ef, dir); return rc; } + exfat_update_mtime(dir); rc = exfat_flush_node(ef, dir); exfat_put_node(ef, dir); return rc; @@ -1073,72 +1004,47 @@ int exfat_mkdir(struct exfat* ef, const char* path) } static int rename_entry(struct exfat* ef, struct exfat_node* dir, - struct exfat_node* node, const le16_t* name, cluster_t new_cluster, - off_t new_offset) + struct exfat_node* node, const le16_t* name, off_t new_offset) { - struct exfat_entry_meta1 meta1; - struct exfat_entry_meta2 meta2; - cluster_t old_cluster = node->entry_cluster; - off_t old_offset = node->entry_offset; const size_t name_length = utf16_length(name); const int name_entries = DIV_ROUND_UP(name_length, EXFAT_ENAME_MAX); + struct exfat_entry entries[2 + name_entries]; + struct exfat_entry_meta1* meta1 = (struct exfat_entry_meta1*) &entries[0]; + struct exfat_entry_meta2* meta2 = (struct exfat_entry_meta2*) &entries[1]; + int rc; int i; - if (exfat_pread(ef->dev, &meta1, sizeof(meta1), - co2o(ef, old_cluster, old_offset)) < 0) - { - exfat_error("failed to read meta1 entry on rename"); - return -EIO; - } - if (!next_entry(ef, node->parent, &old_cluster, &old_offset)) - return -EIO; - if (exfat_pread(ef->dev, &meta2, sizeof(meta2), - co2o(ef, old_cluster, old_offset)) < 0) - { - exfat_error("failed to read meta2 entry on rename"); - return -EIO; - } - meta1.continuations = 1 + name_entries; - meta2.name_hash = exfat_calc_name_hash(ef, name); - meta2.name_length = name_length; - meta1.checksum = exfat_calc_checksum(&meta1, &meta2, name); + rc = read_entries(ef, node->parent, entries, 2, node->entry_offset); + if (rc != 0) + return rc; - if (!erase_entry(ef, node)) - return -EIO; + meta1->continuations = 1 + name_entries; + meta2->name_length = name_length; + meta2->name_hash = exfat_calc_name_hash(ef, name, name_length); - node->entry_cluster = new_cluster; - node->entry_offset = new_offset; + rc = erase_node(ef, node); + if (rc != 0) + return rc; - if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1), - co2o(ef, new_cluster, new_offset)) < 0) - { - exfat_error("failed to write meta1 entry on rename"); - return -EIO; - } - if (!next_entry(ef, dir, &new_cluster, &new_offset)) - return -EIO; - if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2), - co2o(ef, new_cluster, new_offset)) < 0) - { - exfat_error("failed to write meta2 entry on rename"); - return -EIO; - } + node->entry_offset = new_offset; + node->continuations = 1 + name_entries; for (i = 0; i < name_entries; i++) { - struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0}; - memcpy(name_entry.name, name + i * EXFAT_ENAME_MAX, + struct exfat_entry_name* name_entry; + + name_entry = (struct exfat_entry_name*) &entries[2 + i]; + name_entry->type = EXFAT_ENTRY_FILE_NAME; + name_entry->__unknown = 0; + memcpy(name_entry->name, name + i * EXFAT_ENAME_MAX, EXFAT_ENAME_MAX * sizeof(le16_t)); - if (!next_entry(ef, dir, &new_cluster, &new_offset)) - return -EIO; - if (exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry), - co2o(ef, new_cluster, new_offset)) < 0) - { - exfat_error("failed to write name entry on rename"); - return -EIO; - } } + meta1->checksum = exfat_calc_checksum(entries, 2 + name_entries); + rc = write_entries(ef, dir, entries, 2 + name_entries, new_offset); + if (rc != 0) + return rc; + memcpy(node->name, name, (EXFAT_NAME_MAX + 1) * sizeof(le16_t)); tree_detach(node); tree_attach(dir, node); @@ -1150,7 +1056,6 @@ int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path) struct exfat_node* node; struct exfat_node* existing; struct exfat_node* dir; - cluster_t cluster = EXFAT_CLUSTER_BAD; off_t offset = -1; le16_t name[EXFAT_NAME_MAX + 1]; int rc; @@ -1167,7 +1072,7 @@ int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path) } /* check that target is not a subdirectory of the source */ - if (node->flags & EXFAT_ATTRIB_DIR) + if (node->attrib & EXFAT_ATTRIB_DIR) { struct exfat_node* p; @@ -1187,16 +1092,16 @@ int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path) /* remove target if it's not the same node as source */ if (existing != node) { - if (existing->flags & EXFAT_ATTRIB_DIR) + if (existing->attrib & EXFAT_ATTRIB_DIR) { - if (node->flags & EXFAT_ATTRIB_DIR) + if (node->attrib & EXFAT_ATTRIB_DIR) rc = exfat_rmdir(ef, existing); else rc = -ENOTDIR; } else { - if (!(node->flags & EXFAT_ATTRIB_DIR)) + if (!(node->attrib & EXFAT_ATTRIB_DIR)) rc = exfat_unlink(ef, existing); else rc = -EISDIR; @@ -1223,7 +1128,7 @@ int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path) exfat_put_node(ef, existing); } - rc = find_slot(ef, dir, &cluster, &offset, + rc = find_slot(ef, dir, &offset, 2 + DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX)); if (rc != 0) { @@ -1231,9 +1136,17 @@ int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path) exfat_put_node(ef, node); return rc; } - rc = rename_entry(ef, dir, node, name, cluster, offset); + rc = rename_entry(ef, dir, node, name, offset); + if (rc != 0) + { + exfat_put_node(ef, dir); + exfat_put_node(ef, node); + return rc; + } + rc = exfat_flush_node(ef, dir); exfat_put_node(ef, dir); exfat_put_node(ef, node); + /* node itself is not marked as dirty, no need to flush it */ return rc; } @@ -1241,19 +1154,19 @@ void exfat_utimes(struct exfat_node* node, const struct timespec tv[2]) { node->atime = tv[0].tv_sec; node->mtime = tv[1].tv_sec; - node->flags |= EXFAT_ATTRIB_DIRTY; + node->is_dirty = true; } void exfat_update_atime(struct exfat_node* node) { node->atime = time(NULL); - node->flags |= EXFAT_ATTRIB_DIRTY; + node->is_dirty = true; } void exfat_update_mtime(struct exfat_node* node) { node->mtime = time(NULL); - node->flags |= EXFAT_ATTRIB_DIRTY; + node->is_dirty = true; } const char* exfat_get_label(struct exfat* ef) @@ -1261,36 +1174,19 @@ const char* exfat_get_label(struct exfat* ef) return ef->label; } -static int find_label(struct exfat* ef, cluster_t* cluster, off_t* offset) +static int find_label(struct exfat* ef, off_t* offset) { - struct iterator it; + struct exfat_entry entry; int rc; - rc = opendir(ef, ef->root, &it); - if (rc != 0) - return rc; - - for (;;) + for (*offset = 0; ; *offset += sizeof(entry)) { - if (it.offset >= ef->root->size) - { - closedir(&it); - return -ENOENT; - } + rc = read_entries(ef, ef->root, &entry, 1, *offset); + if (rc != 0) + return rc; - if (get_entry_ptr(ef, &it)->type == EXFAT_ENTRY_LABEL) - { - *cluster = it.cluster; - *offset = it.offset; - closedir(&it); + if (entry.type == EXFAT_ENTRY_LABEL) return 0; - } - - if (!fetch_next_entry(ef, ef->root, &it)) - { - closedir(&it); - return -EIO; - } } } @@ -1298,18 +1194,17 @@ int exfat_set_label(struct exfat* ef, const char* label) { le16_t label_utf16[EXFAT_ENAME_MAX + 1]; int rc; - cluster_t cluster; off_t offset; struct exfat_entry_label entry; memset(label_utf16, 0, sizeof(label_utf16)); - rc = utf8_to_utf16(label_utf16, label, EXFAT_ENAME_MAX, strlen(label)); + rc = utf8_to_utf16(label_utf16, label, EXFAT_ENAME_MAX + 1, strlen(label)); if (rc != 0) return rc; - rc = find_label(ef, &cluster, &offset); + rc = find_label(ef, &offset); if (rc == -ENOENT) - rc = find_slot(ef, ef->root, &cluster, &offset, 1); + rc = find_slot(ef, ef->root, &offset, 1); if (rc != 0) return rc; @@ -1319,12 +1214,10 @@ int exfat_set_label(struct exfat* ef, const char* label) if (entry.length == 0) entry.type ^= EXFAT_ENTRY_VALID; - if (exfat_pwrite(ef->dev, &entry, sizeof(struct exfat_entry_label), - co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to write label entry"); - return -EIO; - } + rc = write_entries(ef, ef->root, (struct exfat_entry*) &entry, 1, offset); + if (rc != 0) + return rc; + strcpy(ef->label, label); return 0; } diff --git a/libexfat/platform.h b/libexfat/platform.h index 4c5a0df..b3505f4 100644 --- a/libexfat/platform.h +++ b/libexfat/platform.h @@ -4,7 +4,7 @@ same kernel can use different libc implementations. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 diff --git a/libexfat/time.c b/libexfat/time.c index 93c1d67..3ef99e8 100644 --- a/libexfat/time.c +++ b/libexfat/time.c @@ -3,7 +3,7 @@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 diff --git a/libexfat/utf.c b/libexfat/utf.c index 98ae52d..d8968db 100644 --- a/libexfat/utf.c +++ b/libexfat/utf.c @@ -3,7 +3,7 @@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 @@ -108,7 +108,7 @@ int utf16_to_utf8(char* output, const le16_t* input, size_t outsize, char* outp = output; wchar_t wc; - while (inp - input < insize && le16_to_cpu(*inp)) + while (inp - input < insize) { inp = utf16_to_wchar(inp, &wc, insize - (inp - input)); if (inp == NULL) @@ -122,6 +122,13 @@ int utf16_to_utf8(char* output, const le16_t* input, size_t outsize, exfat_error("name is too long"); return -ENAMETOOLONG; } + if (wc == 0) + return 0; + } + if (outp - output >= outsize) + { + exfat_error("name is too long"); + return -ENAMETOOLONG; } *outp = '\0'; return 0; @@ -202,7 +209,7 @@ int utf8_to_utf16(le16_t* output, const char* input, size_t outsize, le16_t* outp = output; wchar_t wc; - while (inp - input < insize && *inp) + while (inp - input < insize) { inp = utf8_to_wchar(inp, &wc, insize - (inp - input)); if (inp == NULL) @@ -216,6 +223,13 @@ int utf8_to_utf16(le16_t* output, const char* input, size_t outsize, exfat_error("name is too long"); return -ENAMETOOLONG; } + if (wc == 0) + break; + } + if (outp - output >= outsize) + { + exfat_error("name is too long"); + return -ENAMETOOLONG; } *outp = cpu_to_le16(0); return 0; diff --git a/libexfat/utils.c b/libexfat/utils.c index 0d3b809..c080d4c 100644 --- a/libexfat/utils.c +++ b/libexfat/utils.c @@ -3,7 +3,7 @@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 Andrew Nayenko 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 @@ -29,7 +29,7 @@ void exfat_stat(const struct exfat* ef, const struct exfat_node* node, struct stat* stbuf) { memset(stbuf, 0, sizeof(struct stat)); - if (node->flags & EXFAT_ATTRIB_DIR) + if (node->attrib & EXFAT_ATTRIB_DIR) stbuf->st_mode = S_IFDIR | (0777 & ~ef->dmask); else stbuf->st_mode = S_IFREG | (0777 & ~ef->fmask); @@ -37,8 +37,7 @@ void exfat_stat(const struct exfat* ef, const struct exfat_node* node, stbuf->st_uid = ef->uid; stbuf->st_gid = ef->gid; stbuf->st_size = node->size; - stbuf->st_blocks = DIV_ROUND_UP(node->size, CLUSTER_SIZE(*ef->sb)) * - CLUSTER_SIZE(*ef->sb) / 512; + stbuf->st_blocks = ROUND_UP(node->size, CLUSTER_SIZE(*ef->sb)) / 512; stbuf->st_mtime = node->mtime; stbuf->st_atime = node->atime; /* set ctime to mtime to ensure we don't break programs that rely on ctime @@ -46,12 +45,28 @@ void exfat_stat(const struct exfat* ef, const struct exfat_node* node, stbuf->st_ctime = node->mtime; } -void exfat_get_name(const struct exfat_node* node, char* buffer, size_t n) +void exfat_get_name(const struct exfat_node* node, + char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]) { - if (utf16_to_utf8(buffer, node->name, n, EXFAT_NAME_MAX) != 0) + if (utf16_to_utf8(buffer, node->name, EXFAT_UTF8_NAME_BUFFER_MAX, + EXFAT_NAME_MAX) != 0) exfat_bug("failed to convert name to UTF-8"); } +static uint16_t add_checksum_byte(uint16_t sum, uint8_t byte) +{ + return ((sum << 15) | (sum >> 1)) + byte; +} + +static uint16_t add_checksum_bytes(uint16_t sum, const void* buffer, size_t n) +{ + int i; + + for (i = 0; i < n; i++) + sum = add_checksum_byte(sum, ((const uint8_t*) buffer)[i]); + return sum; +} + uint16_t exfat_start_checksum(const struct exfat_entry_meta1* entry) { uint16_t sum = 0; @@ -59,36 +74,23 @@ uint16_t exfat_start_checksum(const struct exfat_entry_meta1* entry) for (i = 0; i < sizeof(struct exfat_entry); i++) if (i != 2 && i != 3) /* skip checksum field itself */ - sum = ((sum << 15) | (sum >> 1)) + ((const uint8_t*) entry)[i]; + sum = add_checksum_byte(sum, ((const uint8_t*) entry)[i]); return sum; } uint16_t exfat_add_checksum(const void* entry, uint16_t sum) { - int i; - - for (i = 0; i < sizeof(struct exfat_entry); i++) - sum = ((sum << 15) | (sum >> 1)) + ((const uint8_t*) entry)[i]; - return sum; + return add_checksum_bytes(sum, entry, sizeof(struct exfat_entry)); } -le16_t exfat_calc_checksum(const struct exfat_entry_meta1* meta1, - const struct exfat_entry_meta2* meta2, const le16_t* name) +le16_t exfat_calc_checksum(const struct exfat_entry* entries, int n) { uint16_t checksum; - const int name_entries = DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX); int i; - checksum = exfat_start_checksum(meta1); - checksum = exfat_add_checksum(meta2, checksum); - for (i = 0; i < name_entries; i++) - { - struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0}; - memcpy(name_entry.name, name + i * EXFAT_ENAME_MAX, - MIN(EXFAT_ENAME_MAX, EXFAT_NAME_MAX - i * EXFAT_ENAME_MAX) * - sizeof(le16_t)); - checksum = exfat_add_checksum(&name_entry, checksum); - } + checksum = exfat_start_checksum((const struct exfat_entry_meta1*) entries); + for (i = 1; i < n; i++) + checksum = exfat_add_checksum(entries + i, checksum); return cpu_to_le16(checksum); } @@ -113,10 +115,10 @@ uint32_t exfat_vbr_add_checksum(const void* sector, size_t size, uint32_t sum) return sum; } -le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name) +le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name, + size_t length) { size_t i; - size_t length = utf16_length(name); uint16_t hash = 0; for (i = 0; i < length; i++)