chiark / gitweb /
volume_id: remove deprecated functions and bump major version
[elogind.git] / extras / volume_id / lib / fat.c
index 74336b4e6d0df79ca773e382d04d4f4ba5d6e7d3..759e106f6805c9d6399c64804f3df7badc4e56ac 100644 (file)
@@ -1,7 +1,8 @@
 /*
  * volume_id - reads filesystem label and uuid
  *
- * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2004-2007 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2007 Ryan Lortie <desrt@desrt.ca>
  *
  *     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
@@ -24,6 +25,7 @@
 #include <ctype.h>
 
 #include "libvolume_id.h"
+#include "libvolume_id-private.h"
 #include "util.h"
 
 #define FAT12_MAX                      0xff5
 #define FAT_ATTR_MASK                  0x3f
 #define FAT_ENTRY_FREE                 0xe5
 
+#define VFAT_LFN_SEQ_MASK              0x3f
+#define VFAT_LFN_SEQ_LAST              0x40
+#define VFAT_LFN_SEQ_MAX               20
+#define VFAT_LFN_CHARS_PER_ENTRY       (5 + 6 + 2)
+#define VFAT_LOWERCASE_NAME            0x10
+#define VFAT_LOWERCASE_EXT             0x08
+
 struct vfat_super_block {
        uint8_t         boot_jump[3];
        uint8_t         sysid[8];
@@ -63,7 +72,7 @@ struct vfat_super_block {
                        uint16_t        flags;
                        uint8_t         version[2];
                        uint32_t        root_cluster;
-                       uint16_t        insfo_sector;
+                       uint16_t        fsinfo_sector;
                        uint16_t        backup_boot;
                        uint16_t        reserved2[6];
                        uint8_t         unknown[3];
@@ -76,12 +85,22 @@ struct vfat_super_block {
        } PACKED type;
 } PACKED;
 
+struct fat32_fsinfo {
+       uint8_t signature1[4];
+       uint32_t reserved1[120];
+       uint8_t signature2[4];
+       uint32_t free_clusters;
+       uint32_t next_cluster;
+       uint32_t reserved2[4];
+} PACKED;
+
 struct vfat_dir_entry {
        uint8_t         name[11];
        uint8_t         attr;
+       uint8_t         lowercase;
+       uint8_t         fine_time_creat;
        uint16_t        time_creat;
        uint16_t        date_creat;
-       uint16_t        time_acc;
        uint16_t        date_acc;
        uint16_t        cluster_high;
        uint16_t        time_write;
@@ -90,14 +109,116 @@ struct vfat_dir_entry {
        uint32_t        size;
 } PACKED;
 
-static uint8_t *get_attr_volume_id(struct vfat_dir_entry *dir, unsigned int count)
+
+struct vfat_lfn_entry {
+       uint8_t         seq;
+       uint16_t        name0[5];
+       uint8_t         attr;
+       uint8_t         reserved;
+       uint8_t         cksum;
+       uint16_t        name1[6];
+       uint16_t        cluster;
+       uint16_t        name2[2];
+} PACKED;
+
+static uint8_t fat_lfn_checksum(const uint8_t name[11])
+{
+       uint8_t cksum = 0;
+       int i;
+
+       /* http://en.wikipedia.org/wiki/File_Allocation_Table */
+       for (i = 0; i < 11; i++)
+               cksum = ((cksum & 1) ? 0x80 : 0) + (cksum >> 1) + name[i];
+
+       return cksum;
+}
+
+static size_t fat_read_lfn(uint8_t *filename, size_t fnsize,
+                          struct vfat_dir_entry *dir,
+                          struct vfat_dir_entry *entry)
+{
+       uint8_t buffer[VFAT_LFN_SEQ_MAX * VFAT_LFN_CHARS_PER_ENTRY * 2];
+       uint8_t expected_seq = 1;
+       uint8_t cksum;
+       size_t len = 0;
+       size_t fnlen = 0;
+
+       cksum = fat_lfn_checksum(entry->name);
+
+       while (--entry >= dir) {
+               struct vfat_lfn_entry *lfn = (struct vfat_lfn_entry *) entry;
+
+               if (expected_seq > VFAT_LFN_SEQ_MAX)
+                       break;
+
+               if ((lfn->attr & FAT_ATTR_MASK) != FAT_ATTR_LONG_NAME)
+                       break;
+
+               if (lfn->cksum != cksum)
+                       break;
+
+               if ((lfn->seq & VFAT_LFN_SEQ_MASK) != expected_seq++)
+                       break;
+
+               if (lfn->cluster != 0)
+                       break;
+
+               /* extra paranoia -- should never happen */
+               if (len + sizeof(lfn->name0) + sizeof(lfn->name1) +
+                   sizeof(lfn->name2) > sizeof(buffer))
+                       break;
+
+               memcpy (&buffer[len], lfn->name0, sizeof(lfn->name0));
+               len += sizeof(lfn->name0);
+               memcpy (&buffer[len], lfn->name1, sizeof(lfn->name1));
+               len += sizeof(lfn->name1);
+               memcpy (&buffer[len], lfn->name2, sizeof(lfn->name2));
+               len += sizeof(lfn->name2);
+
+               if (lfn->seq & VFAT_LFN_SEQ_LAST) {
+                       fnlen = volume_id_set_unicode16(filename, fnsize, buffer, LE, len);
+                       break;
+               }
+       }
+
+       return fnlen;
+}
+
+static size_t fat_read_filename(uint8_t *filename, size_t fnsize,
+                               struct vfat_dir_entry *dir, struct vfat_dir_entry *entry)
+{
+       size_t len;
+       int i;
+
+       /* check if maybe we have LFN entries */
+       len = fat_read_lfn(filename, fnsize, dir, entry);
+       if (len > 0)
+               goto out;
+
+       /* else, read the normal 8.3 name */
+       for (i = 0; i < 11; i++) {
+               if (entry->lowercase & ((i < 8) ? VFAT_LOWERCASE_NAME : VFAT_LOWERCASE_EXT))
+                       filename[i] = tolower(entry->name[i]);
+               else
+                       filename[i] = entry->name[i];
+       }
+       len = 11;
+
+out:
+       filename[len] = '\0';
+       return len;
+}
+
+/* fills filename, returns string length */
+static size_t get_fat_attr_volume_id(uint8_t *filename, size_t fnsize,
+                                    struct vfat_dir_entry *dir, unsigned int count)
 {
        unsigned int i;
 
        for (i = 0; i < count; i++) {
                /* end marker */
                if (dir[i].name[0] == 0x00) {
-                       dbg("end of dir");
+                       dbg("end of dir\n");
                        break;
                }
 
@@ -114,20 +235,22 @@ static uint8_t *get_attr_volume_id(struct vfat_dir_entry *dir, unsigned int coun
                        if (dir[i].cluster_high != 0 || dir[i].cluster_low != 0)
                                continue;
 
-                       dbg("found ATTR_VOLUME_ID id in root dir");
-                       return dir[i].name;
+                       dbg("found ATTR_VOLUME_ID id in root dir\n");
+                       return fat_read_filename(filename, fnsize, dir, &dir[i]);
                }
 
-               dbg("skip dir entry");
+               dbg("skip dir entry\n");
        }
 
-       return NULL;
+       return 0;
 }
 
-int volume_id_probe_vfat(struct volume_id *id, uint64_t off)
+int volume_id_probe_vfat(struct volume_id *id, uint64_t off, uint64_t size)
 {
+       uint8_t filename[255 * 3];
        struct vfat_super_block *vs;
        struct vfat_dir_entry *dir;
+       struct fat32_fsinfo *fsinfo;
        uint16_t sector_size;
        uint16_t dir_entries;
        uint32_t sect_count;
@@ -141,24 +264,28 @@ int volume_id_probe_vfat(struct volume_id *id, uint64_t off)
        uint64_t root_start;
        uint32_t start_data_sect;
        uint16_t root_dir_entries;
+       uint16_t fsinfo_sect;
        uint8_t *buf;
        uint32_t buf_size;
-       uint8_t *label = NULL;
        uint32_t next;
        int maxloop;
+       size_t fnlen;
 
-       info("probing at offset 0x%llx", (unsigned long long) off);
+       info("probing at offset 0x%llx\n", (unsigned long long) off);
 
-       vs = (struct vfat_super_block *) volume_id_get_buffer(id, off, 0x200);
-       if (vs == NULL)
+       buf = volume_id_get_buffer(id, off, 0x400);
+       if (buf == NULL)
+               return -1;
+
+       /* check signature */
+       if (buf[510] != 0x55 || buf[511] != 0xaa)
                return -1;
 
-       /* believe only that's fat, don't trust the version
-        * the cluster_count will tell us
-        */
+       vs = (struct vfat_super_block *) buf;
        if (memcmp(vs->sysid, "NTFS", 4) == 0)
                return -1;
 
+       /* believe only that's fat, don't trust the version */
        if (memcmp(vs->type.fat32.magic, "MSWIN", 5) == 0)
                goto magic;
 
@@ -174,9 +301,7 @@ int volume_id_probe_vfat(struct volume_id *id, uint64_t off)
        if (memcmp(vs->type.fat.magic, "FAT12   ", 8) == 0)
                goto magic;
 
-       /* some old floppies don't have a magic, so we expect the boot code to match */
-
-       /* boot jump address check */
+       /* some old floppies don't have a magic, expect the boot jump address to match */
        if ((vs->boot_jump[0] != 0xeb || vs->boot_jump[2] != 0x90) &&
             vs->boot_jump[0] != 0xe9)
                return -1;
@@ -186,7 +311,7 @@ magic:
        if (!vs->reserved)
                return -1;
 
-       /* fat count*/
+       /* fat count */
        if (!vs->fats)
                return -1;
 
@@ -194,33 +319,32 @@ magic:
        if (vs->media < 0xf8 && vs->media != 0xf0)
                return -1;
 
-       /* cluster size check*/ 
+       /* cluster size check */
        if (vs->sectors_per_cluster == 0 ||
            (vs->sectors_per_cluster & (vs->sectors_per_cluster-1)))
                return -1;
 
        /* sector size check */
        sector_size = le16_to_cpu(vs->sector_size);
-       if (sector_size != 0x200 && sector_size != 0x400 &&
-           sector_size != 0x800 && sector_size != 0x1000)
+       if (sector_size == 0 || ((sector_size & (sector_size-1)) != 0))
                return -1;
 
-       dbg("sector_size 0x%x", sector_size);
-       dbg("sectors_per_cluster 0x%x", vs->sectors_per_cluster);
+       dbg("sector_size 0x%x\n", sector_size);
+       dbg("sectors_per_cluster 0x%x\n", vs->sectors_per_cluster);
 
        dir_entries = le16_to_cpu(vs->dir_entries);
        reserved = le16_to_cpu(vs->reserved);
-       dbg("reserved 0x%x", reserved);
+       dbg("reserved 0x%x\n", reserved);
 
        sect_count = le16_to_cpu(vs->sectors);
        if (sect_count == 0)
                sect_count = le32_to_cpu(vs->total_sect);
-       dbg("sect_count 0x%x", sect_count);
+       dbg("sect_count 0x%x\n", sect_count);
 
        fat_length = le16_to_cpu(vs->fat_length);
-       dbg("fat_length 0x%x", fat_length);
+       dbg("fat_length 0x%x\n", fat_length);
        fat32_length = le32_to_cpu(vs->type.fat32.fat32_length);
-       dbg("fat32_length 0x%x", fat32_length);
+       dbg("fat32_length 0x%x\n", fat32_length);
 
        if (fat_length)
                fat_size = fat_length * vs->fats;
@@ -228,15 +352,15 @@ magic:
                fat_size = fat32_length * vs->fats;
        else
                return -1;
-       dbg("fat_size 0x%x", fat_size);
+       dbg("fat_size 0x%x\n", fat_size);
 
        dir_size = ((dir_entries * sizeof(struct vfat_dir_entry)) +
                        (sector_size-1)) / sector_size;
-       dbg("dir_size 0x%x", dir_size);
+       dbg("dir_size 0x%x\n", dir_size);
 
        cluster_count = sect_count - (reserved + fat_size + dir_size);
        cluster_count /= vs->sectors_per_cluster;
-       dbg("cluster_count 0x%x", cluster_count);
+       dbg("cluster_count 0x%x\n", cluster_count);
 
        /* must be FAT32 */
        if (!fat_length && fat32_length)
@@ -252,9 +376,9 @@ magic:
 
        /* the label may be an attribute in the root directory */
        root_start = (reserved + fat_size) * sector_size;
-       dbg("root dir start 0x%llx", (unsigned long long) root_start);
+       dbg("root dir start 0x%llx\n", (unsigned long long) root_start);
        root_dir_entries = le16_to_cpu(vs->dir_entries);
-       dbg("expected entries 0x%x", root_dir_entries);
+       dbg("expected entries 0x%x\n", root_dir_entries);
 
        buf_size = root_dir_entries * sizeof(struct vfat_dir_entry);
        buf = volume_id_get_buffer(id, off + root_start, buf_size);
@@ -263,29 +387,44 @@ magic:
 
        dir = (struct vfat_dir_entry*) buf;
 
-       label = get_attr_volume_id(dir, root_dir_entries);
+       fnlen = get_fat_attr_volume_id(filename, sizeof(filename), dir, root_dir_entries);
 
        vs = (struct vfat_super_block *) volume_id_get_buffer(id, off, 0x200);
        if (vs == NULL)
                return -1;
 
-       if (label != NULL && memcmp(label, "NO NAME    ", 11) != 0) {
-               volume_id_set_label_raw(id, label, 11);
-               volume_id_set_label_string(id, label, 11);
+       if (fnlen > 0 && memcmp(filename, "NO NAME    ", 11) != 0) {
+               volume_id_set_label_raw(id, filename, fnlen);
+               volume_id_set_label_string(id, filename, fnlen);
        } else if (memcmp(vs->type.fat.label, "NO NAME    ", 11) != 0) {
                volume_id_set_label_raw(id, vs->type.fat.label, 11);
                volume_id_set_label_string(id, vs->type.fat.label, 11);
        }
-       volume_id_set_uuid(id, vs->type.fat.serno, UUID_DOS);
+       volume_id_set_uuid(id, vs->type.fat.serno, 0, UUID_DOS);
        goto found;
 
 fat32:
+       /* FAT32 should have a valid signature in the fsinfo block */
+       fsinfo_sect = le16_to_cpu(vs->type.fat32.fsinfo_sector);
+       buf = volume_id_get_buffer(id, off + (fsinfo_sect * sector_size), 0x200);
+       if (buf == NULL)
+               return -1;
+       fsinfo = (struct fat32_fsinfo *) buf;
+       if (memcmp(fsinfo->signature1, "\x52\x52\x61\x41", 4) != 0)
+               return -1;
+       if (memcmp(fsinfo->signature2, "\x72\x72\x41\x61", 4) != 0)
+               return -1 ;
+
+       vs = (struct vfat_super_block *) volume_id_get_buffer(id, off, 0x200);
+       if (vs == NULL)
+               return -1;
+
        strcpy(id->type_version, "FAT32");
 
        /* FAT32 root dir is a cluster chain like any other directory */
        buf_size = vs->sectors_per_cluster * sector_size;
        root_cluster = le32_to_cpu(vs->type.fat32.root_cluster);
-       dbg("root dir cluster %u", root_cluster);
+       dbg("root dir cluster %u\n", root_cluster);
        start_data_sect = reserved + fat_size;
 
        next = root_cluster;
@@ -296,10 +435,10 @@ fat32:
                uint64_t fat_entry_off;
                int count;
 
-               dbg("next cluster %u", next);
+               dbg("next cluster %u\n", next);
                next_sect_off = (next - 2) * vs->sectors_per_cluster;
                next_off = (start_data_sect + next_sect_off) * sector_size;
-               dbg("cluster offset 0x%llx", (unsigned long long) next_off);
+               dbg("cluster offset 0x%llx\n", (unsigned long long) next_off);
 
                /* get cluster */
                buf = volume_id_get_buffer(id, off + next_off, buf_size);
@@ -308,10 +447,10 @@ fat32:
 
                dir = (struct vfat_dir_entry*) buf;
                count = buf_size / sizeof(struct vfat_dir_entry);
-               dbg("expected entries 0x%x", count);
+               dbg("expected entries 0x%x\n", count);
 
-               label = get_attr_volume_id(dir, count);
-               if (label)
+               fnlen = get_fat_attr_volume_id(filename, sizeof(filename), dir, count);
+               if (fnlen > 0)
                        break;
 
                /* get FAT entry */
@@ -322,24 +461,24 @@ fat32:
 
                /* set next cluster */
                next = le32_to_cpu(*((uint32_t *) buf)) & 0x0fffffff;
-               if (next == 0)
+               if (next < 2 || next >= 0x0ffffff0)
                        break;
        }
        if (maxloop == 0)
-               dbg("reached maximum follow count of root cluster chain, give up");
+               dbg("reached maximum follow count of root cluster chain, give up\n");
 
        vs = (struct vfat_super_block *) volume_id_get_buffer(id, off, 0x200);
        if (vs == NULL)
                return -1;
 
-       if (label != NULL && memcmp(label, "NO NAME    ", 11) != 0) {
-               volume_id_set_label_raw(id, label, 11);
-               volume_id_set_label_string(id, label, 11);
+       if (fnlen > 0 && memcmp(filename, "NO NAME    ", 11) != 0) {
+               volume_id_set_label_raw(id, filename, fnlen);
+               volume_id_set_label_string(id, filename, fnlen);
        } else if (memcmp(vs->type.fat32.label, "NO NAME    ", 11) != 0) {
                volume_id_set_label_raw(id, vs->type.fat32.label, 11);
                volume_id_set_label_string(id, vs->type.fat32.label, 11);
        }
-       volume_id_set_uuid(id, vs->type.fat32.serno, UUID_DOS);
+       volume_id_set_uuid(id, vs->type.fat32.serno, 0, UUID_DOS);
 
 found:
        volume_id_set_usage(id, VOLUME_ID_FILESYSTEM);