path: root/package/system/fstools/patches/002-ntfs-exfat.patch

Index: fstools-2015-02-25.1/CMakeLists.txt
===================================================================
--- fstools-2015-02-25.1.orig/CMakeLists.txt
+++ fstools-2015-02-25.1/CMakeLists.txt
@@ -23,6 +23,8 @@ ADD_LIBRARY(blkid-tiny SHARED
 		libblkid-tiny/ext.c
 		libblkid-tiny/jffs2.c
 		libblkid-tiny/vfat.c
+		libblkid-tiny/ntfs.c
+		libblkid-tiny/exfat.c
 		libblkid-tiny/hfs.c
 		libblkid-tiny/swap.c
 		libblkid-tiny/ubifs.c
Index: fstools-2015-02-25.1/libblkid-tiny/libblkid-tiny.c
===================================================================
--- fstools-2015-02-25.1.orig/libblkid-tiny/libblkid-tiny.c
+++ fstools-2015-02-25.1/libblkid-tiny/libblkid-tiny.c
@@ -10,6 +10,8 @@
 #define DEBUG(fmt, ...)
 #endif
 
+#define isspace(x) ((x == ' ') || (x == '\t') || (x == '\r') || (x == '\n'))
+
 int blkid_debug_mask = 0;
 
 static unsigned char *probe_buffer;
@@ -152,9 +154,77 @@ int blkid_probe_sprintf_uuid(blkid_probe
 	return 0;
 }
 
+size_t blkid_encode_to_utf8(int enc, unsigned char *dest, size_t len,
+                            const unsigned char *src, size_t count)
+{
+    size_t i, j;
+    uint16_t c;
+
+    for (j = i = 0; i + 2 <= count; i += 2)
+    {
+        if (enc == BLKID_ENC_UTF16LE)
+            c = (src[i+1] << 8) | src[i];
+        else /* BLKID_ENC_UTF16BE */
+            c = (src[i] << 8) | src[i+1];
+        if (c == 0)
+        {
+            dest[j] = '\0';
+            break;
+        }
+        else if (c < 0x80)
+        {
+            if (j+1 >= len)
+                break;
+            dest[j++] = (uint8_t) c;
+        }
+        else if (c < 0x800)
+        {
+            if (j+2 >= len)
+                break;
+            dest[j++] = (uint8_t) (0xc0 | (c >> 6));
+            dest[j++] = (uint8_t) (0x80 | (c & 0x3f));
+        }
+        else
+        {
+            if (j+3 >= len)
+                break;
+            dest[j++] = (uint8_t) (0xe0 | (c >> 12));
+            dest[j++] = (uint8_t) (0x80 | ((c >> 6) & 0x3f));
+            dest[j++] = (uint8_t) (0x80 | (c & 0x3f));
+        }
+    }
+    dest[j] = '\0';
+    return j;
+}
+
+size_t blkid_rtrim_whitespace(unsigned char *str)
+{
+    size_t i = strlen((char *) str);
+
+    while (i--)
+    {
+        if (!isspace(str[i]))
+            break;
+    }
+    str[++i] = '\0';
+    return i;
+}
+
+int blkid_probe_set_utf8label(blkid_probe pr, unsigned char *label,
+                              size_t len, int enc)
+{
+    blkid_encode_to_utf8(enc, (unsigned char *) pr->label, sizeof(pr->label), label, len);
+    blkid_rtrim_whitespace((unsigned char *) pr->label);
+    return 0;
+}
+ 
+
+
 static const struct blkid_idinfo *idinfos[] =
 {
 	&vfat_idinfo,
+	&ntfs_idinfo,
+	&exfat_idinfo,
 	&swsuspend_idinfo,
 	&swap_idinfo,
 	&ext4dev_idinfo,
Index: fstools-2015-02-25.1/libblkid-tiny/ntfs.c
===================================================================
--- /dev/null
+++ fstools-2015-02-25.1/libblkid-tiny/ntfs.c
@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2008 Karel Zak <kzak@redhat.com>
+ *
+ * This file may be redistributed under the terms of the
+ * GNU Lesser General Public License.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "superblocks.h"
+
+struct ntfs_bios_parameters
+{
+    uint16_t sector_size; /* Size of a sector in bytes. */
+    uint8_t sectors_per_cluster; /* Size of a cluster in sectors. */
+    uint16_t reserved_sectors; /* zero */
+    uint8_t fats; /* zero */
+    uint16_t root_entries; /* zero */
+    uint16_t sectors; /* zero */
+    uint8_t media_type; /* 0xf8 = hard disk */
+    uint16_t sectors_per_fat; /* zero */
+    uint16_t sectors_per_track; /* irrelevant */
+    uint16_t heads; /* irrelevant */
+    uint32_t hidden_sectors; /* zero */
+    uint32_t large_sectors; /* zero */
+} __attribute__ ((__packed__));
+
+struct ntfs_super_block
+{
+    uint8_t jump[3];
+    uint8_t oem_id[8]; /* magic string */
+
+    struct ntfs_bios_parameters bpb;
+
+    uint16_t unused[2];
+    uint64_t number_of_sectors;
+    uint64_t mft_cluster_location;
+    uint64_t mft_mirror_cluster_location;
+    int8_t clusters_per_mft_record;
+    uint8_t reserved1[3];
+    int8_t cluster_per_index_record;
+    uint8_t reserved2[3];
+    uint64_t volume_serial;
+    uint32_t checksum;
+} __attribute__((packed));
+
+struct master_file_table_record
+{
+    uint32_t magic;
+    uint16_t usa_ofs;
+    uint16_t usa_count;
+    uint64_t lsn;
+    uint16_t sequence_number;
+    uint16_t link_count;
+    uint16_t attrs_offset;
+    uint16_t flags;
+    uint32_t bytes_in_use;
+    uint32_t bytes_allocated;
+} __attribute__((__packed__));
+
+struct file_attribute
+{
+    uint32_t type;
+    uint32_t len;
+    uint8_t non_resident;
+    uint8_t name_len;
+    uint16_t name_offset;
+    uint16_t flags;
+    uint16_t instance;
+    uint32_t value_len;
+    uint16_t value_offset;
+} __attribute__((__packed__));
+
+#define MFT_RECORD_VOLUME 3
+#define NTFS_MAX_CLUSTER_SIZE (64 * 1024)
+
+enum
+{
+    MFT_RECORD_ATTR_VOLUME_NAME = 0x60,
+    MFT_RECORD_ATTR_END = 0xffffffff
+};
+
+static int probe_ntfs(blkid_probe pr, const struct blkid_idmag *mag)
+{
+    struct ntfs_super_block *ns;
+    struct master_file_table_record *mft;
+
+    uint32_t sectors_per_cluster, mft_record_size, attr_off;
+    uint16_t sector_size;
+    uint64_t nr_clusters, off;
+    unsigned char *buf_mft;
+
+    ns = blkid_probe_get_sb(pr, mag, struct ntfs_super_block);
+    if (!ns)
+        return -1;
+
+    /*
+    * Check bios parameters block
+    */
+    sector_size = le16_to_cpu(ns->bpb.sector_size);
+    sectors_per_cluster = ns->bpb.sectors_per_cluster;
+
+    if (sector_size < 256 || sector_size > 4096)
+        return 1;
+
+    switch (sectors_per_cluster)
+    {
+        case 1:
+        case 2:
+        case 4:
+        case 8:
+        case 16:
+        case 32:
+        case 64:
+        case 128:
+            break;
+        default:
+            return 1;
+    }
+
+    if ((uint16_t) le16_to_cpu(ns->bpb.sector_size) *
+        ns->bpb.sectors_per_cluster > NTFS_MAX_CLUSTER_SIZE)
+        return 1;
+
+    /* Unused fields must be zero */
+    if (le16_to_cpu(ns->bpb.reserved_sectors)
+        || le16_to_cpu(ns->bpb.root_entries)
+        || le16_to_cpu(ns->bpb.sectors)
+        || le16_to_cpu(ns->bpb.sectors_per_fat)
+        || le32_to_cpu(ns->bpb.large_sectors)
+        || ns->bpb.fats)
+        return 1;
+
+    if ((uint8_t) ns->clusters_per_mft_record < 0xe1
+        || (uint8_t) ns->clusters_per_mft_record > 0xf7)
+    {
+
+        switch (ns->clusters_per_mft_record)
+        {
+            case 1:
+            case 2:
+            case 4:
+            case 8:
+            case 16:
+            case 32:
+            case 64:
+                break;
+            default:
+                return 1;
+        }
+    }
+
+    if (ns->clusters_per_mft_record > 0)
+        mft_record_size = ns->clusters_per_mft_record *
+                          sectors_per_cluster * sector_size;
+    else
+        mft_record_size = 1 << (0 - ns->clusters_per_mft_record);
+
+    nr_clusters = le64_to_cpu(ns->number_of_sectors) / sectors_per_cluster;
+
+    if ((le64_to_cpu(ns->mft_cluster_location) > nr_clusters) ||
+        (le64_to_cpu(ns->mft_mirror_cluster_location) > nr_clusters))
+        return 1;
+
+
+    off = le64_to_cpu(ns->mft_cluster_location) * sector_size *
+          sectors_per_cluster;
+
+    DBG(DEBUG_LOWPROBE, printf("NTFS: sector_size=%d, mft_record_size=%d, "
+                               "sectors_per_cluster=%d, nr_clusters=%ju "
+                               "cluster_offset=%jd",
+                               (int) sector_size, mft_record_size,
+                               sectors_per_cluster, nr_clusters,
+                               off));
+
+    buf_mft = blkid_probe_get_buffer(pr, off, mft_record_size);
+    if (!buf_mft)
+        return 1;
+
+    if (memcmp(buf_mft, "FILE", 4))
+        return 1;
+
+    off += MFT_RECORD_VOLUME * mft_record_size;
+
+    buf_mft = blkid_probe_get_buffer(pr, off, mft_record_size);
+    if (!buf_mft)
+        return 1;
+
+    if (memcmp(buf_mft, "FILE", 4))
+        return 1;
+
+    mft = (struct master_file_table_record *) buf_mft;
+    attr_off = le16_to_cpu(mft->attrs_offset);
+
+    while (attr_off < mft_record_size &&
+           attr_off <= le32_to_cpu(mft->bytes_allocated))
+    {
+
+        uint32_t attr_len;
+        struct file_attribute *attr;
+
+        attr = (struct file_attribute *) (buf_mft + attr_off);
+        attr_len = le32_to_cpu(attr->len);
+        if (!attr_len)
+            break;
+
+        if (le32_to_cpu(attr->type) == MFT_RECORD_ATTR_END)
+            break;
+        if (le32_to_cpu(attr->type) == MFT_RECORD_ATTR_VOLUME_NAME)
+        {
+            unsigned int val_off = le16_to_cpu(attr->value_offset);
+            unsigned int val_len = le32_to_cpu(attr->value_len);
+            unsigned char *val = ((uint8_t *) attr) + val_off;
+
+            blkid_probe_set_utf8label(pr, val, val_len, BLKID_ENC_UTF16LE);
+            break;
+        }
+
+        if (UINT_MAX - attr_len < attr_off)
+            break;
+        attr_off += attr_len;
+    }
+
+    blkid_probe_sprintf_uuid(pr,
+                             (unsigned char *) &ns->volume_serial,
+                             sizeof(ns->volume_serial),
+                             "%016" PRIX64, le64_to_cpu(ns->volume_serial));
+    return 0;
+}
+
+
+const struct blkid_idinfo ntfs_idinfo =
+{
+    .name = "ntfs",
+    .usage = BLKID_USAGE_FILESYSTEM,
+    .probefunc = probe_ntfs,
+    .magics =
+    {
+        { .magic = "NTFS ", .len = 5, .sboff = 3 },
+        { NULL }
+    }
+};
Index: fstools-2015-02-25.1/libblkid-tiny/exfat.c
===================================================================
--- /dev/null
+++ fstools-2015-02-25.1/libblkid-tiny/exfat.c
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2010 Andrew Nayenko <resver@gmail.com>
+ *
+ * This file may be redistributed under the terms of the
+ * GNU Lesser General Public License.
+ */
+#include "superblocks.h"
+
+struct exfat_super_block
+{
+    uint8_t jump[3];
+    uint8_t oem_name[8];
+    uint8_t __unused1[53];
+    uint64_t block_start;
+    uint64_t block_count;
+    uint32_t fat_block_start;
+    uint32_t fat_block_count;
+    uint32_t cluster_block_start;
+    uint32_t cluster_count;
+    uint32_t rootdir_cluster;
+    uint8_t volume_serial[4];
+    struct
+    {
+        uint8_t minor;
+        uint8_t major;
+    } version;
+    uint16_t volume_state;
+    uint8_t block_bits;
+    uint8_t bpc_bits;
+    uint8_t fat_count;
+    uint8_t drive_no;
+    uint8_t allocated_percent;
+} __attribute__((__packed__));
+
+struct exfat_entry_label
+{
+    uint8_t type;
+    uint8_t length;
+    uint8_t name[30];
+} __attribute__((__packed__));
+
+#define BLOCK_SIZE(sb) (1 << (sb)->block_bits)
+#define CLUSTER_SIZE(sb) (BLOCK_SIZE(sb) << (sb)->bpc_bits)
+#define EXFAT_FIRST_DATA_CLUSTER 2
+#define EXFAT_LAST_DATA_CLUSTER 0xffffff6
+#define EXFAT_ENTRY_SIZE 32
+
+#define EXFAT_ENTRY_EOD 0x00
+#define EXFAT_ENTRY_LABEL 0x83
+
+static blkid_loff_t block_to_offset(const struct exfat_super_block *sb,
+                                    blkid_loff_t block)
+{
+    return (blkid_loff_t) block << sb->block_bits;
+}
+
+static blkid_loff_t cluster_to_block(const struct exfat_super_block *sb,
+                                     uint32_t cluster)
+{
+    return le32_to_cpu(sb->cluster_block_start) +
+           ((blkid_loff_t) (cluster - EXFAT_FIRST_DATA_CLUSTER)
+            << sb->bpc_bits);
+}
+
+static blkid_loff_t cluster_to_offset(const struct exfat_super_block *sb,
+                                      uint32_t cluster)
+{
+    return block_to_offset(sb, cluster_to_block(sb, cluster));
+}
+
+static uint32_t next_cluster(blkid_probe pr,
+                             const struct exfat_super_block *sb, uint32_t cluster)
+{
+    uint32_t *next;
+    blkid_loff_t fat_offset;
+
+    fat_offset = block_to_offset(sb, le32_to_cpu(sb->fat_block_start))
+                 + (blkid_loff_t) cluster * sizeof(cluster);
+    next = (uint32_t *) blkid_probe_get_buffer(pr, fat_offset,
+            sizeof(uint32_t));
+    if (!next)
+        return 0;
+    return le32_to_cpu(*next);
+}
+
+static struct exfat_entry_label *find_label(blkid_probe pr,
+        const struct exfat_super_block *sb)
+{
+    uint32_t cluster = le32_to_cpu(sb->rootdir_cluster);
+    blkid_loff_t offset = cluster_to_offset(sb, cluster);
+    uint8_t *entry;
+
+    for (;;)
+    {
+        entry = (uint8_t *) blkid_probe_get_buffer(pr, offset,
+                EXFAT_ENTRY_SIZE);
+        if (!entry)
+            return NULL;
+        if (entry[0] == EXFAT_ENTRY_EOD)
+            return NULL;
+        if (entry[0] == EXFAT_ENTRY_LABEL)
+            return (struct exfat_entry_label *) entry;
+        offset += EXFAT_ENTRY_SIZE;
+        if (offset % CLUSTER_SIZE(sb) == 0)
+        {
+            cluster = next_cluster(pr, sb, cluster);
+            if (cluster < EXFAT_FIRST_DATA_CLUSTER)
+                return NULL;
+            if (cluster > EXFAT_LAST_DATA_CLUSTER)
+                return NULL;
+            offset = cluster_to_offset(sb, cluster);
+        }
+    }
+}
+
+static int probe_exfat(blkid_probe pr, const struct blkid_idmag *mag)
+{
+    struct exfat_super_block *sb;
+    struct exfat_entry_label *label;
+
+    sb = blkid_probe_get_sb(pr, mag, struct exfat_super_block);
+    if (!sb)
+        return -1;
+
+    blkid_probe_sprintf_uuid(pr, sb->volume_serial, 4,
+                             "%02hhX%02hhX-%02hhX%02hhX",
+                             sb->volume_serial[3], sb->volume_serial[2],
+                             sb->volume_serial[1], sb->volume_serial[0]);
+
+    blkid_probe_sprintf_version(pr, "%u.%u",
+                                sb->version.major, sb->version.minor);
+
+    label = find_label(pr, sb);
+    if (label)
+        blkid_probe_set_utf8label(pr, label->name,
+                                  min(label->length * 2, 30), BLKID_ENC_UTF16LE);
+
+    return 0;
+}
+
+const struct blkid_idinfo exfat_idinfo =
+{
+    .name = "exfat",
+    .usage = BLKID_USAGE_FILESYSTEM,
+    .probefunc = probe_exfat,
+    .magics =
+    {
+        { .magic = "EXFAT   ", .len = 8, .sboff = 3 },
+        { NULL }
+    }
+};
Index: fstools-2015-02-25.1/libblkid-tiny/superblocks.h
===================================================================
--- fstools-2015-02-25.1.orig/libblkid-tiny/superblocks.h
+++ fstools-2015-02-25.1/libblkid-tiny/superblocks.h
@@ -87,6 +87,8 @@ extern int blkid_probe_strncpy_uuid(blki
 
 extern int blkid_probe_set_uuid(blkid_probe pr, unsigned char *uuid);
 extern int blkid_probe_set_uuid_as(blkid_probe pr, unsigned char *uuid, const char *name);
-
+extern size_t blkid_encode_to_utf8(int enc, unsigned char *dest, size_t len,
+		const unsigned char *src, size_t count);
+ 
 
 #endif /* _BLKID_SUPERBLOCKS_H */