3
0

fat.c 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338
  1. /*
  2. * volume_id - reads filesystem label and uuid
  3. *
  4. * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
  5. *
  6. * This library is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU Lesser General Public
  8. * License as published by the Free Software Foundation; either
  9. * version 2.1 of the License, or (at your option) any later version.
  10. *
  11. * This library is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14. * Lesser General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU Lesser General Public
  17. * License along with this library; if not, write to the Free Software
  18. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19. */
  20. #include "volume_id_internal.h"
  21. /* linux/msdos_fs.h says: */
  22. #define FAT12_MAX 0xff4
  23. #define FAT16_MAX 0xfff4
  24. #define FAT32_MAX 0x0ffffff6
  25. #define FAT_ATTR_VOLUME_ID 0x08
  26. #define FAT_ATTR_DIR 0x10
  27. #define FAT_ATTR_LONG_NAME 0x0f
  28. #define FAT_ATTR_MASK 0x3f
  29. #define FAT_ENTRY_FREE 0xe5
  30. struct vfat_super_block {
  31. uint8_t boot_jump[3];
  32. uint8_t sysid[8];
  33. uint16_t sector_size_bytes;
  34. uint8_t sectors_per_cluster;
  35. uint16_t reserved_sct;
  36. uint8_t fats;
  37. uint16_t dir_entries;
  38. uint16_t sectors;
  39. uint8_t media;
  40. uint16_t fat_length;
  41. uint16_t secs_track;
  42. uint16_t heads;
  43. uint32_t hidden;
  44. uint32_t total_sect;
  45. union {
  46. struct fat_super_block {
  47. uint8_t unknown[3];
  48. uint8_t serno[4];
  49. uint8_t label[11];
  50. uint8_t magic[8];
  51. uint8_t dummy2[192];
  52. uint8_t pmagic[2];
  53. } PACKED fat;
  54. struct fat32_super_block {
  55. uint32_t fat32_length;
  56. uint16_t flags;
  57. uint8_t version[2];
  58. uint32_t root_cluster;
  59. uint16_t insfo_sector;
  60. uint16_t backup_boot;
  61. uint16_t reserved2[6];
  62. uint8_t unknown[3];
  63. uint8_t serno[4];
  64. uint8_t label[11];
  65. uint8_t magic[8];
  66. uint8_t dummy2[164];
  67. uint8_t pmagic[2];
  68. } PACKED fat32;
  69. } PACKED type;
  70. } PACKED;
  71. struct vfat_dir_entry {
  72. uint8_t name[11];
  73. uint8_t attr;
  74. uint16_t time_creat;
  75. uint16_t date_creat;
  76. uint16_t time_acc;
  77. uint16_t date_acc;
  78. uint16_t cluster_high;
  79. uint16_t time_write;
  80. uint16_t date_write;
  81. uint16_t cluster_low;
  82. uint32_t size;
  83. } PACKED;
  84. static uint8_t *get_attr_volume_id(struct vfat_dir_entry *dir, int count)
  85. {
  86. for (;--count >= 0; dir++) {
  87. /* end marker */
  88. if (dir->name[0] == 0x00) {
  89. dbg("end of dir");
  90. break;
  91. }
  92. /* empty entry */
  93. if (dir->name[0] == FAT_ENTRY_FREE)
  94. continue;
  95. /* long name */
  96. if ((dir->attr & FAT_ATTR_MASK) == FAT_ATTR_LONG_NAME)
  97. continue;
  98. if ((dir->attr & (FAT_ATTR_VOLUME_ID | FAT_ATTR_DIR)) == FAT_ATTR_VOLUME_ID) {
  99. /* labels do not have file data */
  100. if (dir->cluster_high != 0 || dir->cluster_low != 0)
  101. continue;
  102. dbg("found ATTR_VOLUME_ID id in root dir");
  103. return dir->name;
  104. }
  105. dbg("skip dir entry");
  106. }
  107. return NULL;
  108. }
  109. int FAST_FUNC volume_id_probe_vfat(struct volume_id *id /*,uint64_t fat_partition_off*/)
  110. {
  111. #define fat_partition_off ((uint64_t)0)
  112. struct vfat_super_block *vs;
  113. struct vfat_dir_entry *dir;
  114. uint16_t sector_size_bytes;
  115. uint16_t dir_entries;
  116. uint32_t sect_count;
  117. uint16_t reserved_sct;
  118. uint32_t fat_size_sct;
  119. uint32_t root_cluster;
  120. uint32_t dir_size_sct;
  121. uint32_t cluster_count;
  122. uint64_t root_start_off;
  123. uint32_t start_data_sct;
  124. uint8_t *buf;
  125. uint32_t buf_size;
  126. uint8_t *label = NULL;
  127. uint32_t next_cluster;
  128. int maxloop;
  129. dbg("probing at offset 0x%llx", (unsigned long long) fat_partition_off);
  130. vs = volume_id_get_buffer(id, fat_partition_off, 0x200);
  131. if (vs == NULL)
  132. return -1;
  133. /* believe only that's fat, don't trust the version
  134. * the cluster_count will tell us
  135. */
  136. if (memcmp(vs->sysid, "NTFS", 4) == 0)
  137. return -1;
  138. if (memcmp(vs->type.fat32.magic, "MSWIN", 5) == 0)
  139. goto valid;
  140. if (memcmp(vs->type.fat32.magic, "FAT32 ", 8) == 0)
  141. goto valid;
  142. if (memcmp(vs->type.fat.magic, "FAT16 ", 8) == 0)
  143. goto valid;
  144. if (memcmp(vs->type.fat.magic, "MSDOS", 5) == 0)
  145. goto valid;
  146. if (memcmp(vs->type.fat.magic, "FAT12 ", 8) == 0)
  147. goto valid;
  148. /*
  149. * There are old floppies out there without a magic, so we check
  150. * for well known values and guess if it's a fat volume
  151. */
  152. /* boot jump address check */
  153. if ((vs->boot_jump[0] != 0xeb || vs->boot_jump[2] != 0x90)
  154. && vs->boot_jump[0] != 0xe9
  155. ) {
  156. return -1;
  157. }
  158. /* heads check */
  159. if (vs->heads == 0)
  160. return -1;
  161. /* cluster size check */
  162. if (vs->sectors_per_cluster == 0
  163. || (vs->sectors_per_cluster & (vs->sectors_per_cluster-1))
  164. ) {
  165. return -1;
  166. }
  167. /* media check */
  168. if (vs->media < 0xf8 && vs->media != 0xf0)
  169. return -1;
  170. /* fat count*/
  171. if (vs->fats != 2)
  172. return -1;
  173. valid:
  174. /* sector size check */
  175. sector_size_bytes = le16_to_cpu(vs->sector_size_bytes);
  176. if (sector_size_bytes != 0x200 && sector_size_bytes != 0x400
  177. && sector_size_bytes != 0x800 && sector_size_bytes != 0x1000
  178. ) {
  179. return -1;
  180. }
  181. dbg("sector_size_bytes 0x%x", sector_size_bytes);
  182. dbg("sectors_per_cluster 0x%x", vs->sectors_per_cluster);
  183. reserved_sct = le16_to_cpu(vs->reserved_sct);
  184. dbg("reserved_sct 0x%x", reserved_sct);
  185. sect_count = le16_to_cpu(vs->sectors);
  186. if (sect_count == 0)
  187. sect_count = le32_to_cpu(vs->total_sect);
  188. dbg("sect_count 0x%x", sect_count);
  189. fat_size_sct = le16_to_cpu(vs->fat_length);
  190. if (fat_size_sct == 0)
  191. fat_size_sct = le32_to_cpu(vs->type.fat32.fat32_length);
  192. fat_size_sct *= vs->fats;
  193. dbg("fat_size_sct 0x%x", fat_size_sct);
  194. dir_entries = le16_to_cpu(vs->dir_entries);
  195. dir_size_sct = ((dir_entries * sizeof(struct vfat_dir_entry)) +
  196. (sector_size_bytes-1)) / sector_size_bytes;
  197. dbg("dir_size_sct 0x%x", dir_size_sct);
  198. cluster_count = sect_count - (reserved_sct + fat_size_sct + dir_size_sct);
  199. cluster_count /= vs->sectors_per_cluster;
  200. dbg("cluster_count 0x%x", cluster_count);
  201. // if (cluster_count < FAT12_MAX) {
  202. // strcpy(id->type_version, "FAT12");
  203. // } else if (cluster_count < FAT16_MAX) {
  204. // strcpy(id->type_version, "FAT16");
  205. // } else {
  206. // strcpy(id->type_version, "FAT32");
  207. // goto fat32;
  208. // }
  209. if (cluster_count >= FAT16_MAX)
  210. goto fat32;
  211. /* the label may be an attribute in the root directory */
  212. root_start_off = (reserved_sct + fat_size_sct) * sector_size_bytes;
  213. dbg("root dir start 0x%llx", (unsigned long long) root_start_off);
  214. dbg("expected entries 0x%x", dir_entries);
  215. buf_size = dir_entries * sizeof(struct vfat_dir_entry);
  216. buf = volume_id_get_buffer(id, fat_partition_off + root_start_off, buf_size);
  217. if (buf == NULL)
  218. goto ret;
  219. label = get_attr_volume_id((struct vfat_dir_entry*) buf, dir_entries);
  220. vs = volume_id_get_buffer(id, fat_partition_off, 0x200);
  221. if (vs == NULL)
  222. return -1;
  223. if (label != NULL && memcmp(label, "NO NAME ", 11) != 0) {
  224. // volume_id_set_label_raw(id, label, 11);
  225. volume_id_set_label_string(id, label, 11);
  226. } else if (memcmp(vs->type.fat.label, "NO NAME ", 11) != 0) {
  227. // volume_id_set_label_raw(id, vs->type.fat.label, 11);
  228. volume_id_set_label_string(id, vs->type.fat.label, 11);
  229. }
  230. volume_id_set_uuid(id, vs->type.fat.serno, UUID_DOS);
  231. goto ret;
  232. fat32:
  233. /* FAT32 root dir is a cluster chain like any other directory */
  234. buf_size = vs->sectors_per_cluster * sector_size_bytes;
  235. root_cluster = le32_to_cpu(vs->type.fat32.root_cluster);
  236. start_data_sct = reserved_sct + fat_size_sct;
  237. next_cluster = root_cluster;
  238. maxloop = 100;
  239. while (--maxloop) {
  240. uint64_t next_off_sct;
  241. uint64_t next_off;
  242. uint64_t fat_entry_off;
  243. int count;
  244. dbg("next_cluster 0x%x", (unsigned)next_cluster);
  245. next_off_sct = (uint64_t)(next_cluster - 2) * vs->sectors_per_cluster;
  246. next_off = (start_data_sct + next_off_sct) * sector_size_bytes;
  247. dbg("cluster offset 0x%llx", (unsigned long long) next_off);
  248. /* get cluster */
  249. buf = volume_id_get_buffer(id, fat_partition_off + next_off, buf_size);
  250. if (buf == NULL)
  251. goto ret;
  252. dir = (struct vfat_dir_entry*) buf;
  253. count = buf_size / sizeof(struct vfat_dir_entry);
  254. dbg("expected entries 0x%x", count);
  255. label = get_attr_volume_id(dir, count);
  256. if (label)
  257. break;
  258. /* get FAT entry */
  259. fat_entry_off = (reserved_sct * sector_size_bytes) + (next_cluster * sizeof(uint32_t));
  260. dbg("fat_entry_off 0x%llx", (unsigned long long)fat_entry_off);
  261. buf = volume_id_get_buffer(id, fat_partition_off + fat_entry_off, buf_size);
  262. if (buf == NULL)
  263. goto ret;
  264. /* set next cluster */
  265. next_cluster = le32_to_cpu(*(uint32_t*)buf) & 0x0fffffff;
  266. if (next_cluster < 2 || next_cluster > FAT32_MAX)
  267. break;
  268. }
  269. if (maxloop == 0)
  270. dbg("reached maximum follow count of root cluster chain, give up");
  271. vs = volume_id_get_buffer(id, fat_partition_off, 0x200);
  272. if (vs == NULL)
  273. return -1;
  274. if (label != NULL && memcmp(label, "NO NAME ", 11) != 0) {
  275. // volume_id_set_label_raw(id, label, 11);
  276. volume_id_set_label_string(id, label, 11);
  277. } else if (memcmp(vs->type.fat32.label, "NO NAME ", 11) != 0) {
  278. // volume_id_set_label_raw(id, vs->type.fat32.label, 11);
  279. volume_id_set_label_string(id, vs->type.fat32.label, 11);
  280. }
  281. volume_id_set_uuid(id, vs->type.fat32.serno, UUID_DOS);
  282. ret:
  283. // volume_id_set_usage(id, VOLUME_ID_FILESYSTEM);
  284. // id->type = "vfat";
  285. return 0;
  286. }