Update the Homepage field in d/control.

[sven/exfat-utils.git] / libexfat / exfat.h

diff --git a/libexfat/exfat.h b/libexfat/exfat.h
index de2e1a23746cc4529a46c7a31c442d25d4c574c8..122ac5be75c3ba4803a0b0764762ee21a3ccded6 100644 (file)
--- a/libexfat/exfat.h
+++ b/libexfat/exfat.h
@@ -3,11 +3,12 @@
        Definitions of structures and constants used in exFAT file system
        implementation.
 
        Definitions of structures and constants used in exFAT file system
        implementation.
 

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

 
 

-       This program is free software: you can redistribute it and/or modify
+       This program is free software; you can redistribute it and/or modify

        it under the terms of the GNU General Public License as published by
        it under the terms of the GNU General Public License as published by

-       the Free Software Foundation, either version 3 of the License, or
+       the Free Software Foundation, either version 2 of the License, or

        (at your option) any later version.
 
        This program is distributed in the hope that it will be useful,
        (at your option) any later version.
 
        This program is distributed in the hope that it will be useful,


@@ -15,20 +16,23 @@
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
 
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
 

-       You should have received a copy of the GNU General Public License
-       along with this program.  If not, see <http://www.gnu.org/licenses/>.
+       You should have received a copy of the GNU General Public License along
+       with this program; if not, write to the Free Software Foundation, Inc.,
+       51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */
 
 #ifndef EXFAT_H_INCLUDED
 #define EXFAT_H_INCLUDED
 
 */
 
 #ifndef EXFAT_H_INCLUDED
 #define EXFAT_H_INCLUDED
 

+#include "config.h"
+#include "compiler.h"
+#include "exfatfs.h"

 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>

+#include <stdbool.h>

 #include <sys/stat.h>
 #include <sys/types.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_NAME_MAX 256
 #define EXFAT_ATTRIB_CONTIGUOUS 0x10000


@@ -38,17 +42,28 @@
 #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 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_CLUSTER_BAD || (c) == EXFAT_CLUSTER_END)
+#define CLUSTER_INVALID(c) \
+       ((c) < EXFAT_FIRST_DATA_CLUSTER || (c) > EXFAT_LAST_DATA_CLUSTER)

 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 
 #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 DIV_ROUND_UP(x, d) (((x) + (d) - 1) / (d))

+#define ROUND_UP(x, d) (DIV_ROUND_UP(x, d) * (d))
+#define UTF8_BYTES(c) ((c) * 6) /* UTF-8 character can occupy up to 6 bytes */

 
 

+#define BMAP_SIZE(count) (ROUND_UP(count, sizeof(bitmap_t) * 8) / 8)
+#define BMAP_BLOCK(index) ((index) / sizeof(bitmap_t) / 8)
+#define BMAP_MASK(index) ((bitmap_t) 1 << ((index) % (sizeof(bitmap_t) * 8)))

 #define BMAP_GET(bitmap, index) \
 #define BMAP_GET(bitmap, index) \

-       (((uint8_t*) bitmap)[(index) / 8] & (1u << ((index) % 8)))
+       ((bitmap)[BMAP_BLOCK(index)] & BMAP_MASK(index))

 #define BMAP_SET(bitmap, index) \
 #define BMAP_SET(bitmap, index) \

-       ((uint8_t*) bitmap)[(index) / 8] |= (1u << ((index) % 8))
+       ((bitmap)[BMAP_BLOCK(index)] |= BMAP_MASK(index))

 #define BMAP_CLR(bitmap, index) \
 #define BMAP_CLR(bitmap, index) \

-       ((uint8_t*) bitmap)[(index) / 8] &= ~(1u << ((index) % 8))
+       ((bitmap)[BMAP_BLOCK(index)] &= ~BMAP_MASK(index))
+
+/* The size of off_t type must be 64 bits. File systems larger than 2 GB will
+   be corrupted with 32-bit off_t. */
+STATIC_ASSERT(sizeof(off_t) == 8);

 
 struct exfat_node
 {
 
 struct exfat_node
 {


@@ -69,10 +84,19 @@ struct exfat_node
        le16_t name[EXFAT_NAME_MAX + 1];
 };
 
        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
 {

+       struct exfat_dev* dev;

        struct exfat_super_block* sb;
        struct exfat_super_block* sb;

-       int fd;

        le16_t* upcase;
        size_t upcase_chars;
        struct exfat_node* root;
        le16_t* upcase;
        size_t upcase_chars;
        struct exfat_node* root;


@@ -80,20 +104,18 @@ struct exfat
        {
                cluster_t start_cluster;
                uint32_t size;                          /* in bits */
        {
                cluster_t start_cluster;
                uint32_t size;                          /* in bits */

-               uint8_t* chunk;
+               bitmap_t* chunk;

                uint32_t chunk_size;            /* in bits */
                uint32_t chunk_size;            /* in bits */

-               int dirty;
+               bool dirty;

        }
        cmap;
        }
        cmap;

-       char label[EXFAT_ENAME_MAX * 6 + 1]; /* a character can occupy up to
-                                                                                       6 bytes in UTF-8 */
+       char label[UTF8_BYTES(EXFAT_ENAME_MAX) + 1];

        void* zero_cluster;
        int dmask, fmask;
        uid_t uid;
        gid_t gid;
        int ro;
        void* zero_cluster;
        int dmask, fmask;
        uid_t uid;
        gid_t gid;
        int ro;

-       int ro_fallback;
-       int noatime;
+       bool noatime;

 };
 
 /* in-core nodes iterator */
 };
 
 /* in-core nodes iterator */


@@ -111,21 +133,26 @@ struct exfat_human_bytes
 
 extern int exfat_errors;
 
 
 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)));
-
-int exfat_open(const char* spec, int ro);
-void exfat_read_raw(void* buffer, size_t size, off_t offset, int fd);
-void exfat_write_raw(const void* buffer, size_t size, off_t offset, int fd);
-ssize_t exfat_read(const struct exfat* ef, struct exfat_node* node,
+void exfat_bug(const char* format, ...) PRINTF NORETURN;
+void exfat_error(const char* format, ...) PRINTF;
+void exfat_warn(const char* format, ...) PRINTF;
+void exfat_debug(const char* format, ...) PRINTF;
+
+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);
+off_t exfat_get_size(const struct exfat_dev* dev);
+off_t exfat_seek(struct exfat_dev* dev, off_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);
+ssize_t exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
+               off_t offset);
+ssize_t exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
+               off_t offset);
+ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,

                void* buffer, size_t size, off_t offset);
                void* buffer, size_t size, off_t offset);

-ssize_t exfat_write(struct exfat* ef, struct exfat_node* node,
+ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,

                const void* buffer, size_t size, off_t offset);
 
 int exfat_opendir(struct exfat* ef, struct exfat_node* dir,
                const void* buffer, size_t size, off_t offset);
 
 int exfat_opendir(struct exfat* ef, struct exfat_node* dir,


@@ -142,16 +169,14 @@ 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);
                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);
+int exfat_flush(struct exfat* ef);
+int exfat_truncate(struct exfat* ef, struct exfat_node* node, uint64_t size,
+               bool erase);

 uint32_t exfat_count_free_clusters(const struct exfat* ef);
 int exfat_find_used_sectors(const struct exfat* ef, off_t* a, off_t* b);
 
 void exfat_stat(const struct exfat* ef, const struct exfat_node* node,
                struct stat* stbuf);
 uint32_t exfat_count_free_clusters(const struct exfat* ef);
 int exfat_find_used_sectors(const struct exfat* ef, off_t* a, off_t* b);
 
 void exfat_stat(const struct exfat* ef, const struct exfat_node* node,
                struct stat* stbuf);

-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_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);
 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);


@@ -172,9 +197,10 @@ 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);
 
 struct exfat_node* exfat_get_node(struct exfat_node* node);
 void exfat_put_node(struct exfat* ef, struct exfat_node* node);

+int exfat_cleanup_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);
 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_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_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);


@@ -189,4 +215,9 @@ 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);
 
 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 */
 #endif /* ifndef EXFAT_H_INCLUDED */