summaryrefslogtreecommitdiffstats
path: root/exfat/libexfat
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--exfat/libexfat/Android.mk13
-rw-r--r--exfat/libexfat/byteorder.h109
-rw-r--r--exfat/libexfat/cluster.c445
-rw-r--r--exfat/libexfat/exfat.h215
-rw-r--r--exfat/libexfat/exfatfs.h163
-rw-r--r--exfat/libexfat/io.c385
-rw-r--r--exfat/libexfat/log.c108
-rw-r--r--exfat/libexfat/lookup.c223
-rw-r--r--exfat/libexfat/mount.c314
-rw-r--r--exfat/libexfat/node.c1041
-rw-r--r--exfat/libexfat/time.c156
-rw-r--r--exfat/libexfat/utf.c229
-rw-r--r--exfat/libexfat/utils.c176
-rw-r--r--exfat/libexfat/version.h28
14 files changed, 3605 insertions, 0 deletions
diff --git a/exfat/libexfat/Android.mk b/exfat/libexfat/Android.mk
new file mode 100644
index 000000000..0b7f963a7
--- /dev/null
+++ b/exfat/libexfat/Android.mk
@@ -0,0 +1,13 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libexfat
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin
+LOCAL_CFLAGS = -D_FILE_OFFSET_BITS=64
+LOCAL_SRC_FILES = cluster.c io.c log.c lookup.c mount.c node.c time.c utf.c utils.c
+LOCAL_C_INCLUDES += $(LOCAL_PATH) \
+LOCAL_SHARED_LIBRARIES += libc
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/exfat/libexfat/byteorder.h b/exfat/libexfat/byteorder.h
new file mode 100644
index 000000000..4850efb3d
--- /dev/null
+++ b/exfat/libexfat/byteorder.h
@@ -0,0 +1,109 @@
+/*
+ byteorder.h (12.01.10)
+ Endianness stuff. exFAT uses little-endian byte order.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#ifndef BYTEORDER_H_INCLUDED
+#define BYTEORDER_H_INCLUDED
+
+#define __GLIBC__
+#include <stdint.h>
+
+#if defined(__GLIBC__)
+
+#include <endian.h>
+#include <byteswap.h>
+
+#elif defined(__APPLE__)
+
+#include <machine/endian.h>
+#include <libkern/OSByteOrder.h>
+#define bswap_16(x) OSSwapInt16(x)
+#define bswap_32(x) OSSwapInt32(x)
+#define bswap_64(x) OSSwapInt64(x)
+#define __BYTE_ORDER BYTE_ORDER
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#define __BIG_ENDIAN BIG_ENDIAN
+
+#elif defined(__FreeBSD__) || defined(__DragonFlyBSD__) || defined(__NetBSD__)
+
+#include <sys/endian.h>
+#define bswap_16(x) bswap16(x)
+#define bswap_32(x) bswap32(x)
+#define bswap_64(x) bswap64(x)
+#define __BYTE_ORDER _BYTE_ORDER
+#define __LITTLE_ENDIAN _LITTLE_ENDIAN
+#define __BIG_ENDIAN _BIG_ENDIAN
+
+#elif defined(__OpenBSD__)
+
+#include <machine/endian.h>
+#define bswap_16(x) swap16(x)
+#define bswap_32(x) swap32(x)
+#define bswap_64(x) swap64(x)
+#define __BYTE_ORDER _BYTE_ORDER
+#define __LITTLE_ENDIAN _LITTLE_ENDIAN
+#define __BIG_ENDIAN _BIG_ENDIAN
+
+#elif defined(__sun)
+
+#include <sys/byteorder.h>
+#define bswap_16(x) BSWAP_16(x)
+#define bswap_32(x) BSWAP_32(x)
+#define bswap_64(x) BSWAP_64(x)
+#define __LITTLE_ENDIAN 1234
+#define __BIG_ENDIAN 4321
+#ifdef _LITTLE_ENDIAN
+#define __BYTE_ORDER __LITTLE_ENDIAN
+#else
+#define __BYTE_ORDER __BIG_ENDIAN
+#endif
+
+#else
+#error No byte order macros available for your platform
+#endif
+
+#define __BYTE_ORDER __LITTLE_ENDIAN
+typedef struct { uint16_t __u16; } le16_t;
+typedef struct { uint32_t __u32; } le32_t;
+typedef struct { uint64_t __u64; } le64_t;
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+static inline uint16_t le16_to_cpu(le16_t v) { return v.__u16; }
+static inline uint32_t le32_to_cpu(le32_t v) { return v.__u32; }
+static inline uint64_t le64_to_cpu(le64_t v) { return v.__u64; }
+
+static inline le16_t cpu_to_le16(uint16_t v) { le16_t t = {v}; return t; }
+static inline le32_t cpu_to_le32(uint32_t v) { le32_t t = {v}; return t; }
+static inline le64_t cpu_to_le64(uint64_t v) { le64_t t = {v}; return t; }
+#elif __BYTE_ORDER == __BIG_ENDIAN
+static inline uint16_t le16_to_cpu(le16_t v) { return bswap_16(v.__u16); }
+static inline uint32_t le32_to_cpu(le32_t v) { return bswap_32(v.__u32); }
+static inline uint64_t le64_to_cpu(le64_t v) { return bswap_64(v.__u64); }
+
+static inline le16_t cpu_to_le16(uint16_t v)
+ { le16_t t = {bswap_16(v)}; return t; }
+static inline le32_t cpu_to_le32(uint32_t v)
+ { le32_t t = {bswap_32(v)}; return t; }
+static inline le64_t cpu_to_le64(uint64_t v)
+ { le64_t t = {bswap_64(v)}; return t; }
+#else
+#error Wow! You have a PDP machine?!
+#endif
+
+#endif /* ifndef BYTEORDER_H_INCLUDED */
diff --git a/exfat/libexfat/cluster.c b/exfat/libexfat/cluster.c
new file mode 100644
index 000000000..cb3e87165
--- /dev/null
+++ b/exfat/libexfat/cluster.c
@@ -0,0 +1,445 @@
+/*
+ cluster.c (03.09.09)
+ exFAT file system implementation library.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#include "exfat.h"
+#include <errno.h>
+#include <string.h>
+
+/*
+ * Sector to absolute offset.
+ */
+static off64_t s2o(const struct exfat* ef, off64_t sector)
+{
+ return sector << ef->sb->sector_bits;
+}
+
+/*
+ * Cluster to sector.
+ */
+static off64_t c2s(const struct exfat* ef, cluster_t cluster)
+{
+ if (cluster < EXFAT_FIRST_DATA_CLUSTER)
+ exfat_bug("invalid cluster number %u", cluster);
+ return le32_to_cpu(ef->sb->cluster_sector_start) +
+ ((off64_t) (cluster - EXFAT_FIRST_DATA_CLUSTER) << ef->sb->spc_bits);
+}
+
+/*
+ * Cluster to absolute offset.
+ */
+off64_t exfat_c2o(const struct exfat* ef, cluster_t cluster)
+{
+ return s2o(ef, c2s(ef, cluster));
+}
+
+/*
+ * Sector to cluster.
+ */
+static cluster_t s2c(const struct exfat* ef, off64_t sector)
+{
+ return ((sector - le32_to_cpu(ef->sb->cluster_sector_start)) >>
+ ef->sb->spc_bits) + EXFAT_FIRST_DATA_CLUSTER;
+}
+
+/*
+ * Size in bytes to size in clusters (rounded upwards).
+ */
+static uint32_t bytes2clusters(const struct exfat* ef, uint64_t bytes)
+{
+ uint64_t cluster_size = CLUSTER_SIZE(*ef->sb);
+ return (bytes + cluster_size - 1) / cluster_size;
+}
+
+cluster_t exfat_next_cluster(const struct exfat* ef,
+ const struct exfat_node* node, cluster_t cluster)
+{
+ le32_t next;
+ off64_t fat_offset;
+
+ if (cluster < EXFAT_FIRST_DATA_CLUSTER)
+ exfat_bug("bad cluster 0x%x", cluster);
+
+ if (IS_CONTIGUOUS(*node))
+ return cluster + 1;
+ fat_offset = s2o(ef, le32_to_cpu(ef->sb->fat_sector_start))
+ + cluster * sizeof(cluster_t);
+ exfat_pread(ef->dev, &next, sizeof(next), fat_offset);
+ return le32_to_cpu(next);
+}
+
+cluster_t exfat_advance_cluster(const struct exfat* ef,
+ struct exfat_node* node, uint32_t count)
+{
+ uint32_t i;
+
+ if (node->fptr_index > count)
+ {
+ node->fptr_index = 0;
+ node->fptr_cluster = node->start_cluster;
+ }
+
+ 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))
+ break; /* the caller should handle this and print appropriate
+ error message */
+ }
+ node->fptr_index = count;
+ return node->fptr_cluster;
+}
+
+static cluster_t find_bit_and_set(uint8_t* bitmap, cluster_t start,
+ cluster_t end)
+{
+ const cluster_t mid_start = (start + 7) / 8 * 8;
+ const cluster_t mid_end = end / 8 * 8;
+ cluster_t c;
+ cluster_t byte;
+
+ for (c = start; c < mid_start; c++)
+ if (BMAP_GET(bitmap, c) == 0)
+ {
+ BMAP_SET(bitmap, c);
+ return c + EXFAT_FIRST_DATA_CLUSTER;
+ }
+
+ for (byte = mid_start / 8; byte < mid_end / 8; byte++)
+ if (bitmap[byte] != 0xff)
+ {
+ cluster_t bit;
+
+ for (bit = 0; bit < 8; bit++)
+ if (!(bitmap[byte] & (1u << bit)))
+ {
+ bitmap[byte] |= (1u << bit);
+ return byte * 8 + bit + EXFAT_FIRST_DATA_CLUSTER;
+ }
+ }
+
+ for (c = mid_end; c < end; c++)
+ if (BMAP_GET(bitmap, c) == 0)
+ {
+ BMAP_SET(bitmap, c);
+ return c + EXFAT_FIRST_DATA_CLUSTER;
+ }
+
+ return EXFAT_CLUSTER_END;
+}
+
+void exfat_flush_cmap(struct exfat* ef)
+{
+ exfat_pwrite(ef->dev, ef->cmap.chunk, (ef->cmap.chunk_size + 7) / 8,
+ exfat_c2o(ef, ef->cmap.start_cluster));
+ ef->cmap.dirty = false;
+}
+
+static void set_next_cluster(const struct exfat* ef, int contiguous,
+ cluster_t current, cluster_t next)
+{
+ off64_t fat_offset;
+ le32_t next_le32;
+
+ if (contiguous)
+ return;
+ fat_offset = s2o(ef, le32_to_cpu(ef->sb->fat_sector_start))
+ + current * sizeof(cluster_t);
+ next_le32 = cpu_to_le32(next);
+ exfat_pwrite(ef->dev, &next_le32, sizeof(next_le32), fat_offset);
+}
+
+static cluster_t allocate_cluster(struct exfat* ef, cluster_t hint)
+{
+ cluster_t cluster;
+
+ hint -= EXFAT_FIRST_DATA_CLUSTER;
+ if (hint >= ef->cmap.chunk_size)
+ hint = 0;
+
+ cluster = find_bit_and_set(ef->cmap.chunk, hint, ef->cmap.chunk_size);
+ if (cluster == EXFAT_CLUSTER_END)
+ cluster = find_bit_and_set(ef->cmap.chunk, 0, hint);
+ if (cluster == EXFAT_CLUSTER_END)
+ {
+ exfat_error("no free space left");
+ return EXFAT_CLUSTER_END;
+ }
+
+ ef->cmap.dirty = true;
+ return cluster;
+}
+
+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,
+ ef->cmap.size);
+
+ BMAP_CLR(ef->cmap.chunk, cluster - EXFAT_FIRST_DATA_CLUSTER);
+ ef->cmap.dirty = true;
+}
+
+static void make_noncontiguous(const struct exfat* ef, cluster_t first,
+ cluster_t last)
+{
+ cluster_t c;
+
+ for (c = first; c < last; c++)
+ set_next_cluster(ef, 0, c, c + 1);
+}
+
+static int shrink_file(struct exfat* ef, struct exfat_node* node,
+ uint32_t current, uint32_t difference);
+
+static int grow_file(struct exfat* ef, struct exfat_node* node,
+ uint32_t current, uint32_t difference)
+{
+ cluster_t previous;
+ cluster_t next;
+ uint32_t allocated = 0;
+
+ if (difference == 0)
+ exfat_bug("zero clusters count passed");
+
+ if (node->start_cluster != EXFAT_CLUSTER_FREE)
+ {
+ /* get the last cluster of the file */
+ previous = exfat_advance_cluster(ef, node, current - 1);
+ if (CLUSTER_INVALID(previous))
+ {
+ exfat_error("invalid cluster 0x%x while growing", previous);
+ return -EIO;
+ }
+ }
+ else
+ {
+ if (node->fptr_index != 0)
+ exfat_bug("non-zero pointer index (%u)", node->fptr_index);
+ /* file does not have clusters (i.e. is empty), allocate
+ the first one for it */
+ previous = allocate_cluster(ef, 0);
+ if (CLUSTER_INVALID(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;
+ }
+
+ while (allocated < difference)
+ {
+ next = allocate_cluster(ef, previous + 1);
+ if (CLUSTER_INVALID(next))
+ {
+ if (allocated != 0)
+ shrink_file(ef, node, current + allocated, allocated);
+ return -ENOSPC;
+ }
+ if (next != previous - 1 && IS_CONTIGUOUS(*node))
+ {
+ /* it's a pity, but we are not able to keep the file contiguous
+ anymore */
+ make_noncontiguous(ef, node->start_cluster, previous);
+ node->flags &= ~EXFAT_ATTRIB_CONTIGUOUS;
+ node->flags |= EXFAT_ATTRIB_DIRTY;
+ }
+ set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, next);
+ previous = next;
+ allocated++;
+ }
+
+ set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, EXFAT_CLUSTER_END);
+ return 0;
+}
+
+static int shrink_file(struct exfat* ef, struct exfat_node* node,
+ uint32_t current, uint32_t difference)
+{
+ cluster_t previous;
+ cluster_t next;
+
+ if (difference == 0)
+ exfat_bug("zero difference passed");
+ if (node->start_cluster == EXFAT_CLUSTER_FREE)
+ exfat_bug("unable to shrink empty file (%u clusters)", current);
+ if (current < difference)
+ exfat_bug("file underflow (%u < %u)", current, difference);
+
+ /* crop the file */
+ if (current > difference)
+ {
+ cluster_t last = exfat_advance_cluster(ef, node,
+ current - difference - 1);
+ if (CLUSTER_INVALID(last))
+ {
+ exfat_error("invalid cluster 0x%x while shrinking", last);
+ return -EIO;
+ }
+ previous = exfat_next_cluster(ef, node, last);
+ set_next_cluster(ef, IS_CONTIGUOUS(*node), last, EXFAT_CLUSTER_END);
+ }
+ else
+ {
+ previous = node->start_cluster;
+ node->start_cluster = EXFAT_CLUSTER_FREE;
+ }
+ node->fptr_index = 0;
+ node->fptr_cluster = node->start_cluster;
+
+ /* free remaining clusters */
+ while (difference--)
+ {
+ if (CLUSTER_INVALID(previous))
+ {
+ exfat_error("invalid cluster 0x%x while freeing after shrink",
+ previous);
+ return -EIO;
+ }
+ next = exfat_next_cluster(ef, node, previous);
+ set_next_cluster(ef, IS_CONTIGUOUS(*node), previous,
+ EXFAT_CLUSTER_FREE);
+ free_cluster(ef, previous);
+ previous = next;
+ }
+ return 0;
+}
+
+static void erase_raw(struct exfat* ef, size_t size, off64_t offset)
+{
+ exfat_pwrite(ef->dev, ef->zero_cluster, size, offset);
+}
+
+static int erase_range(struct exfat* ef, struct exfat_node* node,
+ uint64_t begin, uint64_t end)
+{
+ uint64_t cluster_boundary;
+ cluster_t cluster;
+
+ if (begin >= end)
+ return 0;
+
+ cluster_boundary = (begin | (CLUSTER_SIZE(*ef->sb) - 1)) + 1;
+ cluster = exfat_advance_cluster(ef, node,
+ begin / CLUSTER_SIZE(*ef->sb));
+ if (CLUSTER_INVALID(cluster))
+ {
+ exfat_error("invalid cluster 0x%x while erasing", cluster);
+ return -EIO;
+ }
+ /* erase from the beginning to the closest cluster boundary */
+ erase_raw(ef, MIN(cluster_boundary, end) - begin,
+ exfat_c2o(ef, cluster) + begin % CLUSTER_SIZE(*ef->sb));
+ /* erase whole clusters */
+ while (cluster_boundary < end)
+ {
+ cluster = exfat_next_cluster(ef, node, cluster);
+ /* the cluster cannot be invalid because we have just allocated it */
+ if (CLUSTER_INVALID(cluster))
+ exfat_bug("invalid cluster 0x%x after allocation", cluster);
+ erase_raw(ef, CLUSTER_SIZE(*ef->sb), exfat_c2o(ef, cluster));
+ cluster_boundary += CLUSTER_SIZE(*ef->sb);
+ }
+ return 0;
+}
+
+int exfat_truncate(struct exfat* ef, struct exfat_node* node, uint64_t size)
+{
+ uint32_t c1 = bytes2clusters(ef, node->size);
+ uint32_t c2 = bytes2clusters(ef, size);
+ int rc = 0;
+
+ if (node->references == 0 && node->parent)
+ exfat_bug("no references, node changes can be lost");
+
+ if (node->size == size)
+ return 0;
+
+ if (c1 < c2)
+ rc = grow_file(ef, node, c1, c2 - c1);
+ else if (c1 > c2)
+ rc = shrink_file(ef, node, c1, c1 - c2);
+
+ if (rc != 0)
+ return rc;
+
+ rc = erase_range(ef, node, node->size, size);
+ if (rc != 0)
+ return rc;
+
+ exfat_update_mtime(node);
+ node->size = size;
+ node->flags |= EXFAT_ATTRIB_DIRTY;
+ return 0;
+}
+
+uint32_t exfat_count_free_clusters(const struct exfat* ef)
+{
+ uint32_t free_clusters = 0;
+ uint32_t i;
+
+ for (i = 0; i < ef->cmap.size; i++)
+ if (BMAP_GET(ef->cmap.chunk, i) == 0)
+ free_clusters++;
+ return free_clusters;
+}
+
+static int find_used_clusters(const struct exfat* ef,
+ cluster_t* a, cluster_t* b)
+{
+ const cluster_t end = le32_to_cpu(ef->sb->cluster_count);
+
+ /* find first used cluster */
+ for (*a = *b + 1; *a < end; (*a)++)
+ if (BMAP_GET(ef->cmap.chunk, *a - EXFAT_FIRST_DATA_CLUSTER))
+ break;
+ if (*a >= end)
+ return 1;
+
+ /* find last contiguous used cluster */
+ for (*b = *a; *b < end; (*b)++)
+ if (BMAP_GET(ef->cmap.chunk, *b - EXFAT_FIRST_DATA_CLUSTER) == 0)
+ {
+ (*b)--;
+ break;
+ }
+
+ return 0;
+}
+
+int exfat_find_used_sectors(const struct exfat* ef, off64_t* a, off64_t* b)
+{
+ cluster_t ca, cb;
+
+ if (*a == 0 && *b == 0)
+ ca = cb = EXFAT_FIRST_DATA_CLUSTER - 1;
+ else
+ {
+ ca = s2c(ef, *a);
+ cb = s2c(ef, *b);
+ }
+ if (find_used_clusters(ef, &ca, &cb) != 0)
+ return 1;
+ if (*a != 0 || *b != 0)
+ *a = c2s(ef, ca);
+ *b = c2s(ef, cb) + (CLUSTER_SIZE(*ef->sb) - 1) / SECTOR_SIZE(*ef->sb);
+ return 0;
+}
diff --git a/exfat/libexfat/exfat.h b/exfat/libexfat/exfat.h
new file mode 100644
index 000000000..6f152670d
--- /dev/null
+++ b/exfat/libexfat/exfat.h
@@ -0,0 +1,215 @@
+/*
+ exfat.h (29.08.09)
+ Definitions of structures and constants used in exFAT file system
+ implementation.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#ifndef EXFAT_H_INCLUDED
+#define EXFAT_H_INCLUDED
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdbool.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include "exfatfs.h"
+#include "version.h"
+
+#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 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 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 BMAP_GET(bitmap, index) \
+ (((uint8_t*) bitmap)[(index) / 8] & (1u << ((index) % 8)))
+#define BMAP_SET(bitmap, index) \
+ ((uint8_t*) bitmap)[(index) / 8] |= (1u << ((index) % 8))
+#define BMAP_CLR(bitmap, index) \
+ ((uint8_t*) bitmap)[(index) / 8] &= ~(1u << ((index) % 8))
+
+struct exfat_node
+{
+ struct exfat_node* parent;
+ struct exfat_node* child;
+ struct exfat_node* next;
+ struct exfat_node* prev;
+
+ int references;
+ uint32_t fptr_index;
+ cluster_t fptr_cluster;
+ cluster_t entry_cluster;
+ off64_t entry_offset;
+ cluster_t start_cluster;
+ int flags;
+ uint64_t size;
+ time_t mtime, atime;
+ le16_t name[EXFAT_NAME_MAX + 1];
+};
+
+enum exfat_mode
+{
+ EXFAT_MODE_RO,
+ EXFAT_MODE_RW,
+ EXFAT_MODE_ANY,
+};
+
+struct exfat_dev;
+
+struct exfat
+{
+ struct exfat_dev* dev;
+ struct exfat_super_block* sb;
+ le16_t* upcase;
+ size_t upcase_chars;
+ struct exfat_node* root;
+ struct
+ {
+ cluster_t start_cluster;
+ uint32_t size; /* in bits */
+ uint8_t* chunk;
+ uint32_t chunk_size; /* in bits */
+ bool dirty;
+ }
+ cmap;
+ char label[EXFAT_ENAME_MAX * 6 + 1]; /* a character can occupy up to
+ 6 bytes in UTF-8 */
+ void* zero_cluster;
+ int dmask, fmask;
+ uid_t uid;
+ gid_t gid;
+ int ro;
+ bool noatime;
+};
+
+/* in-core nodes iterator */
+struct exfat_iterator
+{
+ struct exfat_node* parent;
+ struct exfat_node* current;
+};
+
+struct exfat_human_bytes
+{
+ uint64_t value;
+ const char* unit;
+};
+
+extern int exfat_errors;
+
+void exfat_bug(const char* format, ...)
+ __attribute__((format(printf, 1, 2), noreturn));
+void exfat_error(const char* format, ...)
+ __attribute__((format(printf, 1, 2)));
+void exfat_warn(const char* format, ...)
+ __attribute__((format(printf, 1, 2)));
+void exfat_debug(const char* format, ...)
+ __attribute__((format(printf, 1, 2)));
+
+struct exfat_dev* exfat_open(const char* spec, enum exfat_mode mode);
+int exfat_close(struct exfat_dev* dev);
+int exfat_fsync(struct exfat_dev* dev);
+enum exfat_mode exfat_get_mode(const struct exfat_dev* dev);
+off64_t exfat_get_size(const struct exfat_dev* dev);
+off64_t exfat_seek(struct exfat_dev* dev, off64_t offset, int whence);
+ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size);
+ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size);
+void exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
+ off64_t offset);
+void exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
+ off64_t offset);
+ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
+ void* buffer, size_t size, off64_t offset);
+ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
+ const void* buffer, size_t size, off64_t offset);
+
+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);
+int exfat_lookup(struct exfat* ef, struct exfat_node** node,
+ const char* path);
+int exfat_split(struct exfat* ef, struct exfat_node** parent,
+ struct exfat_node** node, le16_t* name, const char* path);
+
+off64_t exfat_c2o(const struct exfat* ef, cluster_t cluster);
+cluster_t exfat_next_cluster(const struct exfat* ef,
+ const struct exfat_node* node, cluster_t cluster);
+cluster_t exfat_advance_cluster(const struct exfat* ef,
+ struct exfat_node* node, uint32_t count);
+void exfat_flush_cmap(struct exfat* ef);
+int exfat_truncate(struct exfat* ef, struct exfat_node* node, uint64_t size);
+uint32_t exfat_count_free_clusters(const struct exfat* ef);
+int exfat_find_used_sectors(const struct exfat* ef, off64_t* a, off64_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);
+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);
+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);
+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);
+
+int utf16_to_utf8(char* output, const le16_t* input, size_t outsize,
+ size_t insize);
+int utf8_to_utf16(le16_t* output, const char* input, size_t outsize,
+ size_t insize);
+size_t utf16_length(const le16_t* str);
+
+struct exfat_node* exfat_get_node(struct exfat_node* node);
+void exfat_put_node(struct exfat* ef, struct exfat_node* node);
+int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir);
+void exfat_reset_cache(struct exfat* ef);
+void exfat_flush_node(struct exfat* ef, struct exfat_node* node);
+int exfat_unlink(struct exfat* ef, struct exfat_node* node);
+int exfat_rmdir(struct exfat* ef, struct exfat_node* node);
+int exfat_mknod(struct exfat* ef, const char* path);
+int exfat_mkdir(struct exfat* ef, const char* path);
+int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path);
+void exfat_utimes(struct exfat_node* node, const struct timespec tv[2]);
+void exfat_update_atime(struct exfat_node* node);
+void exfat_update_mtime(struct exfat_node* node);
+const char* exfat_get_label(struct exfat* ef);
+int exfat_set_label(struct exfat* ef, const char* label);
+
+int exfat_mount(struct exfat* ef, const char* spec, const char* options);
+void exfat_unmount(struct exfat* ef);
+
+time_t exfat_exfat2unix(le16_t date, le16_t time, uint8_t centisec);
+void exfat_unix2exfat(time_t unix_time, le16_t* date, le16_t* time,
+ uint8_t* centisec);
+void exfat_tzset(void);
+
+#endif /* ifndef EXFAT_H_INCLUDED */
diff --git a/exfat/libexfat/exfatfs.h b/exfat/libexfat/exfatfs.h
new file mode 100644
index 000000000..5a8e39fda
--- /dev/null
+++ b/exfat/libexfat/exfatfs.h
@@ -0,0 +1,163 @@
+/*
+ exfatfs.h (29.08.09)
+ Definitions of structures and constants used in exFAT file system.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#ifndef EXFATFS_H_INCLUDED
+#define EXFATFS_H_INCLUDED
+
+#include "byteorder.h"
+
+typedef uint32_t cluster_t; /* cluster number */
+
+#define EXFAT_FIRST_DATA_CLUSTER 2
+#define EXFAT_LAST_DATA_CLUSTER 0xfffffff6
+
+#define EXFAT_CLUSTER_FREE 0 /* free cluster */
+#define EXFAT_CLUSTER_BAD 0xfffffff7 /* cluster contains bad sector */
+#define EXFAT_CLUSTER_END 0xffffffff /* final cluster of file or directory */
+
+#define EXFAT_STATE_MOUNTED 2
+
+struct exfat_super_block
+{
+ uint8_t jump[3]; /* 0x00 jmp and nop instructions */
+ uint8_t oem_name[8]; /* 0x03 "EXFAT " */
+ uint8_t __unused1[53]; /* 0x0B always 0 */
+ le64_t sector_start; /* 0x40 partition first sector */
+ le64_t sector_count; /* 0x48 partition sectors count */
+ le32_t fat_sector_start; /* 0x50 FAT first sector */
+ le32_t fat_sector_count; /* 0x54 FAT sectors count */
+ le32_t cluster_sector_start; /* 0x58 first cluster sector */
+ le32_t cluster_count; /* 0x5C total clusters count */
+ le32_t rootdir_cluster; /* 0x60 first cluster of the root dir */
+ le32_t volume_serial; /* 0x64 volume serial number */
+ struct /* 0x68 FS version */
+ {
+ uint8_t minor;
+ uint8_t major;
+ }
+ version;
+ le16_t volume_state; /* 0x6A volume state flags */
+ uint8_t sector_bits; /* 0x6C sector size as (1 << n) */
+ uint8_t spc_bits; /* 0x6D sectors per cluster as (1 << n) */
+ uint8_t fat_count; /* 0x6E always 1 */
+ uint8_t drive_no; /* 0x6F always 0x80 */
+ uint8_t allocated_percent; /* 0x70 percentage of allocated space */
+ uint8_t __unused2[397]; /* 0x71 always 0 */
+ le16_t boot_signature; /* the value of 0xAA55 */
+}
+__attribute__((__packed__));
+
+#define EXFAT_ENTRY_VALID 0x80
+#define EXFAT_ENTRY_CONTINUED 0x40
+
+#define EXFAT_ENTRY_BITMAP (0x01 | EXFAT_ENTRY_VALID)
+#define EXFAT_ENTRY_UPCASE (0x02 | EXFAT_ENTRY_VALID)
+#define EXFAT_ENTRY_LABEL (0x03 | EXFAT_ENTRY_VALID)
+#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)
+
+struct exfat_entry /* common container for all entries */
+{
+ uint8_t type; /* any of EXFAT_ENTRY_xxx */
+ uint8_t data[31];
+}
+__attribute__((__packed__));
+
+#define EXFAT_ENAME_MAX 15
+
+struct exfat_entry_bitmap /* allocated clusters bitmap */
+{
+ uint8_t type; /* EXFAT_ENTRY_BITMAP */
+ uint8_t __unknown1[19];
+ le32_t start_cluster;
+ le64_t size; /* in bytes */
+}
+__attribute__((__packed__));
+
+struct exfat_entry_upcase /* upper case translation table */
+{
+ uint8_t type; /* EXFAT_ENTRY_UPCASE */
+ uint8_t __unknown1[3];
+ le32_t checksum;
+ uint8_t __unknown2[12];
+ le32_t start_cluster;
+ le64_t size; /* in bytes */
+}
+__attribute__((__packed__));
+
+struct exfat_entry_label /* volume label */
+{
+ uint8_t type; /* EXFAT_ENTRY_LABEL */
+ uint8_t length; /* number of characters */
+ le16_t name[EXFAT_ENAME_MAX]; /* in UTF-16LE */
+}
+__attribute__((__packed__));
+
+#define EXFAT_ATTRIB_RO 0x01
+#define EXFAT_ATTRIB_HIDDEN 0x02
+#define EXFAT_ATTRIB_SYSTEM 0x04
+#define EXFAT_ATTRIB_VOLUME 0x08
+#define EXFAT_ATTRIB_DIR 0x10
+#define EXFAT_ATTRIB_ARCH 0x20
+
+struct exfat_entry_meta1 /* file or directory info (part 1) */
+{
+ uint8_t type; /* EXFAT_ENTRY_FILE */
+ uint8_t continuations;
+ le16_t checksum;
+ le16_t attrib; /* combination of EXFAT_ATTRIB_xxx */
+ le16_t __unknown1;
+ le16_t crtime, crdate; /* creation date and time */
+ le16_t mtime, mdate; /* latest modification date and time */
+ le16_t atime, adate; /* latest access date and time */
+ uint8_t crtime_cs; /* creation time in cs (centiseconds) */
+ uint8_t mtime_cs; /* latest modification time in cs */
+ uint8_t __unknown2[10];
+}
+__attribute__((__packed__));
+
+#define EXFAT_FLAG_ALWAYS1 (1u << 0)
+#define EXFAT_FLAG_CONTIGUOUS (1u << 1)
+
+struct exfat_entry_meta2 /* file or directory info (part 2) */
+{
+ uint8_t type; /* EXFAT_ENTRY_FILE_INFO */
+ uint8_t flags; /* combination of EXFAT_FLAG_xxx */
+ uint8_t __unknown1;
+ uint8_t name_length;
+ le16_t name_hash;
+ le16_t __unknown2;
+ le64_t real_size; /* in bytes, equals to size */
+ uint8_t __unknown3[4];
+ le32_t start_cluster;
+ le64_t size; /* in bytes, equals to real_size */
+}
+__attribute__((__packed__));
+
+struct exfat_entry_name /* file or directory name */
+{
+ uint8_t type; /* EXFAT_ENTRY_FILE_NAME */
+ uint8_t __unknown;
+ le16_t name[EXFAT_ENAME_MAX]; /* in UTF-16LE */
+}
+__attribute__((__packed__));
+
+#endif /* ifndef EXFATFS_H_INCLUDED */
diff --git a/exfat/libexfat/io.c b/exfat/libexfat/io.c
new file mode 100644
index 000000000..65df63a78
--- /dev/null
+++ b/exfat/libexfat/io.c
@@ -0,0 +1,385 @@
+/*
+ io.c (02.09.09)
+ exFAT file system implementation library.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#include "exfat.h"
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#ifdef __APPLE__
+#include <sys/disk.h>
+#endif
+#ifdef USE_UBLIO
+#include <sys/uio.h>
+#include <ublio.h>
+#endif
+
+struct exfat_dev
+{
+ int fd;
+ enum exfat_mode mode;
+ off64_t size; /* in bytes */
+#ifdef USE_UBLIO
+ off64_t pos;
+ ublio_filehandle_t ufh;
+#endif
+};
+
+static int open_ro(const char* spec)
+{
+ return open(spec, O_RDONLY);
+}
+
+static int open_rw(const char* spec)
+{
+ int fd = open(spec, O_RDWR);
+#ifdef __linux__
+ int ro = 0;
+
+ /*
+ This ioctl is needed because after "blockdev --setro" kernel still
+ allows to open the device in read-write mode but fails writes.
+ */
+ if (fd != -1 && ioctl(fd, BLKROGET, &ro) == 0 && ro)
+ {
+ close(fd);
+ return -1;
+ }
+#endif
+ return fd;
+}
+
+struct exfat_dev* exfat_open(const char* spec, enum exfat_mode mode)
+{
+ struct exfat_dev* dev;
+ struct stat stbuf;
+#ifdef USE_UBLIO
+ struct ublio_param up;
+#endif
+
+ dev = malloc(sizeof(struct exfat_dev));
+ if (dev == NULL)
+ {
+ exfat_error("failed to allocate memory for device structure");
+ return NULL;
+ }
+
+ switch (mode)
+ {
+ case EXFAT_MODE_RO:
+ dev->fd = open_ro(spec);
+ if (dev->fd == -1)
+ {
+ free(dev);
+ exfat_error("failed to open `%s' in read-only mode", spec);
+ return NULL;
+ }
+ dev->mode = EXFAT_MODE_RO;
+ break;
+ case EXFAT_MODE_RW:
+ dev->fd = open_rw(spec);
+ if (dev->fd == -1)
+ {
+ free(dev);
+ exfat_error("failed to open `%s' in read-write mode", spec);
+ return NULL;
+ }
+ dev->mode = EXFAT_MODE_RW;
+ break;
+ case EXFAT_MODE_ANY:
+ dev->fd = open_rw(spec);
+ if (dev->fd != -1)
+ {
+ dev->mode = EXFAT_MODE_RW;
+ break;
+ }
+ dev->fd = open_ro(spec);
+ if (dev->fd != -1)
+ {
+ dev->mode = EXFAT_MODE_RO;
+ exfat_warn("`%s' is write-protected, mounting read-only", spec);
+ break;
+ }
+ free(dev);
+ exfat_error("failed to open `%s'", spec);
+ return NULL;
+ }
+
+ if (fstat(dev->fd, &stbuf) != 0)
+ {
+ close(dev->fd);
+ free(dev);
+ exfat_error("failed to fstat `%s'", spec);
+ return NULL;
+ }
+ if (!S_ISBLK(stbuf.st_mode) &&
+ !S_ISCHR(stbuf.st_mode) &&
+ !S_ISREG(stbuf.st_mode))
+ {
+ close(dev->fd);
+ free(dev);
+ exfat_error("`%s' is neither a device, nor a regular file", spec);
+ return NULL;
+ }
+
+#ifdef __APPLE__
+ if (!S_ISREG(stbuf.st_mode))
+ {
+ uint32_t block_size = 0;
+ uint64_t blocks = 0;
+
+ if (ioctl(dev->fd, DKIOCGETBLOCKSIZE, &block_size) != 0)
+ {
+ close(dev->fd);
+ free(dev);
+ exfat_error("failed to get block size");
+ return NULL;
+ }
+ if (ioctl(dev->fd, DKIOCGETBLOCKCOUNT, &blocks) != 0)
+ {
+ close(dev->fd);
+ free(dev);
+ exfat_error("failed to get blocks count");
+ return NULL;
+ }
+ dev->size = blocks * block_size;
+ }
+ else
+#endif
+ {
+ /* works for Linux, FreeBSD, Solaris */
+ dev->size = exfat_seek(dev, 0, SEEK_END);
+ if (dev->size <= 0)
+ {
+ close(dev->fd);
+ free(dev);
+ exfat_error("failed to get size of `%s'", spec);
+ return NULL;
+ }
+ if (exfat_seek(dev, 0, SEEK_SET) == -1)
+ {
+ close(dev->fd);
+ free(dev);
+ exfat_error("failed to seek to the beginning of `%s'", spec);
+ return NULL;
+ }
+ }
+
+#ifdef USE_UBLIO
+ memset(&up, 0, sizeof(struct ublio_param));
+ up.up_blocksize = 256 * 1024;
+ up.up_items = 64;
+ up.up_grace = 32;
+ up.up_priv = &dev->fd;
+
+ dev->pos = 0;
+ dev->ufh = ublio_open(&up);
+ if (dev->ufh == NULL)
+ {
+ close(dev->fd);
+ free(dev);
+ exfat_error("failed to initialize ublio");
+ return NULL;
+ }
+#endif
+
+ return dev;
+}
+
+int exfat_close(struct exfat_dev* dev)
+{
+#ifdef USE_UBLIO
+ if (ublio_close(dev->ufh) != 0)
+ exfat_error("failed to close ublio");
+#endif
+ if (close(dev->fd) != 0)
+ {
+ free(dev);
+ exfat_error("failed to close device");
+ return 1;
+ }
+ free(dev);
+ return 0;
+}
+
+int exfat_fsync(struct exfat_dev* dev)
+{
+#ifdef USE_UBLIO
+ if (ublio_fsync(dev->ufh) != 0)
+#else
+ if (fsync(dev->fd) != 0)
+#endif
+ {
+ exfat_error("fsync failed");
+ return 1;
+ }
+ return 0;
+}
+
+enum exfat_mode exfat_get_mode(const struct exfat_dev* dev)
+{
+ return dev->mode;
+}
+
+off64_t exfat_get_size(const struct exfat_dev* dev)
+{
+ return dev->size;
+}
+
+off64_t exfat_seek(struct exfat_dev* dev, off64_t offset, int whence)
+{
+#ifdef USE_UBLIO
+ /* XXX SEEK_CUR will be handled incorrectly */
+ return dev->pos = lseek64(dev->fd, offset, whence);
+#else
+ return lseek64(dev->fd, offset, whence);
+#endif
+}
+
+ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size)
+{
+#ifdef USE_UBLIO
+ ssize_t result = ublio_pread(dev->ufh, buffer, size, dev->pos);
+ if (result >= 0)
+ dev->pos += size;
+ return result;
+#else
+ return read(dev->fd, buffer, size);
+#endif
+}
+
+ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size)
+{
+#ifdef USE_UBLIO
+ ssize_t result = ublio_pwrite(dev->ufh, buffer, size, dev->pos);
+ if (result >= 0)
+ dev->pos += size;
+ return result;
+#else
+ return write(dev->fd, buffer, size);
+#endif
+}
+
+void exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
+ off64_t offset)
+{
+#ifdef USE_UBLIO
+ if (ublio_pread(dev->ufh, buffer, size, offset) != size)
+#else
+ if (pread64(dev->fd, buffer, size, offset) != size)
+#endif
+ exfat_bug("failed to read %zu bytes from file at %"PRIu64, size,
+ (uint64_t) offset);
+}
+
+void exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
+ off64_t offset)
+{
+#ifdef USE_UBLIO
+ if (ublio_pwrite(dev->ufh, buffer, size, offset) != size)
+#else
+ if (pwrite64(dev->fd, buffer, size, offset) != size)
+#endif
+ exfat_bug("failed to write %zu bytes to file at %"PRIu64, size,
+ (uint64_t) offset);
+}
+
+ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
+ void* buffer, size_t size, off64_t offset)
+{
+ cluster_t cluster;
+ char* bufp = buffer;
+ off64_t lsize, loffset, remainder;
+
+ if (offset >= node->size)
+ return 0;
+ if (size == 0)
+ return 0;
+
+ cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
+ if (CLUSTER_INVALID(cluster))
+ {
+ exfat_error("invalid cluster 0x%x while reading", cluster);
+ return -1;
+ }
+
+ loffset = offset % CLUSTER_SIZE(*ef->sb);
+ remainder = MIN(size, node->size - offset);
+ while (remainder > 0)
+ {
+ if (CLUSTER_INVALID(cluster))
+ {
+ exfat_error("invalid cluster 0x%x while reading", cluster);
+ return -1;
+ }
+ lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
+ exfat_pread(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
+ bufp += lsize;
+ loffset = 0;
+ remainder -= lsize;
+ cluster = exfat_next_cluster(ef, node, cluster);
+ }
+ if (!ef->ro && !ef->noatime)
+ exfat_update_atime(node);
+ return size - remainder;
+}
+
+ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
+ const void* buffer, size_t size, off64_t offset)
+{
+ cluster_t cluster;
+ const char* bufp = buffer;
+ off64_t lsize, loffset, remainder;
+ printf("node: %s\n", node);
+ if (offset + size > node->size)
+ if (exfat_truncate(ef, node, offset + size) != 0)
+ return -1;
+ if (size == 0)
+ return 0;
+
+ cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
+ if (CLUSTER_INVALID(cluster))
+ {
+ exfat_error("invalid cluster 0x%x while writing", cluster);
+ return -1;
+ }
+
+ loffset = offset % CLUSTER_SIZE(*ef->sb);
+ remainder = size;
+ while (remainder > 0)
+ {
+ if (CLUSTER_INVALID(cluster))
+ {
+ exfat_error("invalid cluster 0x%x while writing", cluster);
+ return -1;
+ }
+ lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
+ exfat_pwrite(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
+ bufp += lsize;
+ loffset = 0;
+ remainder -= lsize;
+ cluster = exfat_next_cluster(ef, node, cluster);
+ }
+ exfat_update_mtime(node);
+ return size - remainder;
+}
diff --git a/exfat/libexfat/log.c b/exfat/libexfat/log.c
new file mode 100644
index 000000000..8b589b406
--- /dev/null
+++ b/exfat/libexfat/log.c
@@ -0,0 +1,108 @@
+/*
+ log.c (02.09.09)
+ exFAT file system implementation library.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#include "exfat.h"
+#include <stdarg.h>
+#include <syslog.h>
+#include <unistd.h>
+
+int exfat_errors;
+
+/*
+ * This message means an internal bug in exFAT implementation.
+ */
+void exfat_bug(const char* format, ...)
+{
+ va_list ap, aq;
+
+ va_start(ap, format);
+ va_copy(aq, ap);
+
+ fflush(stdout);
+ fputs("BUG: ", stderr);
+ vfprintf(stderr, format, ap);
+ va_end(ap);
+ fputs(".\n", stderr);
+
+ if (!isatty(STDERR_FILENO))
+ vsyslog(LOG_CRIT, format, aq);
+ va_end(aq);
+
+ abort();
+}
+
+/*
+ * This message means an error in exFAT file system.
+ */
+void exfat_error(const char* format, ...)
+{
+ va_list ap, aq;
+
+ exfat_errors++;
+ va_start(ap, format);
+ va_copy(aq, ap);
+
+ fflush(stdout);
+ fputs("ERROR: ", stderr);
+ vfprintf(stderr, format, ap);
+ va_end(ap);
+ fputs(".\n", stderr);
+
+ if (!isatty(STDERR_FILENO))
+ vsyslog(LOG_ERR, format, aq);
+ va_end(aq);
+}
+
+/*
+ * This message means that there is something unexpected in exFAT file system
+ * that can be a potential problem.
+ */
+void exfat_warn(const char* format, ...)
+{
+ va_list ap, aq;
+
+ va_start(ap, format);
+ va_copy(aq, ap);
+
+ fflush(stdout);
+ fputs("WARN: ", stderr);
+ vfprintf(stderr, format, ap);
+ va_end(ap);
+ fputs(".\n", stderr);
+
+ if (!isatty(STDERR_FILENO))
+ vsyslog(LOG_WARNING, format, aq);
+ va_end(aq);
+}
+
+/*
+ * Just debug message. Disabled by default.
+ */
+void exfat_debug(const char* format, ...)
+{
+ va_list ap;
+
+ fflush(stdout);
+ fputs("DEBUG: ", stderr);
+ va_start(ap, format);
+ vfprintf(stderr, format, ap);
+ va_end(ap);
+ fputs(".\n", stderr);
+}
diff --git a/exfat/libexfat/lookup.c b/exfat/libexfat/lookup.c
new file mode 100644
index 000000000..8c889b2b2
--- /dev/null
+++ b/exfat/libexfat/lookup.c
@@ -0,0 +1,223 @@
+/*
+ lookup.c (02.09.09)
+ exFAT file system implementation library.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#include "exfat.h"
+#include <string.h>
+#include <errno.h>
+#include <inttypes.h>
+
+int exfat_opendir(struct exfat* ef, struct exfat_node* dir,
+ struct exfat_iterator* it)
+{
+ int rc;
+
+ exfat_get_node(dir);
+ it->parent = dir;
+ it->current = NULL;
+ rc = exfat_cache_directory(ef, dir);
+ if (rc != 0)
+ exfat_put_node(ef, dir);
+ return rc;
+}
+
+void exfat_closedir(struct exfat* ef, struct exfat_iterator* it)
+{
+ exfat_put_node(ef, it->parent);
+ it->parent = NULL;
+ it->current = NULL;
+}
+
+struct exfat_node* exfat_readdir(struct exfat* ef, struct exfat_iterator* it)
+{
+ if (it->current == NULL)
+ it->current = it->parent->child;
+ else
+ it->current = it->current->next;
+
+ if (it->current != NULL)
+ return exfat_get_node(it->current);
+ else
+ return NULL;
+}
+
+static int compare_char(struct exfat* ef, uint16_t a, uint16_t b)
+{
+ if (a >= ef->upcase_chars || b >= ef->upcase_chars)
+ return (int) a - (int) b;
+
+ return (int) le16_to_cpu(ef->upcase[a]) - (int) le16_to_cpu(ef->upcase[b]);
+}
+
+static int compare_name(struct exfat* ef, const le16_t* a, const le16_t* b)
+{
+ while (le16_to_cpu(*a) && le16_to_cpu(*b))
+ {
+ int rc = compare_char(ef, le16_to_cpu(*a), le16_to_cpu(*b));
+ if (rc != 0)
+ return rc;
+ a++;
+ b++;
+ }
+ return compare_char(ef, le16_to_cpu(*a), le16_to_cpu(*b));
+}
+
+static int lookup_name(struct exfat* ef, struct exfat_node* parent,
+ struct exfat_node** node, const char* name, size_t n)
+{
+ struct exfat_iterator it;
+ le16_t buffer[EXFAT_NAME_MAX + 1];
+ int rc;
+
+ *node = NULL;
+
+ rc = utf8_to_utf16(buffer, name, EXFAT_NAME_MAX, n);
+ if (rc != 0)
+ return rc;
+
+ rc = exfat_opendir(ef, parent, &it);
+ if (rc != 0)
+ return rc;
+ while ((*node = exfat_readdir(ef, &it)))
+ {
+ if (compare_name(ef, buffer, (*node)->name) == 0)
+ {
+ exfat_closedir(ef, &it);
+ return 0;
+ }
+ exfat_put_node(ef, *node);
+ }
+ exfat_closedir(ef, &it);
+ return -ENOENT;
+}
+
+static size_t get_comp(const char* path, const char** comp)
+{
+ const char* end;
+
+ *comp = path + strspn(path, "/"); /* skip leading slashes */
+ end = strchr(*comp, '/');
+ if (end == NULL)
+ return strlen(*comp);
+ else
+ return end - *comp;
+}
+
+int exfat_lookup(struct exfat* ef, struct exfat_node** node,
+ const char* path)
+{
+ struct exfat_node* parent;
+ const char* p;
+ size_t n;
+ int rc;
+
+ /* start from the root directory */
+ parent = *node = exfat_get_node(ef->root);
+ for (p = path; (n = get_comp(p, &p)); p += n)
+ {
+ if (n == 1 && *p == '.') /* skip "." component */
+ continue;
+ rc = lookup_name(ef, parent, node, p, n);
+ if (rc != 0)
+ {
+ exfat_put_node(ef, parent);
+ return rc;
+ }
+ exfat_put_node(ef, parent);
+ parent = *node;
+ }
+ return 0;
+}
+
+static bool is_last_comp(const char* comp, size_t length)
+{
+ const char* p = comp + length;
+
+ return get_comp(p, &p) == 0;
+}
+
+static bool is_allowed(const char* comp, size_t length)
+{
+ size_t i;
+
+ for (i = 0; i < length; i++)
+ switch (comp[i])
+ {
+ case 0x01 ... 0x1f:
+ case '/':
+ case '\\':
+ case ':':
+ case '*':
+ case '?':
+ case '"':
+ case '<':
+ case '>':
+ case '|':
+ return false;
+ }
+ return true;
+}
+
+int exfat_split(struct exfat* ef, struct exfat_node** parent,
+ struct exfat_node** node, le16_t* name, const char* path)
+{
+ const char* p;
+ size_t n;
+ int rc;
+
+ memset(name, 0, (EXFAT_NAME_MAX + 1) * sizeof(le16_t));
+ *parent = *node = exfat_get_node(ef->root);
+ for (p = path; (n = get_comp(p, &p)); p += n)
+ {
+ if (n == 1 && *p == '.')
+ continue;
+ if (is_last_comp(p, n))
+ {
+ if (!is_allowed(p, n))
+ {
+ /* contains characters that are not allowed */
+ exfat_put_node(ef, *parent);
+ return -ENOENT;
+ }
+ rc = utf8_to_utf16(name, p, EXFAT_NAME_MAX, n);
+ if (rc != 0)
+ {
+ exfat_put_node(ef, *parent);
+ return rc;
+ }
+
+ rc = lookup_name(ef, *parent, node, p, n);
+ if (rc != 0 && rc != -ENOENT)
+ {
+ exfat_put_node(ef, *parent);
+ return rc;
+ }
+ return 0;
+ }
+ rc = lookup_name(ef, *parent, node, p, n);
+ if (rc != 0)
+ {
+ exfat_put_node(ef, *parent);
+ return rc;
+ }
+ exfat_put_node(ef, *parent);
+ *parent = *node;
+ }
+ exfat_bug("impossible");
+}
diff --git a/exfat/libexfat/mount.c b/exfat/libexfat/mount.c
new file mode 100644
index 000000000..44fb58138
--- /dev/null
+++ b/exfat/libexfat/mount.c
@@ -0,0 +1,314 @@
+/*
+ mount.c (22.10.09)
+ exFAT file system implementation library.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#include "exfat.h"
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+static uint64_t rootdir_size(const struct exfat* ef)
+{
+ uint64_t clusters = 0;
+ cluster_t rootdir_cluster = le32_to_cpu(ef->sb->rootdir_cluster);
+
+ while (!CLUSTER_INVALID(rootdir_cluster))
+ {
+ clusters++;
+ /* root directory cannot be contiguous because there is no flag
+ to indicate this */
+ rootdir_cluster = exfat_next_cluster(ef, ef->root, rootdir_cluster);
+ }
+ return clusters * CLUSTER_SIZE(*ef->sb);
+}
+
+static const char* get_option(const char* options, const char* option_name)
+{
+ const char* p;
+ size_t length = strlen(option_name);
+
+ for (p = strstr(options, option_name); p; p = strstr(p + 1, option_name))
+ if ((p == options || p[-1] == ',') && p[length] == '=')
+ return p + length + 1;
+ return NULL;
+}
+
+static int get_int_option(const char* options, const char* option_name,
+ int base, int default_value)
+{
+ const char* p = get_option(options, option_name);
+
+ if (p == NULL)
+ return default_value;
+ return strtol(p, NULL, base);
+}
+
+static bool match_option(const char* options, const char* option_name)
+{
+ const char* p;
+ size_t length = strlen(option_name);
+
+ for (p = strstr(options, option_name); p; p = strstr(p + 1, option_name))
+ if ((p == options || p[-1] == ',') &&
+ (p[length] == ',' || p[length] == '\0'))
+ return true;
+ return false;
+}
+
+static void parse_options(struct exfat* ef, const char* options)
+{
+ int sys_umask = umask(0);
+ int opt_umask;
+
+ umask(sys_umask); /* restore umask */
+ opt_umask = get_int_option(options, "umask", 8, sys_umask);
+ ef->dmask = get_int_option(options, "dmask", 8, opt_umask) & 0777;
+ ef->fmask = get_int_option(options, "fmask", 8, opt_umask) & 0777;
+
+ ef->uid = get_int_option(options, "uid", 10, geteuid());
+ ef->gid = get_int_option(options, "gid", 10, getegid());
+
+ ef->noatime = match_option(options, "noatime");
+}
+
+static int verify_vbr_checksum(struct exfat_dev* dev, void* sector,
+ off64_t sector_size)
+{
+ uint32_t vbr_checksum;
+ int i;
+
+ exfat_pread(dev, sector, sector_size, 0);
+ vbr_checksum = exfat_vbr_start_checksum(sector, sector_size);
+ for (i = 1; i < 11; i++)
+ {
+ exfat_pread(dev, sector, sector_size, i * sector_size);
+ vbr_checksum = exfat_vbr_add_checksum(sector, sector_size,
+ vbr_checksum);
+ }
+ exfat_pread(dev, sector, sector_size, i * sector_size);
+ 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 0;
+}
+
+static int commit_super_block(const struct exfat* ef)
+{
+ exfat_pwrite(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0);
+ return exfat_fsync(ef->dev);
+}
+
+static int prepare_super_block(const struct exfat* ef)
+{
+ if (le16_to_cpu(ef->sb->volume_state) & EXFAT_STATE_MOUNTED)
+ exfat_warn("volume was not unmounted cleanly");
+
+ if (ef->ro)
+ return 0;
+
+ ef->sb->volume_state = cpu_to_le16(
+ le16_to_cpu(ef->sb->volume_state) | EXFAT_STATE_MOUNTED);
+ return commit_super_block(ef);
+}
+
+int exfat_mount(struct exfat* ef, const char* spec, const char* options)
+{
+ int rc;
+ enum exfat_mode mode;
+
+ exfat_tzset();
+ memset(ef, 0, sizeof(struct exfat));
+
+ parse_options(ef, options);
+
+ if (match_option(options, "ro"))
+ mode = EXFAT_MODE_RO;
+ else if (match_option(options, "ro_fallback"))
+ mode = EXFAT_MODE_ANY;
+ else
+ mode = EXFAT_MODE_RW;
+ ef->dev = exfat_open(spec, mode);
+ if (ef->dev == NULL)
+ return -EIO;
+ if (exfat_get_mode(ef->dev) == EXFAT_MODE_RO)
+ {
+ if (mode == EXFAT_MODE_ANY)
+ ef->ro = -1;
+ else
+ ef->ro = 1;
+ }
+
+ 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");
+ return -ENOMEM;
+ }
+ memset(ef->sb, 0, sizeof(struct exfat_super_block));
+
+ exfat_pread(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0);
+ if (memcmp(ef->sb->oem_name, "EXFAT ", 8) != 0)
+ {
+ exfat_close(ef->dev);
+ free(ef->sb);
+ exfat_error("exFAT file system is not found");
+ return -EIO;
+ }
+ if (ef->sb->version.major != 1 || ef->sb->version.minor != 0)
+ {
+ exfat_close(ef->dev);
+ exfat_error("unsupported exFAT version: %hhu.%hhu",
+ ef->sb->version.major, ef->sb->version.minor);
+ free(ef->sb);
+ return -EIO;
+ }
+ if (ef->sb->fat_count != 1)
+ {
+ exfat_close(ef->dev);
+ free(ef->sb);
+ exfat_error("unsupported FAT count: %hhu", ef->sb->fat_count);
+ 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);
+ free(ef->sb);
+ 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);
+ 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)) != 0)
+ {
+ free(ef->zero_cluster);
+ 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)
+ {
+ free(ef->zero_cluster);
+ exfat_close(ef->dev);
+ free(ef->sb);
+ exfat_error("failed to allocate root node");
+ return -ENOMEM;
+ }
+ memset(ef->root, 0, sizeof(struct exfat_node));
+ ef->root->flags = 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);
+ /* exFAT does not have time attributes for the root directory */
+ ef->root->mtime = 0;
+ ef->root->atime = 0;
+ /* always keep at least 1 reference to the root node */
+ exfat_get_node(ef->root);
+
+ rc = exfat_cache_directory(ef, ef->root);
+ if (rc != 0)
+ goto error;
+ if (ef->upcase == NULL)
+ {
+ exfat_error("upcase table is not found");
+ goto error;
+ }
+ if (ef->cmap.chunk == NULL)
+ {
+ exfat_error("clusters bitmap is not found");
+ goto error;
+ }
+
+ if (prepare_super_block(ef) != 0)
+ goto error;
+
+ return 0;
+
+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);
+ return -EIO;
+}
+
+static void finalize_super_block(struct exfat* ef)
+{
+ if (ef->ro)
+ return;
+
+ ef->sb->volume_state = cpu_to_le16(
+ le16_to_cpu(ef->sb->volume_state) & ~EXFAT_STATE_MOUNTED);
+
+ /* Some implementations set the percentage of allocated space to 0xff
+ on FS creation and never update it. In this case leave it as is. */
+ if (ef->sb->allocated_percent != 0xff)
+ {
+ uint32_t free, total;
+
+ free = exfat_count_free_clusters(ef);
+ total = le32_to_cpu(ef->sb->cluster_count);
+ ef->sb->allocated_percent = ((total - free) * 100 + total / 2) / total;
+ }
+
+ commit_super_block(ef);
+}
+
+void exfat_unmount(struct exfat* ef)
+{
+ 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;
+ ef->upcase_chars = 0;
+}
diff --git a/exfat/libexfat/node.c b/exfat/libexfat/node.c
new file mode 100644
index 000000000..bacb01d10
--- /dev/null
+++ b/exfat/libexfat/node.c
@@ -0,0 +1,1041 @@
+/*
+ node.c (09.10.09)
+ exFAT file system implementation library.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#include "exfat.h"
+#include <errno.h>
+#include <string.h>
+#include <inttypes.h>
+
+/* on-disk nodes iterator */
+struct iterator
+{
+ cluster_t cluster;
+ off64_t offset;
+ int contiguous;
+ char* chunk;
+};
+
+struct exfat_node* exfat_get_node(struct exfat_node* node)
+{
+ /* if we switch to multi-threaded mode we will need atomic
+ increment here and atomic decrement in exfat_put_node() */
+ node->references++;
+ return node;
+}
+
+void exfat_put_node(struct exfat* ef, struct exfat_node* node)
+{
+ if (--node->references < 0)
+ {
+ char buffer[EXFAT_NAME_MAX + 1];
+ exfat_get_name(node, buffer, EXFAT_NAME_MAX);
+ exfat_bug("reference counter of `%s' is below zero", buffer);
+ }
+
+ if (node->references == 0)
+ {
+ if (node->flags & EXFAT_ATTRIB_DIRTY)
+ exfat_flush_node(ef, node);
+ if (node->flags & EXFAT_ATTRIB_UNLINKED)
+ {
+ /* free all clusters and node structure itself */
+ exfat_truncate(ef, node, 0);
+ free(node);
+ }
+ if (ef->cmap.dirty)
+ exfat_flush_cmap(ef);
+ }
+}
+
+/**
+ * Cluster + offset from the beginning of the directory to absolute offset.
+ */
+static off64_t co2o(struct exfat* ef, cluster_t cluster, off64_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)
+{
+ if (!(dir->flags & EXFAT_ATTRIB_DIR))
+ exfat_bug("not a directory");
+ it->cluster = dir->start_cluster;
+ it->offset = 0;
+ it->contiguous = IS_CONTIGUOUS(*dir);
+ it->chunk = malloc(CLUSTER_SIZE(*ef->sb));
+ if (it->chunk == NULL)
+ {
+ exfat_error("out of memory");
+ return -ENOMEM;
+ }
+ exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
+ exfat_c2o(ef, it->cluster));
+ return 0;
+}
+
+static void closedir(struct iterator* it)
+{
+ it->cluster = 0;
+ it->offset = 0;
+ it->contiguous = 0;
+ free(it->chunk);
+ it->chunk = NULL;
+}
+
+static int 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 0;
+ 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 1;
+ }
+ exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
+ exfat_c2o(ef, it->cluster));
+ }
+ return 0;
+}
+
+static struct exfat_node* allocate_node(void)
+{
+ struct exfat_node* node = malloc(sizeof(struct exfat_node));
+ if (node == NULL)
+ {
+ exfat_error("failed to allocate node");
+ return NULL;
+ }
+ memset(node, 0, sizeof(struct exfat_node));
+ return node;
+}
+
+static void init_node_meta1(struct exfat_node* node,
+ const struct exfat_entry_meta1* meta1)
+{
+ node->flags = le16_to_cpu(meta1->attrib);
+ node->mtime = exfat_exfat2unix(meta1->mdate, meta1->mtime,
+ meta1->mtime_cs);
+ /* there is no centiseconds field for atime */
+ node->atime = exfat_exfat2unix(meta1->adate, meta1->atime, 0);
+}
+
+static void init_node_meta2(struct exfat_node* node,
+ const struct exfat_entry_meta2* meta2)
+{
+ 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;
+}
+
+static const struct exfat_entry* get_entry_ptr(const struct exfat* ef,
+ const struct iterator* it)
+{
+ return (const struct exfat_entry*)
+ (it->chunk + it->offset % CLUSTER_SIZE(*ef->sb));
+}
+
+/*
+ * Reads one entry in directory at position pointed by iterator and fills
+ * node structure.
+ */
+static int readdir(struct exfat* ef, const struct exfat_node* parent,
+ struct exfat_node** node, struct iterator* it)
+{
+ int rc = -EIO;
+ const 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 real_size = 0;
+
+ *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 */
+ }
+
+ entry = get_entry_ptr(ef, it);
+ 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;
+ }
+ 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);
+ real_size = le64_to_cpu(meta2->real_size);
+ /* empty files must be marked as non-contiguous */
+ if ((*node)->size == 0 && (meta2->flags & EXFAT_FLAG_CONTIGUOUS))
+ {
+ exfat_error("empty file marked as contiguous (0x%hhx)",
+ meta2->flags);
+ goto error;
+ }
+ /* directories must be aligned on at cluster boundary */
+ if (((*node)->flags & EXFAT_ATTRIB_DIR) &&
+ (*node)->size % CLUSTER_SIZE(*ef->sb) != 0)
+ {
+ exfat_error("directory has invalid size %"PRIu64" bytes",
+ (*node)->size);
+ goto error;
+ }
+ --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, EXFAT_ENAME_MAX * sizeof(le16_t));
+ namep += EXFAT_ENAME_MAX;
+ if (--continuations == 0)
+ {
+ /*
+ There are two fields that contain file size. Maybe they
+ plan to add compression support in the future and one of
+ those fields is visible (uncompressed) size and the other
+ is real (compressed) size. Anyway, currently it looks like
+ exFAT does not support compression and both fields must be
+ equal.
+
+ There is an exception though: pagefile.sys (its real_size
+ is always 0).
+ */
+ if (real_size != (*node)->size)
+ {
+ char buffer[EXFAT_NAME_MAX + 1];
+
+ exfat_get_name(*node, buffer, EXFAT_NAME_MAX);
+ exfat_error("`%s' real size does not equal to size "
+ "(%"PRIu64" != %"PRIu64")", buffer,
+ real_size, (*node)->size);
+ goto error;
+ }
+ if (actual_checksum != reference_checksum)
+ {
+ char buffer[EXFAT_NAME_MAX + 1];
+
+ exfat_get_name(*node, buffer, EXFAT_NAME_MAX);
+ exfat_error("`%s' has invalid checksum (0x%hx != 0x%hx)",
+ buffer, actual_checksum, reference_checksum);
+ goto error;
+ }
+ if (fetch_next_entry(ef, parent, it) != 0)
+ goto error;
+ return 0; /* entry completed */
+ }
+ break;
+
+ 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)))
+ {
+ exfat_error("invalid cluster 0x%x in upcase table",
+ le32_to_cpu(upcase->start_cluster));
+ goto error;
+ }
+ if (le64_to_cpu(upcase->size) == 0 ||
+ le64_to_cpu(upcase->size) > 0xffff * sizeof(uint16_t) ||
+ le64_to_cpu(upcase->size) % sizeof(uint16_t) != 0)
+ {
+ exfat_error("bad upcase table size (%"PRIu64" bytes)",
+ le64_to_cpu(upcase->size));
+ goto error;
+ }
+ ef->upcase = malloc(le64_to_cpu(upcase->size));
+ if (ef->upcase == NULL)
+ {
+ exfat_error("failed to allocate upcase table (%"PRIu64" bytes)",
+ le64_to_cpu(upcase->size));
+ rc = -ENOMEM;
+ goto error;
+ }
+ ef->upcase_chars = le64_to_cpu(upcase->size) / sizeof(le16_t);
+
+ exfat_pread(ef->dev, ef->upcase, le64_to_cpu(upcase->size),
+ exfat_c2o(ef, le32_to_cpu(upcase->start_cluster)));
+ break;
+
+ case EXFAT_ENTRY_BITMAP:
+ bitmap = (const struct exfat_entry_bitmap*) entry;
+ ef->cmap.start_cluster = le32_to_cpu(bitmap->start_cluster);
+ if (CLUSTER_INVALID(ef->cmap.start_cluster))
+ {
+ exfat_error("invalid cluster 0x%x in clusters bitmap",
+ ef->cmap.start_cluster);
+ goto error;
+ }
+ ef->cmap.size = le32_to_cpu(ef->sb->cluster_count) -
+ EXFAT_FIRST_DATA_CLUSTER;
+ if (le64_to_cpu(bitmap->size) < (ef->cmap.size + 7) / 8)
+ {
+ exfat_error("invalid clusters bitmap size: %"PRIu64
+ " (expected at least %u)",
+ le64_to_cpu(bitmap->size), (ef->cmap.size + 7) / 8);
+ goto error;
+ }
+ /* FIXME bitmap can be rather big, up to 512 MB */
+ ef->cmap.chunk_size = ef->cmap.size;
+ ef->cmap.chunk = malloc(le64_to_cpu(bitmap->size));
+ if (ef->cmap.chunk == NULL)
+ {
+ exfat_error("failed to allocate clusters bitmap chunk "
+ "(%"PRIu64" bytes)", le64_to_cpu(bitmap->size));
+ rc = -ENOMEM;
+ goto error;
+ }
+
+ exfat_pread(ef->dev, ef->cmap.chunk, le64_to_cpu(bitmap->size),
+ exfat_c2o(ef, ef->cmap.start_cluster));
+ break;
+
+ case EXFAT_ENTRY_LABEL:
+ label = (const struct exfat_entry_label*) entry;
+ if (label->length > EXFAT_ENAME_MAX)
+ {
+ exfat_error("too long label (%hhu chars)", label->length);
+ goto error;
+ }
+ if (utf16_to_utf8(ef->label, label->name,
+ sizeof(ef->label), EXFAT_ENAME_MAX) != 0)
+ goto error;
+ break;
+
+ default:
+ if (entry->type & EXFAT_ENTRY_VALID)
+ {
+ exfat_error("unknown entry type 0x%hhx", entry->type);
+ goto error;
+ }
+ break;
+ }
+
+ if (fetch_next_entry(ef, parent, it) != 0)
+ goto error;
+ }
+ /* 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;
+ int rc;
+ struct exfat_node* node;
+ struct exfat_node* current = NULL;
+
+ if (dir->flags & EXFAT_ATTRIB_CACHED)
+ return 0; /* already cached */
+
+ rc = opendir(ef, dir, &it);
+ if (rc != 0)
+ return rc;
+ while ((rc = readdir(ef, dir, &node, &it)) == 0)
+ {
+ node->parent = dir;
+ if (current != NULL)
+ {
+ current->next = node;
+ node->prev = current;
+ }
+ else
+ dir->child = node;
+
+ current = node;
+ }
+ closedir(&it);
+
+ if (rc != -ENOENT)
+ {
+ /* rollback */
+ for (current = dir->child; current; current = node)
+ {
+ node = current->next;
+ free(current);
+ }
+ dir->child = NULL;
+ return rc;
+ }
+
+ dir->flags |= EXFAT_ATTRIB_CACHED;
+ return 0;
+}
+
+static void reset_cache(struct exfat* ef, struct exfat_node* node)
+{
+ struct exfat_node* child;
+ struct exfat_node* next;
+
+ for (child = node->child; child; child = next)
+ {
+ reset_cache(ef, child);
+ next = child->next;
+ free(child);
+ }
+ if (node->references != 0)
+ {
+ char buffer[EXFAT_NAME_MAX + 1];
+ exfat_get_name(node, buffer, EXFAT_NAME_MAX);
+ exfat_warn("non-zero reference counter (%d) for `%s'",
+ node->references, buffer);
+ }
+ while (node->references--)
+ exfat_put_node(ef, node);
+ node->child = NULL;
+ node->flags &= ~EXFAT_ATTRIB_CACHED;
+}
+
+void exfat_reset_cache(struct exfat* ef)
+{
+ reset_cache(ef, ef->root);
+}
+
+void next_entry(struct exfat* ef, const struct exfat_node* parent,
+ cluster_t* cluster, off64_t* offset)
+{
+ *offset += sizeof(struct exfat_entry);
+ if (*offset % CLUSTER_SIZE(*ef->sb) == 0)
+ /* next cluster cannot be invalid */
+ *cluster = exfat_next_cluster(ef, parent, *cluster);
+}
+
+void exfat_flush_node(struct exfat* ef, struct exfat_node* node)
+{
+ cluster_t cluster;
+ off64_t offset;
+ off64_t meta1_offset, meta2_offset;
+ struct exfat_entry_meta1 meta1;
+ struct exfat_entry_meta2 meta2;
+
+ if (ef->ro)
+ exfat_bug("unable to flush node to read-only FS");
+
+ if (node->parent == NULL)
+ return; /* do not flush unlinked node */
+
+ cluster = node->entry_cluster;
+ offset = node->entry_offset;
+ meta1_offset = co2o(ef, cluster, offset);
+ next_entry(ef, node->parent, &cluster, &offset);
+ meta2_offset = co2o(ef, cluster, offset);
+
+ exfat_pread(ef->dev, &meta1, sizeof(meta1), meta1_offset);
+ 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);
+
+ exfat_pread(ef->dev, &meta2, sizeof(meta2), meta2_offset);
+ if (meta2.type != EXFAT_ENTRY_FILE_INFO)
+ exfat_bug("invalid type of meta2: 0x%hhx", meta2.type);
+ meta2.size = meta2.real_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;
+ /* name hash remains unchanged, no need to recalculate it */
+
+ meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
+
+ exfat_pwrite(ef->dev, &meta1, sizeof(meta1), meta1_offset);
+ exfat_pwrite(ef->dev, &meta2, sizeof(meta2), meta2_offset);
+
+ node->flags &= ~EXFAT_ATTRIB_DIRTY;
+}
+
+static void erase_entry(struct exfat* ef, struct exfat_node* node)
+{
+ cluster_t cluster = node->entry_cluster;
+ off64_t offset = node->entry_offset;
+ int name_entries = DIV_ROUND_UP(utf16_length(node->name), EXFAT_ENAME_MAX);
+ uint8_t entry_type;
+
+ entry_type = EXFAT_ENTRY_FILE & ~EXFAT_ENTRY_VALID;
+ exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));
+
+ next_entry(ef, node->parent, &cluster, &offset);
+ entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID;
+ exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));
+
+ while (name_entries--)
+ {
+ next_entry(ef, node->parent, &cluster, &offset);
+ entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID;
+ exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));
+ }
+}
+
+static void tree_detach(struct exfat_node* node)
+{
+ if (node->prev)
+ node->prev->next = node->next;
+ else /* this is the first node in the list */
+ node->parent->child = node->next;
+ if (node->next)
+ node->next->prev = node->prev;
+ node->parent = NULL;
+ node->prev = NULL;
+ node->next = NULL;
+}
+
+static void tree_attach(struct exfat_node* dir, struct exfat_node* node)
+{
+ node->parent = dir;
+ if (dir->child)
+ {
+ dir->child->prev = node;
+ node->next = dir->child;
+ }
+ dir->child = node;
+}
+
+static int shrink_directory(struct exfat* ef, struct exfat_node* dir,
+ off64_t deleted_offset)
+{
+ const struct exfat_node* node;
+ const struct exfat_node* last_node;
+ uint64_t entries = 0;
+ uint64_t new_size;
+ int rc;
+
+ if (!(dir->flags & EXFAT_ATTRIB_DIR))
+ exfat_bug("attempted to shrink a file");
+ if (!(dir->flags & EXFAT_ATTRIB_CACHED))
+ exfat_bug("attempted to shrink uncached directory");
+
+ for (last_node = node = dir->child; node; node = node->next)
+ {
+ if (deleted_offset < node->entry_offset)
+ {
+ /* there are other entries after the removed one, no way to shrink
+ this directory */
+ return 0;
+ }
+ if (last_node->entry_offset < node->entry_offset)
+ last_node = node;
+ }
+
+ if (last_node)
+ {
+ /* offset of the last entry */
+ entries += last_node->entry_offset / sizeof(struct exfat_entry);
+ /* two subentries with meta info */
+ entries += 2;
+ /* subentries with file name */
+ entries += DIV_ROUND_UP(utf16_length(last_node->name),
+ EXFAT_ENAME_MAX);
+ }
+
+ new_size = DIV_ROUND_UP(entries * sizeof(struct exfat_entry),
+ CLUSTER_SIZE(*ef->sb)) * CLUSTER_SIZE(*ef->sb);
+ if (new_size == 0) /* directory always has at least 1 cluster */
+ new_size = CLUSTER_SIZE(*ef->sb);
+ if (new_size == dir->size)
+ return 0;
+ rc = exfat_truncate(ef, dir, new_size);
+ if (rc != 0)
+ return rc;
+ return 0;
+}
+
+static int delete(struct exfat* ef, struct exfat_node* node)
+{
+ struct exfat_node* parent = node->parent;
+ off64_t deleted_offset = node->entry_offset;
+ int rc;
+
+ exfat_get_node(parent);
+ erase_entry(ef, node);
+ exfat_update_mtime(parent);
+ tree_detach(node);
+ rc = shrink_directory(ef, parent, deleted_offset);
+ exfat_put_node(ef, parent);
+ /* file clusters will be freed when node reference counter becomes 0 */
+ node->flags |= EXFAT_ATTRIB_UNLINKED;
+ return rc;
+}
+
+int exfat_unlink(struct exfat* ef, struct exfat_node* node)
+{
+ if (node->flags & EXFAT_ATTRIB_DIR)
+ return -EISDIR;
+ return delete(ef, node);
+}
+
+int exfat_rmdir(struct exfat* ef, struct exfat_node* node)
+{
+ if (!(node->flags & EXFAT_ATTRIB_DIR))
+ return -ENOTDIR;
+ /* check that directory is empty */
+ exfat_cache_directory(ef, node);
+ if (node->child)
+ return -ENOTEMPTY;
+ return delete(ef, node);
+}
+
+static int grow_directory(struct exfat* ef, struct exfat_node* dir,
+ uint64_t asize, uint32_t difference)
+{
+ return exfat_truncate(ef, dir,
+ DIV_ROUND_UP(asize + difference, CLUSTER_SIZE(*ef->sb))
+ * CLUSTER_SIZE(*ef->sb));
+}
+
+static int find_slot(struct exfat* ef, struct exfat_node* dir,
+ cluster_t* cluster, off64_t* offset, int subentries)
+{
+ struct iterator it;
+ int rc;
+ const struct exfat_entry* entry;
+ int contiguous = 0;
+
+ rc = opendir(ef, dir, &it);
+ if (rc != 0)
+ return rc;
+ for (;;)
+ {
+ if (contiguous == 0)
+ {
+ *cluster = it.cluster;
+ *offset = it.offset;
+ }
+ 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) != 0)
+ {
+ closedir(&it);
+ return -EIO;
+ }
+ }
+ closedir(&it);
+ return 0;
+}
+
+static int write_entry(struct exfat* ef, struct exfat_node* dir,
+ const le16_t* name, cluster_t cluster, off64_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);
+ int i;
+
+ 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(&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);
+
+ exfat_pwrite(ef->dev, &meta1, sizeof(meta1), co2o(ef, cluster, offset));
+ next_entry(ef, dir, &cluster, &offset);
+ exfat_pwrite(ef->dev, &meta2, sizeof(meta2), co2o(ef, cluster, offset));
+ 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,
+ EXFAT_ENAME_MAX * sizeof(le16_t));
+ next_entry(ef, dir, &cluster, &offset);
+ exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
+ co2o(ef, cluster, offset));
+ }
+
+ init_node_meta1(node, &meta1);
+ init_node_meta2(node, &meta2);
+
+ tree_attach(dir, node);
+ exfat_update_mtime(dir);
+ return 0;
+}
+
+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;
+ off64_t offset = -1;
+ le16_t name[EXFAT_NAME_MAX + 1];
+ int rc;
+
+ rc = exfat_split(ef, &dir, &existing, name, path);
+ if (rc != 0)
+ return rc;
+ if (existing != NULL)
+ {
+ exfat_put_node(ef, existing);
+ exfat_put_node(ef, dir);
+ return -EEXIST;
+ }
+
+ rc = find_slot(ef, dir, &cluster, &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);
+ exfat_put_node(ef, dir);
+ return rc;
+}
+
+int exfat_mknod(struct exfat* ef, const char* path)
+{
+ return create(ef, path, EXFAT_ATTRIB_ARCH);
+}
+
+int exfat_mkdir(struct exfat* ef, const char* path)
+{
+ int rc;
+ struct exfat_node* node;
+
+ rc = create(ef, path, EXFAT_ATTRIB_ARCH | EXFAT_ATTRIB_DIR);
+ if (rc != 0)
+ return rc;
+ rc = exfat_lookup(ef, &node, path);
+ if (rc != 0)
+ return 0;
+ /* directories always have at least one cluster */
+ rc = exfat_truncate(ef, node, CLUSTER_SIZE(*ef->sb));
+ if (rc != 0)
+ {
+ delete(ef, node);
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ exfat_put_node(ef, node);
+ return 0;
+}
+
+static void rename_entry(struct exfat* ef, struct exfat_node* dir,
+ struct exfat_node* node, const le16_t* name, cluster_t new_cluster,
+ off64_t new_offset)
+{
+ struct exfat_entry_meta1 meta1;
+ struct exfat_entry_meta2 meta2;
+ cluster_t old_cluster = node->entry_cluster;
+ off64_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);
+ int i;
+
+ exfat_pread(ef->dev, &meta1, sizeof(meta1),
+ co2o(ef, old_cluster, old_offset));
+ next_entry(ef, node->parent, &old_cluster, &old_offset);
+ exfat_pread(ef->dev, &meta2, sizeof(meta2),
+ co2o(ef, old_cluster, old_offset));
+ 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);
+
+ erase_entry(ef, node);
+
+ node->entry_cluster = new_cluster;
+ node->entry_offset = new_offset;
+
+ exfat_pwrite(ef->dev, &meta1, sizeof(meta1),
+ co2o(ef, new_cluster, new_offset));
+ next_entry(ef, dir, &new_cluster, &new_offset);
+ exfat_pwrite(ef->dev, &meta2, sizeof(meta2),
+ co2o(ef, new_cluster, new_offset));
+
+ 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,
+ EXFAT_ENAME_MAX * sizeof(le16_t));
+ next_entry(ef, dir, &new_cluster, &new_offset);
+ exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
+ co2o(ef, new_cluster, new_offset));
+ }
+
+ memcpy(node->name, name, (EXFAT_NAME_MAX + 1) * sizeof(le16_t));
+ tree_detach(node);
+ tree_attach(dir, node);
+}
+
+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;
+ off64_t offset = -1;
+ le16_t name[EXFAT_NAME_MAX + 1];
+ int rc;
+
+ rc = exfat_lookup(ef, &node, old_path);
+ if (rc != 0)
+ return rc;
+
+ rc = exfat_split(ef, &dir, &existing, name, new_path);
+ if (rc != 0)
+ {
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ if (existing != NULL)
+ {
+ /* remove target if it's not the same node as source */
+ if (existing != node)
+ {
+ if (existing->flags & EXFAT_ATTRIB_DIR)
+ {
+ if (node->flags & EXFAT_ATTRIB_DIR)
+ rc = exfat_rmdir(ef, existing);
+ else
+ rc = -ENOTDIR;
+ }
+ else
+ {
+ if (!(node->flags & EXFAT_ATTRIB_DIR))
+ rc = exfat_unlink(ef, existing);
+ else
+ rc = -EISDIR;
+ }
+ exfat_put_node(ef, existing);
+ if (rc != 0)
+ {
+ exfat_put_node(ef, dir);
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ }
+ else
+ exfat_put_node(ef, existing);
+ }
+
+ rc = find_slot(ef, dir, &cluster, &offset,
+ 2 + DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX));
+ if (rc != 0)
+ {
+ exfat_put_node(ef, dir);
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ rename_entry(ef, dir, node, name, cluster, offset);
+ exfat_put_node(ef, dir);
+ exfat_put_node(ef, node);
+ return 0;
+}
+
+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;
+}
+
+void exfat_update_atime(struct exfat_node* node)
+{
+ node->atime = time(NULL);
+ node->flags |= EXFAT_ATTRIB_DIRTY;
+}
+
+void exfat_update_mtime(struct exfat_node* node)
+{
+ node->mtime = time(NULL);
+ node->flags |= EXFAT_ATTRIB_DIRTY;
+}
+
+const char* exfat_get_label(struct exfat* ef)
+{
+ return ef->label;
+}
+
+static int find_label(struct exfat* ef, cluster_t* cluster, off64_t* offset)
+{
+ struct iterator it;
+ int rc;
+
+ rc = opendir(ef, ef->root, &it);
+ if (rc != 0)
+ return rc;
+
+ for (;;)
+ {
+ if (it.offset >= ef->root->size)
+ {
+ closedir(&it);
+ return -ENOENT;
+ }
+
+ if (get_entry_ptr(ef, &it)->type == EXFAT_ENTRY_LABEL)
+ {
+ *cluster = it.cluster;
+ *offset = it.offset;
+ closedir(&it);
+ return 0;
+ }
+
+ if (fetch_next_entry(ef, ef->root, &it) != 0)
+ {
+ closedir(&it);
+ return -EIO;
+ }
+ }
+}
+
+int exfat_set_label(struct exfat* ef, const char* label)
+{
+ le16_t label_utf16[EXFAT_ENAME_MAX + 1];
+ int rc;
+ cluster_t cluster;
+ off64_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));
+ if (rc != 0)
+ return rc;
+
+ rc = find_label(ef, &cluster, &offset);
+ if (rc == -ENOENT)
+ rc = find_slot(ef, ef->root, &cluster, &offset, 1);
+ if (rc != 0)
+ return rc;
+
+ entry.type = EXFAT_ENTRY_LABEL;
+ entry.length = utf16_length(label_utf16);
+ memcpy(entry.name, label_utf16, sizeof(entry.name));
+ if (entry.length == 0)
+ entry.type ^= EXFAT_ENTRY_VALID;
+
+ exfat_pwrite(ef->dev, &entry, sizeof(struct exfat_entry_label),
+ co2o(ef, cluster, offset));
+ return 0;
+}
diff --git a/exfat/libexfat/time.c b/exfat/libexfat/time.c
new file mode 100644
index 000000000..890930eac
--- /dev/null
+++ b/exfat/libexfat/time.c
@@ -0,0 +1,156 @@
+/*
+ time.c (03.02.12)
+ exFAT file system implementation library.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#include "exfat.h"
+
+/* timezone offset from UTC in seconds; positive for western timezones,
+ negative for eastern ones */
+static long exfat_timezone;
+
+#define SEC_IN_MIN 60ll
+#define SEC_IN_HOUR (60 * SEC_IN_MIN)
+#define SEC_IN_DAY (24 * SEC_IN_HOUR)
+#define SEC_IN_YEAR (365 * SEC_IN_DAY) /* not leap year */
+/* Unix epoch started at 0:00:00 UTC 1 January 1970 */
+#define UNIX_EPOCH_YEAR 1970
+/* exFAT epoch started at 0:00:00 UTC 1 January 1980 */
+#define EXFAT_EPOCH_YEAR 1980
+/* number of years from Unix epoch to exFAT epoch */
+#define EPOCH_DIFF_YEAR (EXFAT_EPOCH_YEAR - UNIX_EPOCH_YEAR)
+/* number of days from Unix epoch to exFAT epoch (considering leap days) */
+#define EPOCH_DIFF_DAYS (EPOCH_DIFF_YEAR * 365 + EPOCH_DIFF_YEAR / 4)
+/* number of seconds from Unix epoch to exFAT epoch (considering leap days) */
+#define EPOCH_DIFF_SEC (EPOCH_DIFF_DAYS * SEC_IN_DAY)
+/* number of leap years passed from exFAT epoch to the specified year
+ (excluding the specified year itself) */
+#define LEAP_YEARS(year) ((EXFAT_EPOCH_YEAR + (year) - 1) / 4 \
+ - (EXFAT_EPOCH_YEAR - 1) / 4)
+/* checks whether the specified year is leap */
+#define IS_LEAP_YEAR(year) ((EXFAT_EPOCH_YEAR + (year)) % 4 == 0)
+
+static const time_t days_in_year[] =
+{
+ /* Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec */
+ 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
+};
+
+time_t exfat_exfat2unix(le16_t date, le16_t time, uint8_t centisec)
+{
+ time_t unix_time = EPOCH_DIFF_SEC;
+ uint16_t ndate = le16_to_cpu(date);
+ uint16_t ntime = le16_to_cpu(time);
+
+ uint16_t day = ndate & 0x1f; /* 5 bits, 1-31 */
+ uint16_t month = ndate >> 5 & 0xf; /* 4 bits, 1-12 */
+ uint16_t year = ndate >> 9; /* 7 bits, 1-127 (+1980) */
+
+ uint16_t twosec = ntime & 0x1f; /* 5 bits, 0-29 (2 sec granularity) */
+ uint16_t min = ntime >> 5 & 0x3f; /* 6 bits, 0-59 */
+ uint16_t hour = ntime >> 11; /* 5 bits, 0-23 */
+
+ if (day == 0 || month == 0 || month > 12)
+ {
+ exfat_error("bad date %u-%02hu-%02hu",
+ year + EXFAT_EPOCH_YEAR, month, day);
+ return 0;
+ }
+ if (hour > 23 || min > 59 || twosec > 29)
+ {
+ exfat_error("bad time %hu:%02hu:%02u",
+ hour, min, twosec * 2);
+ return 0;
+ }
+ if (centisec > 199)
+ {
+ exfat_error("bad centiseconds count %hhu", centisec);
+ return 0;
+ }
+
+ /* every 4th year between 1904 and 2096 is leap */
+ unix_time += year * SEC_IN_YEAR + LEAP_YEARS(year) * SEC_IN_DAY;
+ unix_time += days_in_year[month] * SEC_IN_DAY;
+ /* if it's leap year and February has passed we should add 1 day */
+ if ((EXFAT_EPOCH_YEAR + year) % 4 == 0 && month > 2)
+ unix_time += SEC_IN_DAY;
+ unix_time += (day - 1) * SEC_IN_DAY;
+
+ unix_time += hour * SEC_IN_HOUR;
+ unix_time += min * SEC_IN_MIN;
+ /* exFAT represents time with 2 sec granularity */
+ unix_time += twosec * 2;
+ unix_time += centisec / 100;
+
+ /* exFAT stores timestamps in local time, so we correct it to UTC */
+ unix_time += exfat_timezone;
+
+ return unix_time;
+}
+
+void exfat_unix2exfat(time_t unix_time, le16_t* date, le16_t* time,
+ uint8_t* centisec)
+{
+ time_t shift = EPOCH_DIFF_SEC + exfat_timezone;
+ uint16_t day, month, year;
+ uint16_t twosec, min, hour;
+ int days;
+ int i;
+
+ /* time before exFAT epoch cannot be represented */
+ if (unix_time < shift)
+ unix_time = shift;
+
+ unix_time -= shift;
+
+ days = unix_time / SEC_IN_DAY;
+ year = (4 * days) / (4 * 365 + 1);
+ days -= year * 365 + LEAP_YEARS(year);
+ month = 0;
+ for (i = 1; i <= 12; i++)
+ {
+ int leap_day = (IS_LEAP_YEAR(year) && i == 2);
+ int leap_sub = (IS_LEAP_YEAR(year) && i >= 3);
+
+ if (i == 12 || days - leap_sub < days_in_year[i + 1] + leap_day)
+ {
+ month = i;
+ days -= days_in_year[i] + leap_sub;
+ break;
+ }
+ }
+ day = days + 1;
+
+ hour = (unix_time % SEC_IN_DAY) / SEC_IN_HOUR;
+ min = (unix_time % SEC_IN_HOUR) / SEC_IN_MIN;
+ twosec = (unix_time % SEC_IN_MIN) / 2;
+
+ *date = cpu_to_le16(day | (month << 5) | (year << 9));
+ *time = cpu_to_le16(twosec | (min << 5) | (hour << 11));
+ if (centisec)
+ *centisec = (unix_time % 2) * 100;
+}
+
+void exfat_tzset(void)
+{
+ time_t now;
+
+ tzset();
+ now = time(NULL);
+ exfat_timezone = mktime(gmtime(&now)) - now;
+}
diff --git a/exfat/libexfat/utf.c b/exfat/libexfat/utf.c
new file mode 100644
index 000000000..983c7930b
--- /dev/null
+++ b/exfat/libexfat/utf.c
@@ -0,0 +1,229 @@
+/*
+ utf.c (13.09.09)
+ exFAT file system implementation library.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#include "exfat.h"
+#include <errno.h>
+
+static char* wchar_to_utf8(char* output, wchar_t wc, size_t outsize)
+{
+ if (wc <= 0x7f)
+ {
+ if (outsize < 1)
+ return NULL;
+ *output++ = (char) wc;
+ }
+ else if (wc <= 0x7ff)
+ {
+ if (outsize < 2)
+ return NULL;
+ *output++ = 0xc0 | (wc >> 6);
+ *output++ = 0x80 | (wc & 0x3f);
+ }
+ else if (wc <= 0xffff)
+ {
+ if (outsize < 3)
+ return NULL;
+ *output++ = 0xe0 | (wc >> 12);
+ *output++ = 0x80 | ((wc >> 6) & 0x3f);
+ *output++ = 0x80 | (wc & 0x3f);
+ }
+ else if (wc <= 0x1fffff)
+ {
+ if (outsize < 4)
+ return NULL;
+ *output++ = 0xf0 | (wc >> 18);
+ *output++ = 0x80 | ((wc >> 12) & 0x3f);
+ *output++ = 0x80 | ((wc >> 6) & 0x3f);
+ *output++ = 0x80 | (wc & 0x3f);
+ }
+ else if (wc <= 0x3ffffff)
+ {
+ if (outsize < 5)
+ return NULL;
+ *output++ = 0xf8 | (wc >> 24);
+ *output++ = 0x80 | ((wc >> 18) & 0x3f);
+ *output++ = 0x80 | ((wc >> 12) & 0x3f);
+ *output++ = 0x80 | ((wc >> 6) & 0x3f);
+ *output++ = 0x80 | (wc & 0x3f);
+ }
+ else if (wc <= 0x7fffffff)
+ {
+ if (outsize < 6)
+ return NULL;
+ *output++ = 0xfc | (wc >> 30);
+ *output++ = 0x80 | ((wc >> 24) & 0x3f);
+ *output++ = 0x80 | ((wc >> 18) & 0x3f);
+ *output++ = 0x80 | ((wc >> 12) & 0x3f);
+ *output++ = 0x80 | ((wc >> 6) & 0x3f);
+ *output++ = 0x80 | (wc & 0x3f);
+ }
+ else
+ return NULL;
+
+ return output;
+}
+
+static const le16_t* utf16_to_wchar(const le16_t* input, wchar_t* wc,
+ size_t insize)
+{
+ if ((le16_to_cpu(input[0]) & 0xfc00) == 0xd800)
+ {
+ if (insize < 2 || (le16_to_cpu(input[1]) & 0xfc00) != 0xdc00)
+ return NULL;
+ *wc = ((wchar_t) (le16_to_cpu(input[0]) & 0x3ff) << 10);
+ *wc |= (le16_to_cpu(input[1]) & 0x3ff);
+ *wc += 0x10000;
+ return input + 2;
+ }
+ else
+ {
+ *wc = le16_to_cpu(*input);
+ return input + 1;
+ }
+}
+
+int utf16_to_utf8(char* output, const le16_t* input, size_t outsize,
+ size_t insize)
+{
+ const le16_t* inp = input;
+ char* outp = output;
+ wchar_t wc;
+
+ while (inp - input < insize && le16_to_cpu(*inp))
+ {
+ inp = utf16_to_wchar(inp, &wc, insize - (inp - input));
+ if (inp == NULL)
+ {
+ exfat_error("illegal UTF-16 sequence");
+ return -EILSEQ;
+ }
+ outp = wchar_to_utf8(outp, wc, outsize - (outp - output));
+ if (outp == NULL)
+ {
+ exfat_error("name is too long");
+ return -ENAMETOOLONG;
+ }
+ }
+ *outp = '\0';
+ return 0;
+}
+
+static const char* utf8_to_wchar(const char* input, wchar_t* wc,
+ size_t insize)
+{
+ if ((input[0] & 0x80) == 0 && insize >= 1)
+ {
+ *wc = (wchar_t) input[0];
+ return input + 1;
+ }
+ if ((input[0] & 0xe0) == 0xc0 && insize >= 2)
+ {
+ *wc = (((wchar_t) input[0] & 0x1f) << 6) |
+ ((wchar_t) input[1] & 0x3f);
+ return input + 2;
+ }
+ if ((input[0] & 0xf0) == 0xe0 && insize >= 3)
+ {
+ *wc = (((wchar_t) input[0] & 0x0f) << 12) |
+ (((wchar_t) input[1] & 0x3f) << 6) |
+ ((wchar_t) input[2] & 0x3f);
+ return input + 3;
+ }
+ if ((input[0] & 0xf8) == 0xf0 && insize >= 4)
+ {
+ *wc = (((wchar_t) input[0] & 0x07) << 18) |
+ (((wchar_t) input[1] & 0x3f) << 12) |
+ (((wchar_t) input[2] & 0x3f) << 6) |
+ ((wchar_t) input[3] & 0x3f);
+ return input + 4;
+ }
+ if ((input[0] & 0xfc) == 0xf8 && insize >= 5)
+ {
+ *wc = (((wchar_t) input[0] & 0x03) << 24) |
+ (((wchar_t) input[1] & 0x3f) << 18) |
+ (((wchar_t) input[2] & 0x3f) << 12) |
+ (((wchar_t) input[3] & 0x3f) << 6) |
+ ((wchar_t) input[4] & 0x3f);
+ return input + 5;
+ }
+ if ((input[0] & 0xfe) == 0xfc && insize >= 6)
+ {
+ *wc = (((wchar_t) input[0] & 0x01) << 30) |
+ (((wchar_t) input[1] & 0x3f) << 24) |
+ (((wchar_t) input[2] & 0x3f) << 18) |
+ (((wchar_t) input[3] & 0x3f) << 12) |
+ (((wchar_t) input[4] & 0x3f) << 6) |
+ ((wchar_t) input[5] & 0x3f);
+ return input + 6;
+ }
+ return NULL;
+}
+
+static le16_t* wchar_to_utf16(le16_t* output, wchar_t wc, size_t outsize)
+{
+ if (wc <= 0xffff) /* if character is from BMP */
+ {
+ if (outsize == 0)
+ return NULL;
+ output[0] = cpu_to_le16(wc);
+ return output + 1;
+ }
+ if (outsize < 2)
+ return NULL;
+ wc -= 0x10000;
+ output[0] = cpu_to_le16(0xd800 | ((wc >> 10) & 0x3ff));
+ output[1] = cpu_to_le16(0xdc00 | (wc & 0x3ff));
+ return output + 2;
+}
+
+int utf8_to_utf16(le16_t* output, const char* input, size_t outsize,
+ size_t insize)
+{
+ const char* inp = input;
+ le16_t* outp = output;
+ wchar_t wc;
+
+ while (inp - input < insize && *inp)
+ {
+ inp = utf8_to_wchar(inp, &wc, insize - (inp - input));
+ if (inp == NULL)
+ {
+ exfat_error("illegal UTF-8 sequence");
+ return -EILSEQ;
+ }
+ outp = wchar_to_utf16(outp, wc, outsize - (outp - output));
+ if (outp == NULL)
+ {
+ exfat_error("name is too long");
+ return -ENAMETOOLONG;
+ }
+ }
+ *outp = cpu_to_le16(0);
+ return 0;
+}
+
+size_t utf16_length(const le16_t* str)
+{
+ size_t i = 0;
+
+ while (le16_to_cpu(str[i]))
+ i++;
+ return i;
+}
diff --git a/exfat/libexfat/utils.c b/exfat/libexfat/utils.c
new file mode 100644
index 000000000..14b4791fe
--- /dev/null
+++ b/exfat/libexfat/utils.c
@@ -0,0 +1,176 @@
+/*
+ utils.c (04.09.09)
+ exFAT file system implementation library.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#include "exfat.h"
+#include <string.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+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)
+ stbuf->st_mode = S_IFDIR | (0777 & ~ef->dmask);
+ else
+ stbuf->st_mode = S_IFREG | (0777 & ~ef->fmask);
+ stbuf->st_nlink = 1;
+ 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_mtime = node->mtime;
+ stbuf->st_atime = node->atime;
+ /* set ctime to mtime to ensure we don't break programs that rely on ctime
+ (e.g. rsync) */
+ stbuf->st_ctime = node->mtime;
+}
+
+void exfat_get_name(const struct exfat_node* node, char* buffer, size_t n)
+{
+ if (utf16_to_utf8(buffer, node->name, n, EXFAT_NAME_MAX) != 0)
+ exfat_bug("failed to convert name to UTF-8");
+}
+
+uint16_t exfat_start_checksum(const struct exfat_entry_meta1* entry)
+{
+ uint16_t sum = 0;
+ int i;
+
+ 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];
+ 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;
+}
+
+le16_t exfat_calc_checksum(const struct exfat_entry_meta1* meta1,
+ const struct exfat_entry_meta2* meta2, const le16_t* name)
+{
+ 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,
+ EXFAT_ENAME_MAX * sizeof(le16_t));
+ checksum = exfat_add_checksum(&name_entry, checksum);
+ }
+ return cpu_to_le16(checksum);
+}
+
+uint32_t exfat_vbr_start_checksum(const void* sector, size_t size)
+{
+ size_t i;
+ uint32_t sum = 0;
+
+ for (i = 0; i < size; i++)
+ /* skip volume_state and allocated_percent fields */
+ if (i != 0x6a && i != 0x6b && i != 0x70)
+ sum = ((sum << 31) | (sum >> 1)) + ((const uint8_t*) sector)[i];
+ return sum;
+}
+
+uint32_t exfat_vbr_add_checksum(const void* sector, size_t size, uint32_t sum)
+{
+ size_t i;
+
+ for (i = 0; i < size; i++)
+ sum = ((sum << 31) | (sum >> 1)) + ((const uint8_t*) sector)[i];
+ return sum;
+}
+
+le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name)
+{
+ size_t i;
+ size_t length = utf16_length(name);
+ uint16_t hash = 0;
+
+ for (i = 0; i < length; i++)
+ {
+ uint16_t c = le16_to_cpu(name[i]);
+
+ /* convert to upper case */
+ if (c < ef->upcase_chars)
+ c = le16_to_cpu(ef->upcase[c]);
+
+ hash = ((hash << 15) | (hash >> 1)) + (c & 0xff);
+ hash = ((hash << 15) | (hash >> 1)) + (c >> 8);
+ }
+ return cpu_to_le16(hash);
+}
+
+void exfat_humanize_bytes(uint64_t value, struct exfat_human_bytes* hb)
+{
+ size_t i;
+ /* 16 EB (minus 1 byte) is the largest size that can be represented by
+ uint64_t */
+ const char* units[] = {"bytes", "KB", "MB", "GB", "TB", "PB", "EB"};
+ uint64_t divisor = 1;
+ uint64_t temp = 0;
+
+ for (i = 0; ; i++, divisor *= 1024)
+ {
+ temp = (value + divisor / 2) / divisor;
+
+ if (temp == 0)
+ break;
+ if (temp / 1024 * 1024 == temp)
+ continue;
+ if (temp < 10240)
+ break;
+ }
+ hb->value = temp;
+ hb->unit = units[i];
+}
+
+void exfat_print_info(const struct exfat_super_block* sb,
+ uint32_t free_clusters)
+{
+ struct exfat_human_bytes hb;
+ off64_t total_space = le64_to_cpu(sb->sector_count) * SECTOR_SIZE(*sb);
+ off64_t avail_space = (off64_t) free_clusters * CLUSTER_SIZE(*sb);
+
+ printf("File system version %hhu.%hhu\n",
+ sb->version.major, sb->version.minor);
+ exfat_humanize_bytes(SECTOR_SIZE(*sb), &hb);
+ printf("Sector size %10"PRIu64" %s\n", hb.value, hb.unit);
+ exfat_humanize_bytes(CLUSTER_SIZE(*sb), &hb);
+ printf("Cluster size %10"PRIu64" %s\n", hb.value, hb.unit);
+ exfat_humanize_bytes(total_space, &hb);
+ printf("Volume size %10"PRIu64" %s\n", hb.value, hb.unit);
+ exfat_humanize_bytes(total_space - avail_space, &hb);
+ printf("Used space %10"PRIu64" %s\n", hb.value, hb.unit);
+ exfat_humanize_bytes(avail_space, &hb);
+ printf("Available space %10"PRIu64" %s\n", hb.value, hb.unit);
+}
diff --git a/exfat/libexfat/version.h b/exfat/libexfat/version.h
new file mode 100644
index 000000000..f35cb4fdf
--- /dev/null
+++ b/exfat/libexfat/version.h
@@ -0,0 +1,28 @@
+/*
+ version.h (12.06.10)
+ Version constants.
+
+ Copyright (C) 2010-2012 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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/>.
+*/
+
+#ifndef VERSION_H_INCLUDED
+#define VERSION_H_INCLUDED
+
+#define EXFAT_VERSION_MAJOR 0
+#define EXFAT_VERSION_MINOR 9
+#define EXFAT_VERSION_PATCH 8
+
+#endif /* ifndef VERSION_H_INCLUDED */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-05 06:25:00 +0100