/*
File: fat.c
Copyright (C) 1998-2007 Christophe GRENIER <grenier@cgsecurity.org>
This software is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
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,
but WITHOUT ANY WARRANTY; without even the implied warranty of
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, write the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <ctype.h>
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_TIME_H
#include <time.h>
#endif
#include "types.h"
#include "common.h"
#include "fat.h"
#include "lang.h"
#include "fnctdsk.h"
#include "testdisk.h"
#include "intrf.h"
#include "intrfn.h"
#include "log.h"
static int set_FAT_info(disk_t *disk_car, const struct fat_boot_sector *fat_header, partition_t *partition,const int debug);
static void fat_set_part_name(partition_t *partition,const unsigned char *src,const int max_size);
static int log_fat_info(const struct fat_boot_sector*fh1, const upart_type_t upart_type, const unsigned int sector_size);
static void fat_set_part_name(partition_t *partition,const unsigned char *src,const int max_size)
{
int i;
for(i=0;(i<max_size) && (src[i]!=(char)0);i++)
partition->name[i]=src[i];
partition->name[i--]='\0';
for(;(i>=0) && (src[i]==' ');i--);
partition->name[i+1]='\0';
}
static int log_fat_info(const struct fat_boot_sector*fh1, const upart_type_t upart_type, const unsigned int sector_size)
{
log_info("sector_size %u\n", fat_sector_size(fh1));
log_info("cluster_size %u\n", fh1->cluster_size);
log_info("reserved %u\n", le16(fh1->reserved));
log_info("fats %u\n", fh1->fats);
log_info("dir_entries %u\n", get_dir_entries(fh1));
log_info("sectors %u\n", sectors(fh1));
log_info("media %02X\n", fh1->media);
log_info("fat_length %u\n", le16(fh1->fat_length));
log_info("secs_track %u\n", le16(fh1->secs_track));
log_info("heads %u\n", le16(fh1->heads));
log_info("hidden %u\n", (unsigned int)le32(fh1->hidden));
log_info("total_sect %u\n", (unsigned int)le32(fh1->total_sect));
if(upart_type==UP_FAT32)
{
log_info("fat32_length %u\n", (unsigned int)le32(fh1->fat32_length));
log_info("flags %04X\n", le16(fh1->flags));
log_info("version %u.%u\n", fh1->version[0], fh1->version[1]);
log_info("root_cluster %u\n", (unsigned int)le32(fh1->root_cluster));
log_info("info_sector %u\n", le16(fh1->info_sector));
log_info("backup_boot %u\n", le16(fh1->backup_boot));
if(fat32_get_free_count((const unsigned char*)fh1,sector_size)==0xFFFFFFFF)
log_info("free_count uninitialised\n");
else
log_info("free_count %lu\n",fat32_get_free_count((const unsigned char*)fh1,sector_size));
if(fat32_get_next_free((const unsigned char*)fh1,sector_size)==0xFFFFFFFF)
log_info("next_free uninitialised\n");
else
log_info("next_free %lu\n",fat32_get_next_free((const unsigned char*)fh1,sector_size));
}
return 0;
}
int dump_fat_info(const struct fat_boot_sector*fh1, const upart_type_t upart_type, const unsigned int sector_size)
{
switch(upart_type)
{
case UP_FAT12:
wdoprintf(stdscr,"FAT : 12\n");
break;
case UP_FAT16:
wdoprintf(stdscr,"FAT : 16\n");
break;
case UP_FAT32:
wdoprintf(stdscr,"FAT : 32\n");
break;
default:
wdoprintf(stdscr,"Not a FAT\n");
return 0;
}
wdoprintf(stdscr,"cluster_size %u\n", fh1->cluster_size);
wdoprintf(stdscr,"reserved %u\n", le16(fh1->reserved));
if(sectors(fh1)!=0)
wdoprintf(stdscr,"sectors %u\n", sectors(fh1));
if(le32(fh1->total_sect)!=0)
wdoprintf(stdscr,"total_sect %u\n", (unsigned int)le32(fh1->total_sect));
if(upart_type==UP_FAT32)
{
wdoprintf(stdscr,"fat32_length %u\n", (unsigned int)le32(fh1->fat32_length));
wdoprintf(stdscr,"root_cluster %u\n", (unsigned int)le32(fh1->root_cluster));
wdoprintf(stdscr,"flags %04X\n", le16(fh1->flags));
wdoprintf(stdscr,"version %u.%u\n", fh1->version[0], fh1->version[1]);
wdoprintf(stdscr,"root_cluster %u\n", (unsigned int)le32(fh1->root_cluster));
wdoprintf(stdscr,"info_sector %u\n", le16(fh1->info_sector));
wdoprintf(stdscr,"backup_boot %u\n", le16(fh1->backup_boot));
if(fat32_get_free_count((const unsigned char*)fh1,sector_size)==0xFFFFFFFF)
wdoprintf(stdscr,"free_count uninitialised\n");
else
wdoprintf(stdscr,"free_count %lu\n",fat32_get_free_count((const unsigned char*)fh1,sector_size));
if(fat32_get_next_free((const unsigned char*)fh1,sector_size)==0xFFFFFFFF)
wdoprintf(stdscr,"next_free uninitialised\n");
else
wdoprintf(stdscr,"next_free %lu\n",fat32_get_next_free((const unsigned char*)fh1,sector_size));
} else {
wdoprintf(stdscr,"fat_length %u\n", le16(fh1->fat_length));
wdoprintf(stdscr,"dir_entries %u\n", get_dir_entries(fh1));
}
return 0;
}
int dump_2fat_info(const struct fat_boot_sector*fh1, const struct fat_boot_sector*fh2, const upart_type_t upart_type, const unsigned int sector_size)
{
switch(upart_type)
{
case UP_FAT12:
wdoprintf(stdscr,"FAT : 12\n");
break;
case UP_FAT16:
wdoprintf(stdscr,"FAT : 16\n");
break;
case UP_FAT32:
wdoprintf(stdscr,"FAT : 32\n");
break;
default:
wdoprintf(stdscr,"Not a FAT\n");
return 0;
}
wdoprintf(stdscr,"cluster_size %u %u\n", fh1->cluster_size, fh2->cluster_size);
wdoprintf(stdscr,"reserved %u %u\n", le16(fh1->reserved),le16(fh2->reserved));
if(sectors(fh1)!=0 || sectors(fh2)!=0)
wdoprintf(stdscr,"sectors %u %u\n", sectors(fh1), sectors(fh2));
if(le32(fh1->total_sect)!=0 || le32(fh2->total_sect)!=0)
wdoprintf(stdscr,"total_sect %u %u\n", (unsigned int)le32(fh1->total_sect), (unsigned int)le32(fh2->total_sect));
if(upart_type==UP_FAT32)
{
wdoprintf(stdscr,"fat32_length %u %u\n", (unsigned int)le16(fh1->fat32_length), (unsigned int)le16(fh2->fat32_length));
wdoprintf(stdscr,"root_cluster %u %u\n", (unsigned int)le32(fh1->root_cluster), (unsigned int)le32(fh2->root_cluster));
wdoprintf(stdscr,"free_count ");
if(fat32_get_free_count((const unsigned char*)fh1,sector_size)==0xFFFFFFFF)
wdoprintf(stdscr,"uninitialised ");
else
wdoprintf(stdscr,"%lu ",fat32_get_free_count((const unsigned char*)fh1,sector_size));
if(fat32_get_free_count((const unsigned char*)fh2,sector_size)==0xFFFFFFFF)
wdoprintf(stdscr,"uninitialised\n");
else
wdoprintf(stdscr,"%lu\n",fat32_get_free_count((const unsigned char*)fh2,sector_size));
wdoprintf(stdscr,"next_free ");
if(fat32_get_next_free((const unsigned char*)fh1,sector_size)==0xFFFFFFFF)
wdoprintf(stdscr,"uninitialised ");
else
wdoprintf(stdscr,"%lu ",fat32_get_next_free((const unsigned char*)fh1,sector_size));
if(fat32_get_next_free((const unsigned char*)fh2,sector_size)==0xFFFFFFFF)
wdoprintf(stdscr,"uninitialised\n");
else
wdoprintf(stdscr,"%lu\n",fat32_get_next_free((const unsigned char*)fh2,sector_size));
} else {
wdoprintf(stdscr,"fat_length %u %u\n", le16(fh1->fat_length), le16(fh2->fat_length));
wdoprintf(stdscr,"dir_entries %u %u\n", get_dir_entries(fh1), get_dir_entries(fh2));
}
return 0;
}
int log_fat2_dump(const struct fat_boot_sector*fh1, const struct fat_boot_sector*fh2, const upart_type_t upart_type, const unsigned int sector_size)
{
switch(upart_type)
{
case UP_FAT12:
log_info("\nFAT12\n");
break;
case UP_FAT16:
log_info("\nFAT16\n");
break;
case UP_FAT32:
log_info("\nFAT32\n");
break;
default:
return 1;
}
log_info("sector_size %u %u\n", fat_sector_size(fh1),fat_sector_size(fh2));
log_info("cluster_size %u %u\n", fh1->cluster_size,fh2->cluster_size);
log_info("reserved %u %u\n", le16(fh1->reserved),le16(fh2->reserved));
log_info("fats %u %u\n", fh1->fats,fh2->fats);
log_info("dir_entries %u %u\n", get_dir_entries(fh1),get_dir_entries(fh2));
log_info("sectors %u %u\n", sectors(fh1),sectors(fh2));
log_info("media %02X %02X\n", fh1->media,fh2->media);
log_info("fat_length %u %u\n", le16(fh1->fat_length),le16(fh2->fat_length));
log_info("secs_track %u %u\n", le16(fh1->secs_track),le16(fh2->secs_track));
log_info("heads %u %u\n", le16(fh1->heads),le16(fh2->heads));
log_info("hidden %u %u\n", (unsigned int)le32(fh1->hidden),(unsigned int)le32(fh2->hidden));
log_info("total_sect %u %u\n", (unsigned int)le32(fh1->total_sect),(unsigned int)le32(fh2->total_sect));
if(upart_type==UP_FAT32)
{
log_info("fat32_length %u %u\n", (unsigned int)le32(fh1->fat32_length),(unsigned int)le32(fh2->fat32_length));
log_info("flags %04X %04X\n", le16(fh1->flags),le16(fh2->flags));
log_info("version %u.%u %u.%u\n", fh1->version[0], fh1->version[1],fh2->version[0], fh2->version[1]);
log_info("root_cluster %u %u\n", (unsigned int)le32(fh1->root_cluster),(unsigned int)le32(fh2->root_cluster));
log_info("info_sector %u %u\n", le16(fh1->info_sector),le16(fh2->info_sector));
log_info("backup_boot %u %u\n", le16(fh1->backup_boot),le16(fh2->backup_boot));
log_info("free_count ");
if(fat32_get_free_count((const unsigned char*)fh1,sector_size)==0xFFFFFFFF)
log_info("uninitialised ");
else
log_info("%lu ",fat32_get_free_count((const unsigned char*)fh1,sector_size));
if(fat32_get_free_count((const unsigned char*)fh2,sector_size)==0xFFFFFFFF)
log_info("uninitialised");
else
log_info("%lu",fat32_get_free_count((const unsigned char*)fh2,sector_size));
log_info("\nnext_free ");
if(fat32_get_next_free((const unsigned char*)fh1,sector_size)==0xFFFFFFFF)
log_info("uninitialised ");
else
log_info("%lu ",fat32_get_next_free((const unsigned char*)fh1,sector_size));
if(fat32_get_next_free((const unsigned char*)fh2,sector_size)==0xFFFFFFFF)
log_info("uninitialised\n");
else
log_info("%lu\n",fat32_get_next_free((const unsigned char*)fh2,sector_size));
}
return 0;
}
int check_FAT(disk_t *disk_car,partition_t *partition,const int debug)
{
unsigned char *buffer;
buffer=MALLOC(3*disk_car->sector_size);
if(disk_car->read(disk_car,3*disk_car->sector_size, buffer, partition->part_offset)!=0)
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_RERR);
log_error(msg_CHKFAT_RERR);
free(buffer);
return 1;
}
if(test_FAT(disk_car,(const struct fat_boot_sector *)buffer,partition,debug,0)!=0)
{
if(debug>0)
{
log_error("\n\ntest_FAT()\n");
log_partition(disk_car,partition);
log_fat_info((const struct fat_boot_sector*)buffer, partition->upart_type,disk_car->sector_size);
}
free(buffer);
return 1;
}
set_FAT_info(disk_car,(const struct fat_boot_sector *)buffer,partition,debug);
/* aff_buffer(BUFFER_ADD,"Ok\n"); */
free(buffer);
return 0;
}
static int set_FAT_info(disk_t *disk_car, const struct fat_boot_sector *fat_header, partition_t *partition,const int debug)
{
const char*buffer=(const char*)fat_header;
partition->name[0]='\0';
switch(partition->upart_type)
{
case UP_FAT12:
snprintf(partition->info,sizeof(partition->info),"FAT12");
if(buffer[38]==0x29) /* BS_BootSig */
{
fat_set_part_name(partition,((const unsigned char*)fat_header)+FAT1X_PART_NAME,11);
if(check_volume_name(partition->name,11))
partition->name[0]='\0';
}
break;
case UP_FAT16:
snprintf(partition->info,sizeof(partition->info),"FAT16");
if(buffer[38]==0x29) /* BS_BootSig */
{
fat_set_part_name(partition,((const unsigned char*)fat_header)+FAT1X_PART_NAME,11);
if(check_volume_name(partition->name,11))
partition->name[0]='\0';
}
break;
case UP_FAT32:
snprintf(partition->info,sizeof(partition->info),"FAT32");
fat32_set_part_name(disk_car,partition,fat_header);
break;
default:
log_critical("set_FAT_info unknown upart_type\n");
return 1;
}
return 0;
}
unsigned int get_next_cluster(disk_t *disk_car,const partition_t *partition, const upart_type_t upart_type,const int offset, const unsigned int cluster)
{
/* Offset can be offset to FAT1 or to FAT2 */
/* log_trace("get_next_cluster(upart_type=%u,offset=%u,cluster=%u\n",upart_type,offset,cluster); */
switch(upart_type)
{
case UP_FAT12:
{
unsigned char buffer[0x400];
unsigned long int offset_s,offset_o;
offset_s=(cluster+cluster/2)/disk_car->sector_size;
offset_o=(cluster+cluster/2)%disk_car->sector_size;
if(disk_car->read(disk_car,sizeof(buffer), &buffer, partition->part_offset+(uint64_t)(offset+offset_s)*disk_car->sector_size)!=0)
{
log_error("get_next_cluster read error\n"); return 0;
}
if((cluster&1)!=0)
return le16((*((uint16_t*)&buffer[offset_o])))>>4;
else
return le16(*((uint16_t*)&buffer[offset_o]))&0x0FFF;
}
case UP_FAT16:
{
unsigned char buffer[disk_car->sector_size];
const uint16_t *p16=(const uint16_t*)&buffer;
unsigned long int offset_s,offset_o;
offset_s=cluster/(disk_car->sector_size/2);
offset_o=cluster%(disk_car->sector_size/2);
if(disk_car->read(disk_car,disk_car->sector_size, &buffer, partition->part_offset+(uint64_t)(offset+offset_s)*disk_car->sector_size)!=0)
{
log_error("get_next_cluster read error\n"); return 0;
}
return le16(p16[offset_o]);
}
case UP_FAT32:
{
unsigned char buffer[disk_car->sector_size];
const uint32_t *p32;
unsigned long int offset_s,offset_o;
p32=(const uint32_t*)&buffer;
offset_s=cluster/(disk_car->sector_size/4);
offset_o=cluster%(disk_car->sector_size/4);
if(disk_car->read(disk_car,disk_car->sector_size, &buffer, partition->part_offset+(uint64_t)(offset+offset_s)*disk_car->sector_size)!=0)
{
log_error("get_next_cluster read error\n"); return 0;
}
/* FAT32 used 28 bits, the 4 high bits are reserved
* 0x00000000: free cluster
* 0x0FFFFFF7: bad cluster
* 0x0FFFFFF8+: EOC End of cluster
* */
return le32(p32[offset_o])&0xFFFFFFF;
}
default:
log_critical("fat.c get_next_cluster unknown fat type\n");
return 0;
}
}
int set_next_cluster(disk_t *disk_car,const partition_t *partition, const upart_type_t upart_type,const int offset, const unsigned int cluster, const unsigned int next_cluster)
{
unsigned char buffer[0x400];
unsigned long int offset_s,offset_o;
/* Offset can be offset to FAT1 or to FAT2 */
/* log_trace("set_next_cluster(upart_type=%u,offset=%u,cluster=%u,next_cluster=%u)\n",upart_type,offset,cluster,next_cluster); */
switch(upart_type)
{
case UP_FAT12:
{
offset_s=(cluster+cluster/2)/disk_car->sector_size;
offset_o=(cluster+cluster/2)%disk_car->sector_size;
if(disk_car->read(disk_car,sizeof(buffer), &buffer, partition->part_offset+(uint64_t)(offset+offset_s)*disk_car->sector_size)!=0)
{
log_error("set_next_cluster read error\n"); return 1;
}
if((cluster&1)!=0)
(*((uint16_t*)&buffer[offset_o]))=le16((next_cluster<<4) | (le16(*((uint16_t*)&buffer[offset_o]))&0xF));
else
(*((uint16_t*)&buffer[offset_o]))=le16((next_cluster) | (le16(*((uint16_t*)&buffer[offset_o]))&0xF000));
}
break;
case UP_FAT16:
{
uint16_t *p16=(uint16_t*)&buffer;
offset_s=cluster/(disk_car->sector_size/2);
offset_o=cluster%(disk_car->sector_size/2);
if(disk_car->read(disk_car,sizeof(buffer), &buffer, partition->part_offset+(uint64_t)(offset+offset_s)*disk_car->sector_size)!=0)
{
log_error("set_next_cluster read error\n"); return 1;
}
p16[offset_o]=le16(next_cluster);
}
break;
case UP_FAT32:
{
uint32_t *p32=(uint32_t*)&buffer;
offset_s=cluster/(disk_car->sector_size/4);
offset_o=cluster%(disk_car->sector_size/4);
if(disk_car->read(disk_car,sizeof(buffer), &buffer, partition->part_offset+(uint64_t)(offset+offset_s)*disk_car->sector_size)!=0)
{
log_error("set_next_cluster read error\n");
return 1;
}
/* FAT32 used 28 bits, the 4 high bits are reserved
* 0x00000000: free cluster
* 0x0FFFFFF7: bad cluster
* 0x0FFFFFF8+: EOC End of cluster
* */
p32[offset_o]=le32(next_cluster);
}
break;
default:
log_critical("fat.c set_next_cluster unknown fat type\n");
return 1;
}
if(disk_car->write(disk_car,sizeof(buffer), &buffer, partition->part_offset+(uint64_t)(offset+offset_s)*disk_car->sector_size)!=0)
{
display_message("Write error: set_next_cluster write error\n");
return 1;
}
return 0;
}
unsigned int fat32_get_prev_cluster(disk_t *disk_car,const partition_t *partition, const unsigned int fat_offset, const unsigned int cluster, const unsigned int no_of_cluster)
{
unsigned char buffer[disk_car->sector_size];
const uint32_t *p32;
uint64_t hd_offset=partition->part_offset+fat_offset*disk_car->sector_size;
unsigned int prev_cluster;
p32=(const uint32_t*)&buffer;
for(prev_cluster=2;prev_cluster<=no_of_cluster+1;prev_cluster++)
{
unsigned int offset_s,offset_o;
offset_s=prev_cluster/(disk_car->sector_size/4);
offset_o=prev_cluster%(disk_car->sector_size/4);
if((offset_o==0)||(prev_cluster==2))
{
if(disk_car->read(disk_car,disk_car->sector_size, &buffer, hd_offset)!=0)
{
log_error("fat32_get_prev_cluster error\n"); return 0;
}
hd_offset+=disk_car->sector_size;
}
if((le32(p32[offset_o]) & 0xFFFFFFF) ==cluster)
return prev_cluster;
}
return 0;
}
unsigned int get_prev_cluster(disk_t *disk_car,const partition_t *partition, const upart_type_t upart_type,const int offset, const unsigned int cluster, const unsigned int no_of_cluster)
{
unsigned int prev_cluster;
for(prev_cluster=2;prev_cluster<=no_of_cluster+1;prev_cluster++)
{
if(get_next_cluster(disk_car,partition,upart_type,offset, prev_cluster)==cluster)
return prev_cluster;
}
return 0;
}
int test_FAT(disk_t *disk_car,const struct fat_boot_sector *fat_header, partition_t *partition,const int debug, const int dump_ind)
{
upart_type_t upart_type=UP_UNK;
unsigned long int start_fat1,start_fat2,start_rootdir,start_data,no_of_cluster,fat_length,fat_length_calc,part_size,end_data;
const char *buffer=(const char*)fat_header;
if(debug>1)
{
log_trace("test_FAT\n");
log_partition(disk_car,partition);
}
if(le16(fat_header->marker)!=0xAA55)
{
aff_buffer(BUFFER_ADD,"test_FAT : Boot sector doesn't have the endmark 0xAA55\n");
log_error("test_FAT : Boot sector doesn't have the endmark 0xAA55\n");
return 1;
}
if(dump_ind!=0)
dump_ncurses(fat_header,DEFAULT_SECTOR_SIZE);
if(!((fat_header->ignored[0]==0xeb && fat_header->ignored[2]==0x90)||fat_header->ignored[0]==0xe9))
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_BAD_JUMP);
log_error(msg_CHKFAT_BAD_JUMP);
return 1;
}
if(fat_sector_size(fat_header)!=disk_car->sector_size)
{
aff_buffer(BUFFER_ADD,"check_FAT: Incorrect number of bytes per sector %u (FAT) != %u (HD)\n",fat_sector_size(fat_header),disk_car->sector_size);
log_error("check_FAT: Incorrect number of bytes per sector %u (FAT) != %u (HD)\n",fat_sector_size(fat_header),disk_car->sector_size);
return 1;
}
switch(fat_header->cluster_size)
{
case 1:
case 2:
case 4:
case 8:
case 16:
case 32:
case 64:
case 128:
break;
default:
aff_buffer(BUFFER_ADD,msg_CHKFAT_SECT_CLUSTER);
log_error(msg_CHKFAT_SECT_CLUSTER);
return 1;
}
switch(fat_header->fats)
{
case 1:
aff_buffer(BUFFER_ADD,"check_FAT: Unusual, only one FAT\n");
log_warning("check_FAT: Unusual, only one FAT\n");
break;
case 2:
break;
default:
aff_buffer(BUFFER_ADD,"check_FAT: Bad number %u of FAT\n", fat_header->fats);
log_error("check_FAT: Bad number %u of FAT\n", fat_header->fats);
return 1;
}
if(fat_header->media!=0xF0 && fat_header->media<0xF8)
{ /* Legal values are 0xF0, 0xF8-0xFF */
aff_buffer(BUFFER_ADD,"check_FAT: Bad media descriptor (0x%2x!=0xf8)\n",fat_header->media);
log_error("check_FAT: Bad media descriptor (0x%2x!=0xf8)\n",fat_header->media);
return 1;
}
if(fat_header->media!=0xF8)
{ /* the only value I have ever seen is 0xF8 */
aff_buffer(BUFFER_ADD,"check_FAT: Unusual media descriptor (0x%2x!=0xf8)\n",fat_header->media);
log_warning("check_FAT: Unusual media descriptor (0x%2x!=0xf8)\n",fat_header->media);
}
fat_length=le16(fat_header->fat_length)>0?le16(fat_header->fat_length):le32(fat_header->fat32_length);
part_size=(sectors(fat_header)>0?sectors(fat_header):fat_header->total_sect);
start_fat1=le16(fat_header->reserved);
start_fat2=start_fat1+(fat_header->fats>1?fat_length:0);
start_data=start_fat1+fat_header->fats*fat_length+(get_dir_entries(fat_header)*32+disk_car->sector_size-1)/disk_car->sector_size;
no_of_cluster=(part_size-start_data)/fat_header->cluster_size;
end_data=start_data+no_of_cluster*fat_header->cluster_size-1;
if(debug>1)
{
log_info("number of cluster = %lu\n",no_of_cluster);
}
if(no_of_cluster<4085)
{
upart_type=UP_FAT12;
if(debug>0)
{
log_info("FAT12\n");
}
if(sectors(fat_header)==0)
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_SIZE);
log_error(msg_CHKFAT_SIZE);
}
if(le16(fat_header->reserved)!=1)
{
aff_buffer(BUFFER_ADD,"check_FAT: Unusual number of reserved sectors %u (FAT), should be 1.\n",le16(fat_header->reserved));
log_warning("check_FAT: Unusual number of reserved sectors %u (FAT), should be 1.\n",le16(fat_header->reserved));
}
if((get_dir_entries(fat_header)==0)||(get_dir_entries(fat_header)%16!=0))
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_ENTRY);
log_error(msg_CHKFAT_ENTRY);
return 1;
}
if((le16(fat_header->fat_length)>256)||(le16(fat_header->fat_length)==0))
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_SECTPFAT);
log_error(msg_CHKFAT_SECTPFAT);
return 1;
}
start_rootdir=start_fat2+fat_length;
fat_length_calc=((no_of_cluster+2+disk_car->sector_size*2/3-1)*3/2/disk_car->sector_size);
partition->upart_type=UP_FAT12;
if(memcmp(buffer+FAT_NAME1,"FAT12 ",8)!=0) /* 2 Mo max */
{
aff_buffer(BUFFER_ADD,"Should be marked as FAT12\n");
log_warning("Should be marked as FAT12\n");
}
}
else if(no_of_cluster<65525)
{
upart_type=UP_FAT16;
if(debug>0)
{
log_info("FAT16\n");
}
if(le16(fat_header->reserved)!=1)
{
aff_buffer(BUFFER_ADD,"check_FAT: Unusual number of reserved sectors %u (FAT), should be 1.\n",le16(fat_header->reserved));
log_warning("check_FAT: Unusual number of reserved sectors %u (FAT), should be 1.\n",le16(fat_header->reserved));
}
if(le16(fat_header->fat_length)==0)
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_SECTPFAT);
log_error(msg_CHKFAT_SECTPFAT);
return 1;
}
if((get_dir_entries(fat_header)==0)||(get_dir_entries(fat_header)%16!=0))
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_ENTRY);
log_error(msg_CHKFAT_ENTRY);
return 1;
}
start_rootdir=start_fat2+fat_length;
fat_length_calc=((no_of_cluster+2+disk_car->sector_size/2-1)*2/disk_car->sector_size);
partition->upart_type=UP_FAT16;
if(memcmp(buffer+FAT_NAME1,"FAT16 ",8)!=0)
{
aff_buffer(BUFFER_ADD,"Should be marked as FAT16\n");
log_warning("Should be marked as FAT16\n");
}
}
else
{
upart_type=UP_FAT32;
if(debug>0)
{
log_info("FAT32\n");
}
if(sectors(fat_header)!=0)
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_SIZE);
log_error(msg_CHKFAT_SIZE);
return 1;
}
if(get_dir_entries(fat_header)!=0)
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_ENTRY);
log_error(msg_CHKFAT_ENTRY);
return 1;
}
if((fat_header->version[0]!=0) || (fat_header->version[1]!=0))
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_BADFAT32VERSION);
log_error(msg_CHKFAT_BADFAT32VERSION);
}
if((le32(fat_header->root_cluster)<2) ||(le32(fat_header->root_cluster)>=2+no_of_cluster))
{
aff_buffer(BUFFER_ADD,"Bad root_cluster\n");
log_error("Bad root_cluster\n");
return 1;
}
start_rootdir=start_data+(le32(fat_header->root_cluster)-2)*fat_header->cluster_size;
fat_length_calc=((no_of_cluster+2+disk_car->sector_size/4-1)*4/disk_car->sector_size);
partition->upart_type=UP_FAT32;
if(memcmp(buffer+FAT_NAME2,"FAT32 ",8)!=0)
{
aff_buffer(BUFFER_ADD,"Should be marked as FAT32\n");
log_warning("Should be marked as FAT32\n");
}
}
if(partition->part_size>0)
{
if(part_size>partition->part_size/disk_car->sector_size)
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_SIZE);
log_error("test_FAT size boot_sector %lu > partition %lu\n",(long unsigned)part_size,(long unsigned)(partition->part_size/disk_car->sector_size));
return 1;
}
else
{
if((debug>0) && (part_size!=partition->part_size))
log_warning("test_FAT size boot_sector %lu, partition %lu\n",(long unsigned)part_size,(long unsigned)(partition->part_size/disk_car->sector_size));
}
}
if(debug>0)
{
log_info("FAT1 : %lu-%lu\n",start_fat1,start_fat1+fat_length-1);
log_info("FAT2 : %lu-%lu\n",start_fat2,start_fat2+fat_length-1);
log_info("start_rootdir : %lu",start_rootdir);
if(partition->upart_type==UP_FAT32)
log_info(" root cluster : %u",(unsigned int)le32(fat_header->root_cluster));
log_info("\nData : %lu-%lu\n",start_data,end_data);
log_info("sectors : %lu\n",part_size);
log_info("cluster_size : %u\n",fat_header->cluster_size);
log_info("no_of_cluster : %lu (2 - %lu)\n", no_of_cluster,no_of_cluster+1);
log_info("fat_length %lu calculated %lu\n",fat_length,fat_length_calc);
}
if(fat_length<fat_length_calc)
{
aff_buffer(BUFFER_ADD,msg_CHKFAT_SECTPFAT);
return 1;
}
if(fat_header->fats>1)
comp_FAT(disk_car,partition,fat_length,le16(fat_header->reserved));
if(le16(fat_header->heads)!=disk_car->CHS.head+1)
{
aff_buffer(BUFFER_ADD,"Warning: Incorrect number of heads/cylinder %u (FAT) != %u (HD)\n",le16(fat_header->heads),disk_car->CHS.head+1);
log_warning("heads/cylinder %u (FAT) != %u (HD)\n",le16(fat_header->heads),disk_car->CHS.head+1);
}
if(le16(fat_header->secs_track)!=disk_car->CHS.sector)
{
aff_buffer(BUFFER_ADD,"Warning: Incorrect number of sectors per track %u (FAT) != %u (HD)\n",le16(fat_header->secs_track),disk_car->CHS.sector);
log_warning("sect/track %u (FAT) != %u (HD)\n",le16(fat_header->secs_track),disk_car->CHS.sector);
}
return 0;
}
int comp_FAT(disk_t *disk_car,const partition_t *partition,const unsigned long int taille,const unsigned long int sect_res)
{
/*
return 0 if FATs match
*/
unsigned int reste=taille;
unsigned int read_size;
uint64_t hd_offset, hd_offset2;
unsigned char *buffer, *buffer2;
buffer=(unsigned char *)MALLOC(NBR_SECT*disk_car->sector_size);
buffer2=(unsigned char *)MALLOC(NBR_SECT*disk_car->sector_size);
hd_offset=partition->part_offset+(uint64_t)sect_res*disk_car->sector_size;
hd_offset2=hd_offset+(uint64_t)taille*disk_car->sector_size;
if(reste>1000) reste=1000; /* Quick check ! */
while(reste)
{
read_size=reste>NBR_SECT?NBR_SECT:reste;
reste-=read_size;
if(disk_car->read(disk_car,read_size*disk_car->sector_size, buffer, hd_offset))
{ log_error(msg_CHKFAT_RERR);
return 1;}
if(disk_car->read(disk_car,read_size*disk_car->sector_size, buffer2, hd_offset2))
{ log_error(msg_CHKFAT_RERR);
return 1;}
if(memcmp(buffer,buffer2,disk_car->sector_size*read_size)!=0)
{
log_error("FAT differs, FAT sectors=%lu-%lu/%lu\n",
(unsigned long) ((hd_offset-partition->part_offset)/disk_car->sector_size-sect_res),
(unsigned long) ((hd_offset-partition->part_offset)/disk_car->sector_size-sect_res+read_size),
taille);
free(buffer2);
free(buffer);
return 1;
}
hd_offset+=read_size*disk_car->sector_size;
hd_offset2+=read_size*disk_car->sector_size;
}
free(buffer2);
free(buffer);
return 0;
}
unsigned int fat_sector_size(const struct fat_boot_sector *fat_header)
{ return (fat_header->sector_size[1]<<8)+fat_header->sector_size[0]; }
unsigned int get_dir_entries(const struct fat_boot_sector *fat_header)
{ return (fat_header->dir_entries[1]<<8)+fat_header->dir_entries[0]; }
unsigned int sectors(const struct fat_boot_sector *fat_header)
{ return (fat_header->sectors[1]<<8)+fat_header->sectors[0]; }
unsigned long int fat32_get_free_count(const unsigned char *boot_fat32, const unsigned int sector_size)
{
return (boot_fat32[sector_size+0x1E8+3]<<24)+(boot_fat32[sector_size+0x1E8+2]<<16)+(boot_fat32[sector_size+0x1E8+1]<<8)+boot_fat32[sector_size+0x1E8];
}
unsigned long int fat32_get_next_free(const unsigned char *boot_fat32, const unsigned int sector_size)
{
return (boot_fat32[sector_size+0x1EC+3]<<24)+(boot_fat32[sector_size+0x1EC+2]<<16)+(boot_fat32[sector_size+0x1EC+1]<<8)+boot_fat32[sector_size+0x1EC];
}
int recover_FAT(disk_t *disk_car, const struct fat_boot_sector*fat_header, partition_t *partition, const int debug, const int dump_ind, const int backup)
{
const char*buffer=(const char*)fat_header;
if(le16(fat_header->marker)==0xAA55
&& (fat_header->ignored[0]==0xeb || fat_header->ignored[0]==0xe9)
&& (fat_header->fats==1 || fat_header->fats==2))
{
if(test_FAT(disk_car, fat_header, partition, debug, dump_ind))
return 1;
/* test_FAT has set partition->upart_type */
switch(partition->upart_type)
{
case UP_FAT12:
if(debug||dump_ind)
{
log_info("\nFAT12 at %u/%u/%u\n", offset2cylinder(disk_car,partition->part_offset),offset2head(disk_car,partition->part_offset),offset2sector(disk_car,partition->part_offset));
}
partition->part_size=(uint64_t)sectors(fat_header)*fat_sector_size(fat_header);
partition->part_type_i386=P_12FAT;
break;
case UP_FAT16:
if(debug||dump_ind)
{
log_info("\nFAT16 at %u/%u/%u\n", offset2cylinder(disk_car,partition->part_offset),offset2head(disk_car,partition->part_offset),offset2sector(disk_car,partition->part_offset));
}
if(sectors(fat_header)!=0)
{
partition->part_size=(uint64_t)sectors(fat_header)*fat_sector_size(fat_header);
partition->part_type_i386=P_16FAT;
} else {
partition->part_size=(uint64_t)le32(fat_header->total_sect)*fat_sector_size(fat_header);
if(offset2cylinder(disk_car,partition->part_offset+partition->part_size-1)<=1024)
partition->part_type_i386=P_16FATBD;
else
partition->part_type_i386=P_16FATBD_LBA;
}
break;
case UP_FAT32:
if(debug||dump_ind)
{
log_info("\nFAT32 at %u/%u/%u\n", offset2cylinder(disk_car,partition->part_offset),offset2head(disk_car,partition->part_offset),offset2sector(disk_car,partition->part_offset));
}
if(sectors(fat_header)!=0)
partition->part_size=(uint64_t)sectors(fat_header)*fat_sector_size(fat_header);
else
partition->part_size=(uint64_t)le32(fat_header->total_sect)*fat_sector_size(fat_header);
if(offset2cylinder(disk_car,partition->part_offset+partition->part_size-1)<=1024)
partition->part_type_i386=P_32FAT;
else
partition->part_type_i386=P_32FAT_LBA;
if(backup)
{
partition->boot_sector=6;
partition->part_offset-=6*512; /* backup sector ... */
}
break;
default:
return 1;
}
set_FAT_info(disk_car,fat_header,partition,debug);
return 0;
} /* fin marqueur de fin =:-) */
return 1;
}
int fat32_set_part_name(disk_t *disk_car, partition_t *partition, const struct fat_boot_sector*fat_header)
{
partition->name[0]='\0';
if((fat_header->cluster_size>0)&&(fat_header->cluster_size<=128))
{
unsigned char *buffer=(unsigned char*)MALLOC(fat_header->cluster_size*disk_car->sector_size);
if(disk_car->read(disk_car,fat_header->cluster_size*disk_car->sector_size, buffer, partition->part_offset+(uint64_t)(le16(fat_header->reserved)+fat_header->fats*le32(fat_header->fat32_length)+(le32(fat_header->root_cluster)-2)*fat_header->cluster_size)*disk_car->sector_size))
{
log_error("fat32_set_part_name() cannot read FAT32 root cluster.\n");
}
else
{
int i;
int stop=0;
for(i=0;(i<16*fat_header->cluster_size)&&(stop==0);i++)
{ /* Test attribut volume name and check if the volume name is erased or not */
if(((buffer[i*0x20+0xB] & ATTR_EXT) !=ATTR_EXT) && ((buffer[i*0x20+0xB] & ATTR_VOLUME) !=0) && (buffer[i*0x20]!=0xE5))
{
/* dump_ncurses(&buffer[i*0x20],0x20); */
fat_set_part_name(partition,&buffer[i*0x20],11);
if(check_volume_name(partition->name,11))
partition->name[0]='\0';
}
if(buffer[i*0x20]==0)
{
stop=1;
}
}
}
free(buffer);
}
if(partition->name[0]=='\0')
{
log_info("set_FAT_info: name from BS used\n");
fat_set_part_name(partition,((const unsigned char*)fat_header)+FAT32_PART_NAME,11);
if(check_volume_name(partition->name,11))
partition->name[0]='\0';
}
return 0;
}
int check_HPFS(disk_t *disk_car,partition_t *partition,const int debug)
{
unsigned char buffer[disk_car->sector_size];
if(disk_car->read(disk_car,disk_car->sector_size, &buffer, partition->part_offset)!=0)
{
aff_buffer(BUFFER_ADD,"check_HPFS: Read error\n");
log_error("check_HPFS: Read error\n");
return 1;
}
if(test_HPFS(disk_car,(const struct fat_boot_sector *)buffer,partition,debug,0)!=0)
{
if(debug>0)
{
log_info("\n\ntest_HPFS()\n");
log_partition(disk_car,partition);
}
return 1;
}
return 0;
}
int test_HPFS(disk_t *disk_car,const struct fat_boot_sector *fat_header, partition_t *partition,const int debug, const int dump_ind)
{
const char*buffer=(const char*)fat_header;
if(le16(fat_header->marker)==0xAA55)
{
if(memcmp(buffer+OS2_NAME,"IBM",3)==0)
{ /* D'apres une analyse de OS2 sur systeme FAT...
FAT_NAME1=FAT
*/
if(debug||dump_ind)
{
log_info("\nHPFS maybe at %u/%u/%u\n", offset2cylinder(disk_car,partition->part_offset),offset2head(disk_car,partition->part_offset),offset2sector(disk_car,partition->part_offset));
}
if(dump_ind)
dump_ncurses(buffer,DEFAULT_SECTOR_SIZE);
if(sectors(fat_header)!=0)
partition->part_size=(uint64_t)sectors(fat_header)*fat_sector_size(fat_header);
else
partition->part_size=(uint64_t)le32(fat_header->total_sect)*fat_sector_size(fat_header);
partition->upart_type=UP_HPFS;
return 0;
}
} /* fin marqueur de fin :)) */
return 1;
}
int recover_HPFS(disk_t *disk_car,const struct fat_boot_sector*fat_header, partition_t *partition, const int debug, const int dump_ind)
{
if(test_HPFS(disk_car,fat_header,partition,debug,0)!=0)
return 1;
partition->part_type_i386=P_HPFS;
partition->name[0]='\0';
partition->info[0]='\0';
return 0;
}
int check_OS2MB(disk_t *disk_car,partition_t *partition,const int debug)
{
unsigned char buffer[disk_car->sector_size];
if(disk_car->read(disk_car,disk_car->sector_size, &buffer, partition->part_offset)!=0)
{
aff_buffer(BUFFER_ADD,"check_OS2MB: Read error\n");
log_error("check_OS2MB: Read error\n");
return 1;
}
if(test_OS2MB(disk_car,(const struct fat_boot_sector *)buffer,partition,debug,0)!=0)
{
if(debug>0)
{
log_info("\n\ntest_OS2MB()\n");
log_partition(disk_car,partition);
}
return 1;
}
return 0;
}
int recover_OS2MB(disk_t *disk_car, const struct fat_boot_sector*fat_header, partition_t *partition, const int debug, const int dump_ind)
{
if(test_OS2MB(disk_car, fat_header, partition, debug, dump_ind))
return 1;
partition->part_size=(uint64_t)(disk_car->CHS.head+1) * disk_car->CHS.sector*disk_car->sector_size; /* 1 cylinder */
partition->part_type_i386=P_OS2MB;
partition->name[0]='\0';
partition->info[0]='\0';
return 0;
}
int test_OS2MB(disk_t *disk_car,const struct fat_boot_sector *fat_header, partition_t *partition,const int debug, const int dump_ind)
{
const char*buffer=(const char*)fat_header;
if(le16(fat_header->marker)==0xAA55 && memcmp(buffer+FAT_NAME1,"FAT ",8)==0)
{
if(debug||dump_ind)
{
log_info("\nMarker (0xAA55) at %u/%u/%u\n", offset2cylinder(disk_car,partition->part_offset),offset2head(disk_car,partition->part_offset),offset2sector(disk_car,partition->part_offset));
}
if(dump_ind)
dump_ncurses(buffer,DEFAULT_SECTOR_SIZE);
partition->upart_type=UP_OS2MB;
return 0;
}
return 1;
}
int is_fat(const partition_t *partition)
{
return (is_fat12(partition)||is_fat16(partition)||is_fat32(partition));
}
int is_part_fat(const partition_t *partition)
{
return (is_part_fat12(partition)||is_part_fat16(partition)||is_part_fat32(partition));
}
int is_part_fat12(const partition_t *partition)
{
switch(partition->part_type_i386)
{
case P_12FAT:
case P_12FATH:
return 1;
default:
return 0;
}
}
int is_fat12(const partition_t *partition)
{
return (is_part_fat12(partition) || partition->upart_type==UP_FAT12);
}
int is_part_fat16(const partition_t *partition)
{
switch(partition->part_type_i386)
{
case P_16FAT:
case P_16FATH:
case P_16FATBD_LBA:
case P_16FATBD:
case P_16FATBDH:
case P_16FATBD_LBAH:
return 1;
default:
return 0;
}
}
int is_fat16(const partition_t *partition)
{
return (is_part_fat16(partition) || partition->upart_type==UP_FAT16);
}
int is_part_fat32(const partition_t *partition)
{
switch(partition->part_type_i386)
{
case P_32FAT:
case P_32FAT_LBA:
case P_32FATH:
case P_32FAT_LBAH:
return 1;
default:
return 0;
}
}
int is_fat32(const partition_t *partition)
{
return (is_part_fat32(partition) || partition->upart_type==UP_FAT32);
}
int fat32_free_info(disk_t *disk_car,const partition_t *partition, const unsigned int fat_offset, const unsigned int no_of_cluster, unsigned int *next_free, unsigned int*free_count)
{
unsigned char *buffer;
const uint32_t *p32;
unsigned int prev_cluster;
uint64_t hd_offset=partition->part_offset+(uint64_t)fat_offset*disk_car->sector_size;
buffer=(unsigned char *)MALLOC(disk_car->sector_size);
p32=(const uint32_t*)buffer;
*next_free=0;
*free_count=0;
for(prev_cluster=2;prev_cluster<=no_of_cluster+1;prev_cluster++)
{
unsigned long int cluster;
unsigned int offset_s,offset_o;
offset_s=prev_cluster/(disk_car->sector_size/4);
offset_o=prev_cluster%(disk_car->sector_size/4);
if((offset_o==0)||(prev_cluster==2))
{
if(disk_car->read(disk_car,disk_car->sector_size, buffer, hd_offset)!=0)
{
log_error("fat32_free_info read error\n");
*next_free=0xFFFFFFFF;
*free_count=0xFFFFFFFF;
return 1;
}
hd_offset+=disk_car->sector_size;
}
cluster=le32(p32[offset_o]) & 0xFFFFFFF;
if(cluster==0)
{
(*free_count)++;
if(*next_free==0)
*next_free=prev_cluster;
}
}
log_info("next_free %u, free_count %u\n",*next_free,*free_count);
free(buffer);
return 0;
}
syntax highlighted by Code2HTML, v. 0.9.1