Beispiel #1
0
int JudgeFAT(char *file_path, dbr_list* p_dbr, fat_boot_sector* fat)
{
	char sz_temp1[4] = {0};
	char sz_temp2[4] = {0};
	LARGE_INTEGER tmp1 = {0};
	LARGE_INTEGER tmp2 = {0};

	char flag[4] = {'\xf8', '\xff', '\xff', '\x0f'};

	DWORD readsize = 0;
	
	tmp1.QuadPart = p_dbr->ll_offset + (fat->reserved * SECTOR_SIZE);
	tmp2.QuadPart = p_dbr->ll_offset - ((fat->backup_boot + fat->reserved) * SECTOR_SIZE);

	if (!ReadFileOffset(file_path, tmp1.QuadPart, 4, sz_temp1, FILE_BEGIN))
		ErrorOut("ReadFile Error!\n");
	
	if (!memcmp(sz_temp1, flag, 4))
	{
		p_dbr->ll_start_sector = p_dbr->ll_offset / SECTOR_SIZE;
		return 1;
	}else
	{
		if (!ReadFileOffset(file_path, tmp2.QuadPart, 4, sz_temp2, FILE_BEGIN))
			ErrorOut("ReadFile Error!\n");

		if (!memcmp(sz_temp2, flag, 4))
		{
			p_dbr->ll_start_sector = p_dbr->ll_offset / SECTOR_SIZE - fat->backup_boot;
			p_dbr->n_is_org = 1; 
			return 1;
		}
	}
	return 0;
}
Beispiel #2
0
int JudgeMFT(char* file_path, dbr_list* p_dbr, ntfs_boot_sector* ntfs)
{

	char sz_temp1[4] = {0};
	char sz_temp2[4] = {0};
	DWORD readsize;
	LARGE_INTEGER tmp1 = {0};
	LARGE_INTEGER tmp2 = {0};
	tmp1.QuadPart = p_dbr->ll_offset + (ntfs->mft_lcn.QuadPart * ntfs->sectors_per_cluster * SECTOR_SIZE);
	tmp2.QuadPart = p_dbr->ll_offset - (ntfs->sectors_nbr * SECTOR_SIZE) + (ntfs->mft_lcn.QuadPart * ntfs->sectors_per_cluster * SECTOR_SIZE);

	if (!ReadFileOffset(file_path, tmp1.QuadPart, 4, sz_temp1, FILE_BEGIN))
		ErrorOut("ReadFile Error!\n");
	
	if (!memcmp(sz_temp1, "FILE", 4))
	{
		p_dbr->ll_start_sector = p_dbr->ll_offset / SECTOR_SIZE;
		return 1;
	}else
	{
		if (!ReadFileOffset(file_path, tmp2.QuadPart, 4, sz_temp2, FILE_BEGIN))
			ErrorOut("ReadFile Error!\n");
		
		if (!memcmp(sz_temp2, "FILE", 4))
		{
			p_dbr->ll_start_sector = p_dbr->ll_offset / SECTOR_SIZE - ntfs->sectors_nbr;
			p_dbr->n_is_org = 1;
			return 1;
		}
	}
	return 0;
}
Beispiel #3
0
  bool FileScanner::Read(ObjectFileRef& ref)
  {
    uint8_t    typeByte;
    FileOffset fileOffset;

    if (!(Read(typeByte) &&
          ReadFileOffset(fileOffset))) {
      return false;
    }

    ref.Set(fileOffset,(RefType)typeByte);

    return true;
  }
Beispiel #4
0
void HandleFile(char* file_path, rebuild_content_t* p_rebuild_list)
{
	char* sz_vhd_buf = (char*)malloc(SECTOR_SIZE);
	memset(sz_vhd_buf, 0, SECTOR_SIZE);

	rebuild_content_t* p_rebuild_tmp = NULL;
	char tmp[SECTOR_SIZE] = {0};

/////////////////////////////// Handle VHD
	hd_ftr* vhd;
	vhd = (hd_ftr*)data;
	LARGE_INTEGER offset = {0};
	DWORD readsize = 0;

	/*Set hd_ftr struct*/
	vhd->orig_size = 0;   // clear
	vhd->orig_size = g_ll_file_size - SECTOR_SIZE;
	vhd->orig_size = INT64_TO_NET(vhd->orig_size);
	vhd->curr_size = vhd->orig_size;
	vhd->checksum = 0;

	/*calc checksum*/
	unsigned int temp = 0;
	for (int i = 0; i < 512; i++)
	{
		temp += data[i];
	}
	vhd->checksum = htonl(~temp);
///////////////////////////////////////////


	for(p_rebuild_tmp = p_rebuild_list->p_next; p_rebuild_tmp != NULL;) 
	{
		if (!ReadFileOffset(file_path, p_rebuild_tmp->ll_offset, p_rebuild_tmp->n_size, tmp, FILE_BEGIN))
			ErrorOut("Backup Read Error!\n");
		
		if (!WriteFileOffset(file_path, p_rebuild_tmp->ll_offset, p_rebuild_tmp->n_size, p_rebuild_tmp->content, FILE_BEGIN))
			ErrorOut("Backup Write Error!\n");

		memcpy(p_rebuild_tmp->content, tmp, p_rebuild_tmp->n_size);       // BackUp SECTOR
		p_rebuild_tmp = p_rebuild_tmp->p_next;
	}

/////////////////////////////////////////////////// BackUp VHD
	ReadFileOffset(file_path, -SECTOR_SIZE, SECTOR_SIZE, sz_vhd_buf, FILE_END);
	
/////////////////////////////////////////////*	*/// Write VHD
	WriteFileOffset(file_path, -SECTOR_SIZE, SECTOR_SIZE, (char*)vhd, FILE_END);

	printf("WriteFile Success! You can mount it as vhd file now!\n");
 	system("pause");


////////////////////////// Restore SECTOR

	for(p_rebuild_tmp = p_rebuild_list->p_next; p_rebuild_tmp != NULL;) 
	{
		if (!ReadFileOffset(file_path, p_rebuild_tmp->ll_offset, p_rebuild_tmp->n_size, tmp, FILE_BEGIN))
			ErrorOut("Restore Read Error!\n");

		if (!WriteFileOffset(file_path, p_rebuild_tmp->ll_offset, p_rebuild_tmp->n_size, p_rebuild_tmp->content, FILE_BEGIN))
			ErrorOut("Restore Write Error!\n");
		memcpy(p_rebuild_tmp->content, tmp, p_rebuild_tmp->n_size);       // BackUp SECTOR
		p_rebuild_tmp = p_rebuild_tmp->p_next;
	}

///////////////////////// Restore VHD
	WriteFileOffset(file_path, -SECTOR_SIZE, SECTOR_SIZE, sz_vhd_buf, FILE_END);

	printf("Restore File Success!\n");
}