fatdetect.c 2.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120
  1. /* FAT boot-sector + MBR detection (FAT12/16/32). */
  2. #include "fatdetect.h"
  3. static unsigned int rd16(const unsigned char *p)
  4. {
  5. return (unsigned int)p[0] | ((unsigned int)p[1] << 8);
  6. }
  7. static unsigned int rd32(const unsigned char *p)
  8. {
  9. return (unsigned int)p[0] | ((unsigned int)p[1] << 8) |
  10. ((unsigned int)p[2] << 16) | ((unsigned int)p[3] << 24);
  11. }
  12. static int is_pow2(unsigned int v)
  13. {
  14. return v != 0 && (v & (v - 1)) == 0;
  15. }
  16. int fat_detect(const unsigned char *boot, fat_info_t *info)
  17. {
  18. unsigned int bps, spc, reserved, num_fats, root_entries;
  19. unsigned int total, sec_per_fat16, sec_per_fat32, sec_per_fat;
  20. unsigned int root_dir_sectors, data_sectors, clusters;
  21. unsigned int label_off, i;
  22. if (boot[510] != 0x55 || boot[511] != 0xAA)
  23. return -1;
  24. bps = rd16(boot + 0x0B);
  25. if (bps != 512)
  26. return -1;
  27. spc = boot[0x0D];
  28. if (!is_pow2(spc) || spc > 128)
  29. return -1;
  30. reserved = rd16(boot + 0x0E);
  31. if (reserved < 1)
  32. return -1;
  33. num_fats = boot[0x10];
  34. if (num_fats < 1 || num_fats > 2)
  35. return -1;
  36. root_entries = rd16(boot + 0x11);
  37. total = rd16(boot + 0x13);
  38. if (total == 0)
  39. total = rd32(boot + 0x20);
  40. if (total == 0)
  41. return -1;
  42. sec_per_fat16 = rd16(boot + 0x16);
  43. sec_per_fat32 = rd32(boot + 0x24);
  44. sec_per_fat = sec_per_fat16 ? sec_per_fat16 : sec_per_fat32;
  45. if (sec_per_fat == 0)
  46. return -1;
  47. root_dir_sectors = (root_entries * 32 + bps - 1) / bps;
  48. if (total < reserved + num_fats * sec_per_fat + root_dir_sectors)
  49. return -1;
  50. data_sectors = total - reserved - num_fats * sec_per_fat - root_dir_sectors;
  51. if (data_sectors < spc)
  52. return -1;
  53. clusters = data_sectors / spc;
  54. if (clusters < 4085)
  55. info->type = FAT12;
  56. else if (clusters < 65525)
  57. info->type = FAT16;
  58. else
  59. info->type = FAT32;
  60. info->bytes_per_sector = bps;
  61. info->sectors_per_cluster = spc;
  62. info->total_sectors = total;
  63. info->cluster_count = clusters;
  64. /* Volume label (11 bytes): 0x2B for FAT12/16, 0x47 for FAT32. */
  65. label_off = (info->type == FAT32) ? 0x47 : 0x2B;
  66. for (i = 0; i < 11; i++)
  67. info->label[i] = (char)boot[label_off + i];
  68. info->label[11] = '\0';
  69. for (i = 11; i > 0 && (info->label[i - 1] == ' ' || info->label[i - 1] == '\0'); i--)
  70. ;
  71. info->label[i] = '\0';
  72. return 0;
  73. }
  74. int mbr_is_fat_type(unsigned char type)
  75. {
  76. switch (type) {
  77. case 0x01: case 0x04: case 0x06:
  78. case 0x0B: case 0x0C: case 0x0E:
  79. return 1;
  80. default:
  81. return 0;
  82. }
  83. }
  84. int mbr_parse(const unsigned char *mbr, mbr_part_t parts[4])
  85. {
  86. int n = 0, i;
  87. if (mbr[510] != 0x55 || mbr[511] != 0xAA)
  88. return 0;
  89. for (i = 0; i < 4; i++) {
  90. const unsigned char *e = mbr + 0x1BE + (unsigned int)i * 16;
  91. unsigned char type = e[4];
  92. if (type == 0)
  93. continue;
  94. parts[n].index = (unsigned char)i;
  95. parts[n].type = type;
  96. parts[n].start_lba = rd32(e + 8);
  97. parts[n].sectors = rd32(e + 12);
  98. parts[n].is_fat = mbr_is_fat_type(type);
  99. n++;
  100. }
  101. return n;
  102. }