int interface_superblock(disk_t *disk_car,list_part_t *list_part, char**current_cmd)
{
const list_part_t *parts;
const partition_t *old_part=NULL;
#ifdef HAVE_NCURSES
struct MenuItem menuSuperblock[]=
{
{ 'P', "Previous",""},
{ 'N', "Next","" },
{ 'Q',"Quit","Return to Advanced menu"},
{ 0, NULL, NULL }
};
#endif
screen_buffer_reset();
#ifdef HAVE_NCURSES
aff_copy(stdscr);
wmove(stdscr,4,0);
wprintw(stdscr,"%s",disk_car->description(disk_car));
wmove(stdscr,5,0);
mvwaddstr(stdscr,6,0,msg_PART_HEADER_LONG);
#endif
for(parts=list_part;parts!=NULL;parts=parts->next)
{
const partition_t *partition=parts->part;
if(old_part==NULL ||
old_part->part_offset!=partition->part_offset ||
old_part->part_size!=partition->part_size ||
guid_cmp(old_part->part_type_gpt, partition->part_type_gpt)!=0 ||
old_part->part_type_i386!=partition->part_type_i386 ||
old_part->part_type_sun!=partition->part_type_sun ||
old_part->part_type_mac!=partition->part_type_mac ||
old_part->upart_type!=partition->upart_type)
{
aff_part_buffer(AFF_PART_BASE, disk_car, partition);
old_part=partition;
}
if(partition->blocksize!=0)
screen_buffer_add("superblock %lu, blocksize=%u [%s]\n",
(long unsigned)(partition->sb_offset/partition->blocksize),
partition->blocksize, partition->fsname);
}
if(list_part!=NULL)
{
const partition_t *partition=list_part->part;
screen_buffer_add("\n");
screen_buffer_add("To repair the filesystem using alternate superblock, run\n");
screen_buffer_add("fsck.ext%u -p -b superblock -B blocksize device\n",
(partition->upart_type==UP_EXT2?2:
(partition->upart_type==UP_EXT3?3:4)));
}
screen_buffer_to_log();
if(*current_cmd==NULL)
{
log_flush();
#ifdef HAVE_NCURSES
screen_buffer_display(stdscr,"",menuSuperblock);
#endif
}
return 0;
}
static void change_part_type_ncurses(const disk_t *disk_car,partition_t *partition)
{
partition_t *new_partition;
char response[100];
int size=0;
int i;
unsigned int last[3], done = 0, next = 0;
struct part_name_struct part_name[0x100];
struct MenuItem menuType[]=
{
{ 'P', "Previous",""},
{ 'N', "Next","" },
{ 'Q', "Proceed","Go set the partition type"},
{ 0, NULL, NULL }
};
if(partition->arch->set_part_type==NULL)
return ;
/* Create an index of all partition type except Intel extended */
new_partition=partition_new(NULL);
dup_partition_t(new_partition,partition);
for(i=0;i<=0xFF;i++)
{
if(partition->arch->set_part_type(new_partition,i)==0)
{
part_name[size].name=new_partition->arch->get_partition_typename(new_partition);
if(part_name[size].name!=NULL)
part_name[size++].index=i;
}
}
free(new_partition);
/* Display the list of partition type in 3 columns */
screen_buffer_reset();
screen_buffer_add("List of partition type\n");
for (i = 2; i >= 0; i--)
last[2 - i] = done += (size + i - done) / (i + 1);
i = done = 0;
while (done < last[0])
{
screen_buffer_add( "%02x %-20s%c", part_name[next].index, part_name[next].name,(i==2 ? '\n' : ' '));
next = last[i++] + done;
if (i > 2 || next >= last[i]) {
i = 0;
next = ++done;
}
}
/* Ask for the new partition type*/
aff_copy(stdscr);
wmove(stdscr,4,0);
aff_part(stdscr,AFF_PART_ORDER|AFF_PART_STATUS,disk_car,partition);
screen_buffer_display(stdscr,"",menuType);
wmove(stdscr,LINES-2,0);
wclrtoeol(stdscr);
wprintw(stdscr,"New partition type [current %02x] ? ",partition->arch->get_part_type(partition));
if (get_string(stdscr, response, sizeof(response), NULL) > 0) {
int tmp_val = strtol(response, NULL, 16);
partition->arch->set_part_type(partition,tmp_val);
}
}
static int check_part_gpt(disk_t *disk, const int verbose,partition_t *partition, const int saveheader)
{
int ret=0;
unsigned int old_levels;
old_levels=log_set_levels(0);
if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_MS_BASIC_DATA)==0 ||
guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_MS_RESERVED)==0)
{
ret=check_FAT(disk,partition,verbose);
if(ret!=0)
ret=check_EXFAT(disk, partition);
if(ret!=0)
ret=check_NTFS(disk,partition,verbose,0);
if(ret!=0)
ret=check_ReFS(disk, partition);
if(ret!=0)
ret=check_linux(disk, partition, verbose);
if(ret!=0)
screen_buffer_add("No FAT, NTFS, ext2, JFS, Reiser, cramfs or XFS marker\n");
}
else if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_LINUX_RAID)==0)
{
ret=check_MD(disk, partition, verbose);
if(ret!=0)
screen_buffer_add("Invalid RAID superblock\n");
}
else if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_LINUX_LVM)==0)
{
ret=check_LVM(disk, partition, verbose);
if(ret!=0)
ret=check_LVM2(disk, partition, verbose);
if(ret!=0)
screen_buffer_add("No LVM or LVM2 structure\n");
}
else if(guid_cmp(partition->part_type_gpt, GPT_ENT_TYPE_MAC_HFS)==0)
{
ret=check_HFS(disk, partition, verbose);
if(ret!=0)
ret=check_HFSP(disk, partition, verbose);
if(ret!=0)
screen_buffer_add("No HFS or HFS+ structure\n");
}
log_set_levels(old_levels);
if(ret!=0)
{
log_error("check_part_gpt failed for partition\n");
log_partition(disk, partition);
aff_part_buffer(AFF_PART_ORDER|AFF_PART_STATUS,disk,partition);
if(saveheader>0)
{
save_header(disk, partition, verbose);
}
}
return ret;
}
int check_FAT(disk_t *disk_car,partition_t *partition,const int verbose)
{
unsigned char *buffer;
buffer=(unsigned char *)MALLOC(3*disk_car->sector_size);
if((unsigned)disk_car->pread(disk_car, buffer, 3 * disk_car->sector_size, partition->part_offset) != 3 * disk_car->sector_size)
{
screen_buffer_add("check_FAT: can't read FAT boot sector\n");
log_error("check_FAT: can't read FAT boot sector\n");
free(buffer);
return 1;
}
if(test_FAT(disk_car,(const struct fat_boot_sector *)buffer,partition,verbose,0)!=0)
{
if(verbose>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);
/* screen_buffer_add("Ok\n"); */
free(buffer);
return 0;
}
list_part_t *read_part_gpt(disk_t *disk, const int verbose, const int saveheader)
{
list_part_t *list_part;
screen_buffer_reset();
if((list_part=read_part_gpt_aux(disk, verbose, saveheader, 1))!=NULL)
return list_part;
screen_buffer_add( "Trying alternate GPT\n");
list_part=read_part_gpt_aux(disk, verbose, saveheader,
(disk->disk_size-1)/disk->sector_size);
screen_buffer_to_log();
return list_part;
}
static file_data_t *reiser_dir(disk_t *disk_car, const partition_t *partition, dir_data_t *dir_data, const unsigned long int cluster)
{
struct rfs_dir_struct *ls=(struct rfs_dir_struct*)dir_data->private_dir_data;
reiserfs_dir_t *dir;
reiserfs_dir_entry_t entry;
ls->dir_list=NULL;
ls->current_file=NULL;
if (!(dir = reiserfs_dir_open(ls->current_fs, dir_data->current_directory))) {
screen_buffer_add("Couldn't open dir\n");
log_error("Couldn't open dir\n");
return NULL;
}
while (reiserfs_dir_read(dir, &entry))
{
char name[MAX_NAME_LEN(DEFAULT_BLOCK_SIZE)];
reiserfs_object_t *entity;
strncpy(name,dir_data->current_directory,sizeof(name));
strcat(name,"/");
strcat(name,entry.de_name);
if((entity=reiserfs_object_create(ls->current_fs,name,1)))
{
unsigned int thislen;
file_data_t *new_file=(file_data_t *)MALLOC(sizeof(*new_file));
thislen=(MAX_NAME_LEN(DEFAULT_BLOCK_SIZE)<DIR_NAME_LEN?MAX_NAME_LEN(DEFAULT_BLOCK_SIZE):DIR_NAME_LEN);
memcpy(new_file->name,entry.de_name,thislen);
new_file->name[thislen-1]='\0';
new_file->status=0;
new_file->prev=ls->current_file;
new_file->next=NULL;
new_file->st_ino=entity->stat.st_ino;
new_file->st_mode=entity->stat.st_mode;
// new_file->st_nlink=entity->stat.st_nlink;
new_file->st_uid=entity->stat.st_uid;
new_file->st_gid=entity->stat.st_gid;
new_file->st_size=entity->stat.st_size;
// new_file->st_blksize=entity->stat.st_blksize;
new_file->td_atime=entity->stat.st_atime;
new_file->td_mtime=entity->stat.st_mtime;
new_file->td_ctime=entity->stat.st_ctime;
reiserfs_object_free(entity);
if(ls->current_file)
ls->current_file->next=new_file;
else
ls->dir_list=new_file;
ls->current_file=new_file;
}
}
reiserfs_dir_close(dir);
return ls->dir_list;
}
int check_HPFS(disk_t *disk_car,partition_t *partition,const int verbose)
{
unsigned char buffer[disk_car->sector_size];
if((unsigned)disk_car->pread(disk_car, &buffer, disk_car->sector_size, partition->part_offset) != disk_car->sector_size)
{
screen_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,verbose,0)!=0)
{
if(verbose>0)
{
log_info("\n\ntest_HPFS()\n");
log_partition(disk_car,partition);
}
return 1;
}
return 0;
}
static const char *exFAT_boot_sector_rescan(disk_t *disk, partition_t *partition, unsigned char *buffer_bs, unsigned char *buffer_backup_bs)
{
const int size_bs=12 * disk->sector_size;
int opt_B=0;
int opt_O=0;
#ifdef HAVE_NCURSES
aff_copy(stdscr);
wmove(stdscr,4,0);
wprintw(stdscr,"%s",disk->description(disk));
mvwaddstr(stdscr,5,0,msg_PART_HEADER_LONG);
wmove(stdscr,6,0);
aff_part(stdscr,AFF_PART_ORDER|AFF_PART_STATUS,disk,partition);
#endif
log_info("\nexFAT_boot_sector\n");
log_partition(disk,partition);
screen_buffer_add("Boot sector\n");
if(disk->pread(disk, buffer_bs, size_bs, partition->part_offset) != size_bs)
{
screen_buffer_add("Bad: can't read exFAT boot record.\n");
memset(buffer_bs,0,size_bs);
}
else if(test_exFAT((const struct exfat_super_block*)buffer_bs)==0)
{
screen_buffer_add("exFAT OK\n");
opt_O=1;
}
else
screen_buffer_add("Bad\n");
screen_buffer_add("\nBackup boot record\n");
if(disk->pread(disk, buffer_backup_bs, size_bs, partition->part_offset + size_bs) != size_bs)
{
screen_buffer_add("Bad: can't read exFAT backup boot record.\n");
memset(buffer_backup_bs,0,size_bs);
}
else if(test_exFAT((const struct exfat_super_block*)buffer_backup_bs)==0)
{
screen_buffer_add("exFAT OK\n");
opt_B=1;
}
else
screen_buffer_add("Bad\n");
screen_buffer_add("\n");
if(memcmp(buffer_bs, buffer_backup_bs, size_bs)==0)
{
screen_buffer_add("Sectors are identical.\n");
return "D";
}
else
{
screen_buffer_add("Sectors are not identical.\n");
}
if(opt_B!=0 && opt_O!=0)
return "DOB";
else if(opt_B!=0)
return "DB";
else if(opt_O!=0)
return "DO";
return "D";
}
list_part_t *read_part_gpt(disk_t *disk_car, const int verbose, const int saveheader)
{
struct gpt_hdr *gpt;
struct gpt_ent* gpt_entries;
list_part_t *new_list_part=NULL;
unsigned int i;
uint32_t gpt_entries_size;
uint64_t gpt_entries_offset;
gpt=(struct gpt_hdr*)MALLOC(disk_car->sector_size);
screen_buffer_reset();
if((unsigned)disk_car->pread(disk_car, gpt, disk_car->sector_size, disk_car->sector_size) != disk_car->sector_size)
{
free(gpt);
return NULL;
}
if(memcmp(gpt->hdr_sig, GPT_HDR_SIG, 8)!=0)
{
screen_buffer_add("Bad GPT partition, invalid signature.\n");
free(gpt);
return NULL;
}
if(verbose>0)
{
log_info("hdr_size=%llu\n", (long long unsigned)le32(gpt->hdr_size));
log_info("hdr_lba_self=%llu\n", (long long unsigned)le64(gpt->hdr_lba_self));
log_info("hdr_lba_alt=%llu (expected %llu)\n",
(long long unsigned)le64(gpt->hdr_lba_alt),
(long long unsigned)((disk_car->disk_size-1)/disk_car->sector_size));
log_info("hdr_lba_start=%llu\n", (long long unsigned)le64(gpt->hdr_lba_start));
log_info("hdr_lba_end=%llu\n", (long long unsigned)le64(gpt->hdr_lba_end));
log_info("hdr_lba_table=%llu\n",
(long long unsigned)le64(gpt->hdr_lba_table));
log_info("hdr_entries=%llu\n", (long long unsigned)le32(gpt->hdr_entries));
log_info("hdr_entsz=%llu\n", (long long unsigned)le32(gpt->hdr_entsz));
}
/* Check header size */
if(le32(gpt->hdr_size)<92 || le32(gpt->hdr_size) > disk_car->sector_size)
{
screen_buffer_add("GPT: invalid header size.\n");
free(gpt);
return NULL;
}
{ /* CRC check */
uint32_t crc;
uint32_t origcrc;
origcrc=le32(gpt->hdr_crc_self);
gpt->hdr_crc_self=le32(0);
crc=get_crc32(gpt, le32(gpt->hdr_size), 0xFFFFFFFF)^0xFFFFFFFF;
if(crc!=origcrc)
{
screen_buffer_add("Bad GPT partition, invalid header checksum.\n");
free(gpt);
return NULL;
}
gpt->hdr_crc_self=le32(origcrc);
}
if(le64(gpt->hdr_lba_self)!=1)
{
screen_buffer_add("Bad GPT partition, invalid LBA self location.\n");
free(gpt);
return NULL;
}
if(le64(gpt->hdr_lba_start) >= le64(gpt->hdr_lba_end))
{
screen_buffer_add("Bad GPT partition, invalid LBA start/end location.\n");
free(gpt);
return NULL;
}
if(le32(gpt->hdr_revision)!=GPT_HDR_REVISION)
{
screen_buffer_add("GPT: Warning - not revision 1.0\n");
}
if(le32(gpt->__reserved)!=0)
{
screen_buffer_add("GPT: Warning - __reserved!=0\n");
}
if(le32(gpt->hdr_entries)==0 || le32(gpt->hdr_entries)>4096)
{
screen_buffer_add("GPT: invalid number (%u) of partition entries.\n",
(unsigned int)le32(gpt->hdr_entries));
free(gpt);
return NULL;
}
/* le32(gpt->hdr_entsz)==128 */
if(le32(gpt->hdr_entsz)%8!=0 || le32(gpt->hdr_entsz)<128 || le32(gpt->hdr_entsz)>4096)
{
screen_buffer_add("GPT: invalid partition entry size.\n");
free(gpt);
return NULL;
}
gpt_entries_size=le32(gpt->hdr_entries) * le32(gpt->hdr_entsz);
if(gpt_entries_size<16384)
{
screen_buffer_add("GPT: A minimum of 16,384 bytes of space must be reserved for the GUID Partition Entry array.\n");
free(gpt);
return NULL;
}
gpt_entries_offset=(uint64_t)le64(gpt->hdr_lba_table) * disk_car->sector_size;
if((uint64_t) le64(gpt->hdr_lba_self) + le32(gpt->hdr_size) - 1 >= gpt_entries_offset ||
gpt_entries_offset >= le64(gpt->hdr_lba_start) * disk_car->sector_size)
{
screen_buffer_add( "GPT: The primary GUID Partition Entry array must be located after the primary GUID Partition Table Header and end before the FirstUsableLBA.\n");
free(gpt);
return NULL;
}
gpt_entries=(struct gpt_ent*)MALLOC(gpt_entries_size);
if((unsigned)disk_car->pread(disk_car, gpt_entries, gpt_entries_size, gpt_entries_offset) != gpt_entries_size)
{
free(gpt_entries);
free(gpt);
return new_list_part;
}
{ /* CRC check */
uint32_t crc;
crc=get_crc32(gpt_entries, gpt_entries_size, 0xFFFFFFFF)^0xFFFFFFFF;
if(crc!=le32(gpt->hdr_crc_table))
{
screen_buffer_add("Bad GPT partition entries, invalid checksum.\n");
free(gpt_entries);
free(gpt);
return NULL;
}
}
for(i=0;i<le32(gpt->hdr_entries);i++)
{
const struct gpt_ent* gpt_entry;
gpt_entry=(const struct gpt_ent*)((const char*)gpt_entries + (unsigned long)i*le32(gpt->hdr_entsz));
if(guid_cmp(gpt_entry->ent_type, GPT_ENT_TYPE_UNUSED)!=0 &&
le64(gpt_entry->ent_lba_start) < le64(gpt_entry->ent_lba_end))
{
int insert_error=0;
partition_t *new_partition=partition_new(&arch_gpt);
new_partition->order=i+1;
guid_cpy(&new_partition->part_uuid, &gpt_entry->ent_uuid);
guid_cpy(&new_partition->part_type_gpt, &gpt_entry->ent_type);
new_partition->part_offset=(uint64_t)le64(gpt_entry->ent_lba_start)*disk_car->sector_size;
new_partition->part_size=(uint64_t)(le64(gpt_entry->ent_lba_end) -
le64(gpt_entry->ent_lba_start)+1) * disk_car->sector_size;
new_partition->status=STATUS_PRIM;
UCSle2str(new_partition->partname, (const uint16_t *)&gpt_entry->ent_name, sizeof(gpt_entry->ent_name)/2);
new_partition->arch->check_part(disk_car,verbose,new_partition,saveheader);
/* log_debug("%u ent_attr %08llx\n", new_partition->order, (long long unsigned)le64(gpt_entry->ent_attr)); */
aff_part_buffer(AFF_PART_ORDER|AFF_PART_STATUS,disk_car,new_partition);
new_list_part=insert_new_partition(new_list_part, new_partition, 0, &insert_error);
if(insert_error>0)
free(new_partition);
}
}
/* TODO: The backup GUID Partition Entry array must be
located after the LastUsableLBA and end before the backup GUID Partition Table Header.
*/
free(gpt_entries);
free(gpt);
return new_list_part;
}
void aff_part_buffer(const unsigned int newline,const disk_t *disk_car,const partition_t *partition)
{
const char *msg;
msg=aff_part_aux(newline, disk_car, partition);
screen_buffer_add("%s\n", msg);
}
dir_partition_t dir_partition(disk_t *disk, const partition_t *partition, const int verbose, char **current_cmd)
{
dir_data_t dir_data;
#ifdef HAVE_NCURSES
WINDOW *window;
#endif
dir_partition_t res;
fflush(stderr);
dir_data.local_dir=NULL;
res=dir_partition_init(disk, partition, verbose, &dir_data);
#ifdef HAVE_NCURSES
window=newwin(LINES, COLS, 0, 0); /* full screen */
dir_data.display=window;
aff_copy(window);
#else
dir_data.display=NULL;
#endif
log_info("\n");
switch(res)
{
case DIR_PART_ENOSYS:
screen_buffer_reset();
#ifdef HAVE_NCURSES
aff_copy(window);
wmove(window,4,0);
aff_part(window,AFF_PART_ORDER|AFF_PART_STATUS,disk,partition);
#endif
log_partition(disk,partition);
screen_buffer_add("Support for this filesystem hasn't been enable during compilation.\n");
screen_buffer_to_log();
if(*current_cmd==NULL)
{
#ifdef HAVE_NCURSES
screen_buffer_display(window,"",NULL);
#endif
}
break;
case DIR_PART_EIO:
screen_buffer_reset();
#ifdef HAVE_NCURSES
aff_copy(window);
wmove(window,4,0);
aff_part(window,AFF_PART_ORDER|AFF_PART_STATUS,disk,partition);
#endif
log_partition(disk,partition);
screen_buffer_add("Can't open filesystem. Filesystem seems damaged.\n");
screen_buffer_to_log();
if(*current_cmd==NULL)
{
#ifdef HAVE_NCURSES
screen_buffer_display(window,"",NULL);
#endif
}
break;
case DIR_PART_OK:
{
int recursive=0;
if(*current_cmd!=NULL)
{
int do_continue;
do
{
do_continue=0;
while(*current_cmd[0]==',')
(*current_cmd)++;
if(strncmp(*current_cmd,"recursive",9)==0)
{
(*current_cmd)+=9;
recursive=1;
do_continue=1;
}
else if(strncmp(*current_cmd,"fullpathname",12)==0)
{
(*current_cmd)+=12;
dir_data.param|=FLAG_LIST_PATHNAME;
do_continue=1;
}
} while(do_continue==1);
}
if(recursive>0)
dir_whole_partition_log(disk,partition,&dir_data,dir_data.current_inode);
else
{
#ifdef HAVE_NCURSES
dir_partition_aff(disk, partition, &dir_data, dir_data.current_inode, current_cmd);
#else
{
file_info_t dir_list = {
.list = TD_LIST_HEAD_INIT(dir_list.list),
.name = NULL
};
dir_data.get_dir(disk, partition, &dir_data, dir_data.current_inode, &dir_list);
dir_aff_log(&dir_data, &dir_list);
delete_list_file(&dir_list);
}
#endif
}
dir_data.close(&dir_data);
}
break;
}
#ifdef HAVE_NCURSES
delwin(window);
(void) clearok(stdscr, TRUE);
#ifdef HAVE_TOUCHWIN
touchwin(stdscr);
#endif
wrefresh(stdscr);
#endif
fflush(stderr);
free(dir_data.local_dir);
return res;
}
static int check_part_none(disk_t *disk_car,const int verbose,partition_t *partition, const int saveheader)
{
int ret=0;
switch(partition->upart_type)
{
case UP_BEOS:
ret=check_BeFS(disk_car,partition);
break;
case UP_BTRFS:
ret=check_btrfs(disk_car, partition);
break;
case UP_CRAMFS:
ret=check_cramfs(disk_car,partition,verbose);
break;
case UP_EXT2:
case UP_EXT3:
case UP_EXT4:
ret=check_EXT2(disk_car,partition,verbose);
break;
case UP_EXTENDED:
break;
case UP_EXFAT:
ret=check_EXFAT(disk_car, partition);
break;
case UP_FAT12:
case UP_FAT16:
case UP_FAT32:
ret=check_FAT(disk_car,partition,verbose);
break;
case UP_FATX:
ret=check_FATX(disk_car, partition);
break;
case UP_FREEBSD:
ret=check_BSD(disk_car,partition,verbose,BSD_MAXPARTITIONS);
break;
case UP_GFS2:
ret=check_gfs2(disk_car, partition);
break;
case UP_HFS:
ret=check_HFS(disk_car,partition,verbose);
break;
case UP_HFSP:
case UP_HFSX:
ret=check_HFSP(disk_car,partition,verbose);
break;
case UP_HPFS:
ret=check_HPFS(disk_car,partition,verbose);
break;
case UP_ISO:
ret=check_ISO(disk_car, partition);
break;
case UP_JFS:
ret=check_JFS(disk_car, partition);
break;
case UP_LINSWAP:
case UP_LINSWAP2:
case UP_LINSWAP_8K:
case UP_LINSWAP2_8K:
case UP_LINSWAP2_8KBE:
ret=check_Linux_SWAP(disk_car, partition);
break;
case UP_LUKS:
ret=check_LUKS(disk_car, partition);
break;
case UP_LVM:
ret=check_LVM(disk_car,partition,verbose);
break;
case UP_LVM2:
ret=check_LVM2(disk_car,partition,verbose);
break;
case UP_NETWARE:
ret=check_netware(disk_car, partition);
break;
case UP_NTFS:
ret=check_NTFS(disk_car,partition,verbose,0);
if(ret!=0)
{ screen_buffer_add("Invalid NTFS boot\n"); }
break;
case UP_OPENBSD:
ret=check_BSD(disk_car,partition,verbose,OPENBSD_MAXPARTITIONS);
break;
case UP_OS2MB:
ret=check_OS2MB(disk_car,partition,verbose);
break;
case UP_MD:
case UP_MD1:
ret=check_MD(disk_car,partition,verbose);
if(ret!=0)
{ screen_buffer_add("Invalid RAID superblock\n"); }
break;
case UP_RFS:
case UP_RFS2:
case UP_RFS3:
case UP_RFS4:
ret=check_rfs(disk_car,partition,verbose);
break;
case UP_SUN:
ret=check_sun_i386(disk_car,partition,verbose);
break;
case UP_SYSV4:
ret=check_sysv(disk_car,partition,verbose);
break;
case UP_UFS:
case UP_UFS2:
case UP_UFS_LE:
case UP_UFS2_LE:
ret=check_ufs(disk_car,partition,verbose);
break;
case UP_VMFS:
ret=check_VMFS(disk_car, partition);
break;
case UP_WBFS:
ret=check_WBFS(disk_car, partition);
break;
case UP_XFS:
case UP_XFS2:
case UP_XFS3:
case UP_XFS4:
ret=check_xfs(disk_car,partition,verbose);
break;
case UP_ZFS:
ret=check_ZFS(disk_car, partition);
break;
case UP_UNK:
break;
}
return ret;
}
int exFAT_boot_sector(disk_t *disk, partition_t *partition, const int verbose, char **current_cmd)
{
unsigned char *buffer_bs;
unsigned char *buffer_backup_bs;
const char *options="";
int rescan=1;
#ifdef HAVE_NCURSES
struct MenuItem menu_exFAT[]=
{
{ 'P', "Previous",""},
{ 'N', "Next","" },
{ 'Q', "Quit","Return to Advanced menu"},
{ 'O', "Org. BS","Copy superblock over backup sector"},
{ 'B', "Backup BS","Copy backup superblock over superblock"},
{ 'D', "Dump","Dump superblock and backup superblock"},
{ 0, NULL, NULL }
};
#endif
buffer_bs=(unsigned char*)MALLOC(12 * disk->sector_size);
buffer_backup_bs=(unsigned char*)MALLOC(12 * disk->sector_size);
while(1)
{
#ifdef HAVE_NCURSES
unsigned int menu=0;
#endif
int command;
screen_buffer_reset();
if(rescan==1)
{
int opt_over=0;
int opt_B=0;
int opt_O=0;
options="D";
#ifdef HAVE_NCURSES
aff_copy(stdscr);
wmove(stdscr,4,0);
wprintw(stdscr,"%s",disk->description(disk));
mvwaddstr(stdscr,5,0,msg_PART_HEADER_LONG);
wmove(stdscr,6,0);
aff_part(stdscr,AFF_PART_ORDER|AFF_PART_STATUS,disk,partition);
#endif
log_info("\nexFAT_boot_sector\n");
log_partition(disk,partition);
screen_buffer_add("Boot sector\n");
if(disk->pread(disk, buffer_bs, 12 * disk->sector_size, partition->part_offset) != 12 * disk->sector_size)
{
screen_buffer_add("Bad: can't read exFAT boot record.\n");
memset(buffer_bs,0,12 * disk->sector_size);
}
else if(test_EXFAT((const struct exfat_super_block*)buffer_bs, partition)==0)
{
screen_buffer_add("exFAT OK\n");
opt_O=1;
opt_over=1;
}
else
screen_buffer_add("Bad\n");
screen_buffer_add("\nBackup boot record\n");
if(disk->pread(disk, buffer_backup_bs, 12 * disk->sector_size, partition->part_offset + 12 * disk->sector_size) != 12 * disk->sector_size)
{
screen_buffer_add("Bad: can't read exFAT backup boot record.\n");
memset(buffer_backup_bs,0,12 * disk->sector_size);
}
else if(test_EXFAT((const struct exfat_super_block*)buffer_backup_bs, partition)==0)
{
screen_buffer_add("exFAT OK\n");
opt_B=1;
opt_over=1;
}
else
screen_buffer_add("Bad\n");
screen_buffer_add("\n");
if(memcmp(buffer_bs,buffer_backup_bs,12 * disk->sector_size)==0)
{
screen_buffer_add("Sectors are identical.\n");
opt_over=0;
}
else
{
screen_buffer_add("Sectors are not identical.\n");
}
if(opt_over!=0)
{
if(opt_B!=0 && opt_O!=0)
options="DOB";
else if(opt_B!=0)
options="DB";
else if(opt_O!=0)
options="DO";
}
rescan=0;
}
screen_buffer_to_log();
if(*current_cmd!=NULL)
{
command=0;
while(*current_cmd[0]==',')
(*current_cmd)++;
if(strncmp(*current_cmd,"dump",4)==0)
{
(*current_cmd)+=4;
command='D';
}
else if(strncmp(*current_cmd,"originalexFAT",11)==0)
{
(*current_cmd)+=11;
if(strchr(options,'O')!=NULL)
command='O';
}
else if(strncmp(*current_cmd,"backupexFAT",9)==0)
{
(*current_cmd)+=9;
if(strchr(options,'B')!=NULL)
command='B';
}
}
else
{
log_flush();
#ifdef HAVE_NCURSES
command=screen_buffer_display_ext(stdscr, options, menu_exFAT, &menu);
#else
command=0;
#endif
}
switch(command)
{
case 0:
free(buffer_bs);
free(buffer_backup_bs);
return 0;
case 'O': /* O : copy original superblock over backup boot */
#ifdef HAVE_NCURSES
if(ask_confirmation("Copy original exFAT boot record over backup, confirm ? (Y/N)")!=0)
{
log_info("copy original superblock over backup boot\n");
if(disk->pwrite(disk, buffer_bs, 12 * disk->sector_size, partition->part_offset + 12 * disk->sector_size) != 12 * disk->sector_size)
{
display_message("Write error: Can't overwrite exFAT backup boot record\n");
}
disk->sync(disk);
rescan=1;
}
#endif
break;
case 'B': /* B : copy backup superblock over main superblock */
#ifdef HAVE_NCURSES
if(ask_confirmation("Copy backup exFAT boot record over main boot record, confirm ? (Y/N)")!=0)
{
log_info("copy backup superblock over main superblock\n");
/* Reset information about backup boot record */
partition->sb_offset=0;
if(disk->pwrite(disk, buffer_backup_bs, 12 * disk->sector_size, partition->part_offset) != 12 * disk->sector_size)
{
display_message("Write error: Can't overwrite exFAT main boot record\n");
}
disk->sync(disk);
rescan=1;
}
#endif
break;
case 'D':
exFAT_dump(disk, partition, buffer_bs, buffer_backup_bs, current_cmd);
break;
}
}
}
int dir_partition(disk_t *disk_car, const partition_t *partition, const int verbose, char **current_cmd)
{
dir_data_t dir_data;
#ifdef HAVE_NCURSES
WINDOW *window;
#endif
int res=-3;
fflush(stderr);
dir_data.local_dir=NULL;
if(is_part_fat(partition))
res=dir_partition_fat_init(disk_car,partition,&dir_data,verbose);
else if(is_part_ntfs(partition))
{
res=dir_partition_ntfs_init(disk_car,partition,&dir_data,verbose);
if(res!=0)
res=dir_partition_exfat_init(disk_car, partition, &dir_data, verbose);
}
else if(is_part_linux(partition))
{
res=dir_partition_ext2_init(disk_car,partition,&dir_data,verbose);
if(res!=0)
res=dir_partition_reiser_init(disk_car,partition,&dir_data,verbose);
}
if(res!=0)
{
switch(partition->upart_type)
{
case UP_FAT12:
case UP_FAT16:
case UP_FAT32:
res=dir_partition_fat_init(disk_car,partition,&dir_data,verbose);
break;
case UP_EXT4:
case UP_EXT3:
case UP_EXT2:
res=dir_partition_ext2_init(disk_car,partition,&dir_data,verbose);
break;
case UP_RFS:
case UP_RFS2:
case UP_RFS3:
res=dir_partition_reiser_init(disk_car,partition,&dir_data,verbose);
break;
case UP_NTFS:
res=dir_partition_ntfs_init(disk_car,partition,&dir_data,verbose);
break;
case UP_EXFAT:
res=dir_partition_exfat_init(disk_car, partition, &dir_data, verbose);
break;
default:
return res;
}
}
#ifdef HAVE_NCURSES
window=newwin(LINES, COLS, 0, 0); /* full screen */
dir_data.display=window;
aff_copy(window);
#else
dir_data.display=NULL;
#endif
log_info("\n");
switch(res)
{
case -2:
screen_buffer_reset();
#ifdef HAVE_NCURSES
aff_copy(window);
wmove(window,4,0);
aff_part(window,AFF_PART_ORDER|AFF_PART_STATUS,disk_car,partition);
#endif
log_partition(disk_car,partition);
screen_buffer_add("Support for this filesystem hasn't been enable during compilation.\n");
screen_buffer_to_log();
if(*current_cmd==NULL)
{
#ifdef HAVE_NCURSES
screen_buffer_display(window,"",NULL);
#endif
}
break;
case -1:
screen_buffer_reset();
#ifdef HAVE_NCURSES
aff_copy(window);
wmove(window,4,0);
aff_part(window,AFF_PART_ORDER|AFF_PART_STATUS,disk_car,partition);
#endif
log_partition(disk_car,partition);
screen_buffer_add("Can't open filesystem. Filesystem seems damaged.\n");
screen_buffer_to_log();
if(*current_cmd==NULL)
{
#ifdef HAVE_NCURSES
screen_buffer_display(window,"",NULL);
#endif
}
break;
default:
{
int recursive=0;
if(*current_cmd!=NULL)
{
int do_continue;
do
{
do_continue=0;
while(*current_cmd[0]==',')
(*current_cmd)++;
if(strncmp(*current_cmd,"recursive",9)==0)
{
(*current_cmd)+=9;
recursive=1;
do_continue=1;
}
else if(strncmp(*current_cmd,"fullpathname",12)==0)
{
(*current_cmd)+=12;
dir_data.param|=FLAG_LIST_PATHNAME;
do_continue=1;
}
} while(do_continue==1);
}
if(recursive>0)
dir_whole_partition_log(disk_car,partition,&dir_data,dir_data.current_inode);
else
{
#ifdef HAVE_NCURSES
dir_partition_aff(disk_car, partition, &dir_data, dir_data.current_inode, current_cmd);
#else
{
file_data_t *dir_list;
dir_list=dir_data.get_dir(disk_car, partition, &dir_data, dir_data.current_inode);
dir_aff_log(&dir_data, dir_list);
delete_list_file(dir_list);
}
#endif
}
dir_data.close(&dir_data);
}
break;
}
#ifdef HAVE_NCURSES
delwin(window);
(void) clearok(stdscr, TRUE);
#ifdef HAVE_TOUCHWIN
touchwin(stdscr);
#endif
wrefresh(stdscr);
#endif
fflush(stderr);
free(dir_data.local_dir);
return res;
}
int ntfs_boot_sector(disk_t *disk_car, partition_t *partition, const int verbose, const unsigned int expert, char **current_cmd)
{
unsigned char *buffer_bs;
unsigned char *buffer_backup_bs;
const char *options="";
#ifdef HAVE_NCURSES
struct MenuItem menu_ntfs[]=
{
{ 'P', "Previous",""},
{ 'N', "Next","" },
{ 'Q', "Quit","Return to Advanced menu"},
{ 'L', "List", "List directories and files, copy data from NTFS" },
{ 'O', "Org. BS","Copy boot sector over backup sector"},
{ 'B', "Backup BS","Copy backup boot sector over boot sector"},
{ 'R', "Rebuild BS","Rebuild boot sector"},
{ 'M', "Repair MFT","Check MFT"},
{ 'D', "Dump","Dump boot sector and backup boot sector"},
{ 0, NULL, NULL }
};
#endif
buffer_bs=(unsigned char*)MALLOC(NTFS_BOOT_SECTOR_SIZE);
buffer_backup_bs=(unsigned char*)MALLOC(NTFS_BOOT_SECTOR_SIZE);
while(1)
{
unsigned int menu=0;
int command;
screen_buffer_reset();
{
int identical_sectors=0;
int opt_B=0;
int opt_O=0;
#ifdef HAVE_NCURSES
aff_copy(stdscr);
wmove(stdscr,4,0);
wprintw(stdscr,"%s",disk_car->description(disk_car));
mvwaddstr(stdscr,5,0,msg_PART_HEADER_LONG);
wmove(stdscr,6,0);
aff_part(stdscr,AFF_PART_ORDER|AFF_PART_STATUS,disk_car,partition);
#endif
log_info("\nntfs_boot_sector\n");
log_partition(disk_car,partition);
screen_buffer_add("Boot sector\n");
if(disk_car->pread(disk_car, buffer_bs, NTFS_BOOT_SECTOR_SIZE, partition->part_offset) != NTFS_BOOT_SECTOR_SIZE)
{
screen_buffer_add("ntfs_boot_sector: Can't read boot sector.\n");
memset(buffer_bs,0,NTFS_BOOT_SECTOR_SIZE);
}
if(test_NTFS(disk_car,(struct ntfs_boot_sector*)buffer_bs,partition,verbose,0)==0)
{
screen_buffer_add("Status: OK\n");
opt_O=1;
}
else
{
screen_buffer_add("Status: Bad\n");
}
screen_buffer_add("\nBackup boot sector\n");
if(disk_car->pread(disk_car, buffer_backup_bs, NTFS_BOOT_SECTOR_SIZE, partition->part_offset + partition->part_size - disk_car->sector_size) != NTFS_BOOT_SECTOR_SIZE)
{
screen_buffer_add("ntfs_boot_sector: Can't read backup boot sector.\n");
memset(buffer_backup_bs,0,NTFS_BOOT_SECTOR_SIZE);
}
if(test_NTFS(disk_car,(struct ntfs_boot_sector*)buffer_backup_bs,partition,verbose,0)==0)
{
screen_buffer_add("Status: OK\n");
opt_B=1;
}
else
{
screen_buffer_add("Status: Bad\n");
}
screen_buffer_add("\n");
if(memcmp(buffer_bs,buffer_backup_bs,NTFS_BOOT_SECTOR_SIZE)==0)
{
log_ntfs_info((const struct ntfs_boot_sector *)buffer_bs);
screen_buffer_add("Sectors are identical.\n");
identical_sectors=1;
}
else
{
log_ntfs2_info((const struct ntfs_boot_sector *)buffer_bs, (const struct ntfs_boot_sector *)buffer_backup_bs);
screen_buffer_add("Sectors are not identical.\n");
identical_sectors=0;
}
screen_buffer_add("\n");
screen_buffer_add("A valid NTFS Boot sector must be present in order to access\n");
screen_buffer_add("any data; even if the partition is not bootable.\n");
if(opt_B!=0 && opt_O!=0)
{
if(identical_sectors==0)
options="DOBRL";
else
options="DRML";
}
else if(opt_B!=0)
{
menu=5;
if(expert>0)
options="DBRML";
else
options="DBRL";
}
else if(opt_O!=0)
{
menu=4;
options="DORL";
}
else
options="DR";
}
screen_buffer_to_log();
if(*current_cmd!=NULL)
{
command=0;
while(*current_cmd[0]==',')
(*current_cmd)++;
if(strncmp(*current_cmd,"rebuildbs",9)==0)
{
(*current_cmd)+=9;
command='R';
}
else if(strncmp(*current_cmd,"dump",4)==0)
{
(*current_cmd)+=4;
command='D';
}
else if(strncmp(*current_cmd,"list",4)==0)
{
(*current_cmd)+=4;
command='L';
}
else if(strncmp(*current_cmd,"originalntfs",11)==0)
{
(*current_cmd)+=11;
if(strchr(options,'O')!=NULL)
command='O';
}
else if(strncmp(*current_cmd,"backupntfs",9)==0)
{
(*current_cmd)+=9;
if(strchr(options,'B')!=NULL)
command='B';
}
else if(strncmp(*current_cmd,"repairmft",9)==0)
{
(*current_cmd)+=9;
if(strchr(options,'M')!=NULL)
command='M';
}
}
else
{
log_flush();
#ifdef HAVE_NCURSES
command=screen_buffer_display_ext(stdscr, options, menu_ntfs, &menu);
#else
command=0;
#endif
}
switch(command)
{
case 0:
free(buffer_bs);
free(buffer_backup_bs);
return 0;
case 'O': /* O : copy original boot sector over backup boot */
#ifdef HAVE_NCURSES
if(ask_confirmation("Copy original NTFS boot sector over backup boot, confirm ? (Y/N)")!=0)
{
log_info("copy original boot sector over backup boot\n");
if(disk_car->pwrite(disk_car, buffer_bs, NTFS_BOOT_SECTOR_SIZE, partition->part_offset + partition->part_size - disk_car->sector_size) != NTFS_BOOT_SECTOR_SIZE)
{
display_message("Write error: Can't overwrite NTFS backup boot sector\n");
}
disk_car->sync(disk_car);
}
#endif
break;
case 'B': /* B : copy backup boot sector over boot sector */
#ifdef HAVE_NCURSES
if(ask_confirmation("Copy backup NTFS boot sector over boot sector, confirm ? (Y/N)")!=0)
{
log_info("copy backup boot sector over boot sector\n");
/* Reset information about backup boot sector */
partition->sb_offset=0;
if(disk_car->pwrite(disk_car, buffer_backup_bs, NTFS_BOOT_SECTOR_SIZE, partition->part_offset) != NTFS_BOOT_SECTOR_SIZE)
{
display_message("Write error: Can't overwrite NTFS boot sector\n");
}
disk_car->sync(disk_car);
}
#endif
break;
case 'L':
if(strchr(options,'O')==NULL && strchr(options,'B')!=NULL)
{
io_redir_add_redir(disk_car,partition->part_offset,NTFS_BOOT_SECTOR_SIZE,0,buffer_backup_bs);
dir_partition(disk_car, partition, 0,current_cmd);
io_redir_del_redir(disk_car,partition->part_offset);
}
else
dir_partition(disk_car, partition, 0,current_cmd);
break;
case 'M':
repair_MFT(disk_car, partition, verbose, expert, current_cmd);
break;
case 'R': /* R : rebuild boot sector */
rebuild_NTFS_BS(disk_car, partition, verbose, 1, expert, current_cmd);
break;
case 'D':
dump_NTFS(disk_car, partition, buffer_bs, buffer_backup_bs);
break;
}
}
}
