mirror of
https://github.com/wiidev/usbloadergx.git
synced 2024-11-05 11:05:06 +01:00
6022ad060d
*Added Free Space show option to the settings (can be enabled even on FAT partitions) *Moved partition free space determination to a ThreadedTask because it takes up to 10 seconds on FAT. This speeds up the build up of the main game menu (on start and on change from other menu) on all partitions. *Removed double "waiting for slow HDD" screens *Fixed scrollbar in settings
348 lines
10 KiB
C++
348 lines
10 KiB
C++
/****************************************************************************
|
|
* Copyright (C) 2010
|
|
* by Dimok
|
|
*
|
|
* This software is provided 'as-is', without any express or implied
|
|
* warranty. In no event will the authors be held liable for any
|
|
* damages arising from the use of this software.
|
|
*
|
|
* Permission is granted to anyone to use this software for any
|
|
* purpose, including commercial applications, and to alter it and
|
|
* redistribute it freely, subject to the following restrictions:
|
|
*
|
|
* 1. The origin of this software must not be misrepresented; you
|
|
* must not claim that you wrote the original software. If you use
|
|
* this software in a product, an acknowledgment in the product
|
|
* documentation would be appreciated but is not required.
|
|
*
|
|
* 2. Altered source versions must be plainly marked as such, and
|
|
* must not be misrepresented as being the original software.
|
|
*
|
|
* 3. This notice may not be removed or altered from any source
|
|
* distribution.
|
|
*
|
|
* for WiiXplorer 2010
|
|
***************************************************************************/
|
|
#include <gccore.h>
|
|
#include <fat.h>
|
|
#include <ntfs.h>
|
|
#include <ext2.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <malloc.h>
|
|
#include "libs/libwbfs/libwbfs.h"
|
|
#include "utils/uncompress.h"
|
|
#include "PartitionHandle.h"
|
|
|
|
#define PARTITION_TYPE_DOS33_EXTENDED 0x05 /* DOS 3.3+ extended partition */
|
|
#define PARTITION_TYPE_WIN95_EXTENDED 0x0F /* Windows 95 extended partition */
|
|
|
|
#define CACHE 32
|
|
#define SECTORS 64
|
|
|
|
static inline const char * PartFromType(int type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case 0x00: return "Unused";
|
|
case 0x01: return "FAT12";
|
|
case 0x04: return "FAT16";
|
|
case 0x05: return "Extended";
|
|
case 0x06: return "FAT16";
|
|
case 0x07: return "NTFS";
|
|
case 0x0b: return "FAT32";
|
|
case 0x0c: return "FAT32";
|
|
case 0x0e: return "FAT16";
|
|
case 0x0f: return "Extended";
|
|
case 0x82: return "LxSWP";
|
|
case 0x83: return "LINUX";
|
|
case 0x8e: return "LxLVM";
|
|
case 0xa8: return "OSX";
|
|
case 0xab: return "OSXBT";
|
|
case 0xaf: return "OSXHF";
|
|
case 0xbf: return "WBFS";
|
|
case 0xe8: return "LUKS";
|
|
default: return "Unknown";
|
|
}
|
|
}
|
|
|
|
PartitionHandle::PartitionHandle(const DISC_INTERFACE *discio)
|
|
{
|
|
interface = discio;
|
|
|
|
// Sanity check
|
|
if (!interface)
|
|
return;
|
|
|
|
// Start the device and check that it is inserted
|
|
if (!interface->startup())
|
|
return;
|
|
|
|
if (!interface->isInserted())
|
|
return;
|
|
|
|
FindPartitions();
|
|
}
|
|
|
|
PartitionHandle::~PartitionHandle()
|
|
{
|
|
UnMountAll();
|
|
|
|
//shutdown device
|
|
interface->shutdown();
|
|
}
|
|
|
|
bool PartitionHandle::IsMounted(int pos)
|
|
{
|
|
if(pos < 0 || pos >= (int) MountNameList.size())
|
|
return false;
|
|
|
|
if(MountNameList[pos].size() == 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool PartitionHandle::Mount(int pos, const char * name, bool forceFAT)
|
|
{
|
|
if(!valid(pos))
|
|
return false;
|
|
|
|
if(!name)
|
|
return false;
|
|
|
|
UnMount(pos);
|
|
|
|
if(pos >= (int) MountNameList.size())
|
|
MountNameList.resize(GetPartitionCount());
|
|
|
|
MountNameList[pos] = name;
|
|
|
|
//! Some stupid partition manager think they don't need to edit the freaken MBR.
|
|
//! So we need to check the first 64 sectors and see if some partition is there.
|
|
//! libfat does that by default so let's use it.
|
|
//! We do that only on sd not on usb.
|
|
if(forceFAT && (!GetFSName(pos) || strcmp(GetFSName(pos), "Unknown") == 0))
|
|
{
|
|
if (fatMount(MountNameList[pos].c_str(), interface, 0, CACHE, SECTORS))
|
|
{
|
|
extern sec_t _FAT_startSector;
|
|
AddPartition("FAT", _FAT_startSector, 0xdeadbeaf, true, 0x0c, 0);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if(strncmp(GetFSName(pos), "FAT", 3) == 0 || strcmp(GetFSName(pos), "GUID-Entry") == 0)
|
|
{
|
|
if (fatMount(MountNameList[pos].c_str(), interface, GetLBAStart(pos), CACHE, SECTORS))
|
|
{
|
|
if(strcmp(GetFSName(pos), "GUID-Entry") == 0)
|
|
PartitionList[pos].FSName = "FAT";
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if(strncmp(GetFSName(pos), "NTFS", 4) == 0 || strcmp(GetFSName(pos), "GUID-Entry") == 0)
|
|
{
|
|
if(ntfsMount(MountNameList[pos].c_str(), interface, GetLBAStart(pos), CACHE, SECTORS, NTFS_SHOW_HIDDEN_FILES | NTFS_RECOVER))
|
|
{
|
|
PartitionList[pos].FSName = "NTFS";
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if(strncmp(GetFSName(pos), "LINUX", 5) == 0 || strcmp(GetFSName(pos), "GUID-Entry") == 0)
|
|
{
|
|
if(ext2Mount(MountNameList[pos].c_str(), interface, GetLBAStart(pos), CACHE, SECTORS, EXT2_FLAG_DEFAULT))
|
|
{
|
|
PartitionList[pos].FSName = "LINUX";
|
|
return true;
|
|
}
|
|
}
|
|
|
|
MountNameList[pos].clear();
|
|
|
|
return false;
|
|
}
|
|
|
|
void PartitionHandle::UnMount(int pos)
|
|
{
|
|
if(!interface)
|
|
return;
|
|
|
|
if(pos >= (int) MountNameList.size())
|
|
return;
|
|
|
|
if(MountNameList[pos].size() == 0)
|
|
return;
|
|
|
|
char DeviceSyn[20];
|
|
snprintf(DeviceSyn, sizeof(DeviceSyn), "%s:", MountNameList[pos].c_str());
|
|
|
|
//closing all open Files write back the cache
|
|
fatUnmount(DeviceSyn);
|
|
//closing all open Files write back the cache
|
|
ntfsUnmount(DeviceSyn, true);
|
|
//closing all open Files write back the cache
|
|
ext2Unmount(DeviceSyn);
|
|
//Remove name from list
|
|
MountNameList[pos].clear();
|
|
}
|
|
|
|
bool PartitionHandle::IsExisting(u64 lba)
|
|
{
|
|
for(u32 i = 0; i < PartitionList.size(); ++i)
|
|
{
|
|
if(PartitionList[i].LBA_Start == lba)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int PartitionHandle::FindPartitions()
|
|
{
|
|
MASTER_BOOT_RECORD mbr;
|
|
|
|
// Read the first sector on the device
|
|
if (!interface->readSectors(0, 1, &mbr))
|
|
return -1;
|
|
|
|
// If this is the devices master boot record
|
|
if (mbr.signature != MBR_SIGNATURE)
|
|
return -1;
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
PARTITION_RECORD * partition = (PARTITION_RECORD *) &mbr.partitions[i];
|
|
|
|
if(partition->type == PARTITION_TYPE_GPT)
|
|
{
|
|
int ret = CheckGPT(i);
|
|
if(ret == 0) // if it's a GPT we don't need to go on looking through the mbr anymore
|
|
return ret;
|
|
}
|
|
|
|
if(partition->type == PARTITION_TYPE_DOS33_EXTENDED || partition->type == PARTITION_TYPE_WIN95_EXTENDED)
|
|
{
|
|
CheckEBR(i, le32(partition->lba_start));
|
|
continue;
|
|
}
|
|
|
|
if(le32(partition->block_count) > 0 && !IsExisting(le32(partition->lba_start)))
|
|
{
|
|
AddPartition(PartFromType(partition->type), le32(partition->lba_start),
|
|
le32(partition->block_count), (partition->status == PARTITION_BOOTABLE),
|
|
partition->type, i);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void PartitionHandle::CheckEBR(u8 PartNum, sec_t ebr_lba)
|
|
{
|
|
EXTENDED_BOOT_RECORD ebr;
|
|
sec_t next_erb_lba = 0;
|
|
|
|
do
|
|
{
|
|
// Read and validate the extended boot record
|
|
if (!interface->readSectors(ebr_lba + next_erb_lba, 1, &ebr))
|
|
return;
|
|
|
|
if (ebr.signature != EBR_SIGNATURE)
|
|
return;
|
|
|
|
if(le32(ebr.partition.block_count) > 0 && !IsExisting(ebr_lba + next_erb_lba + le32(ebr.partition.lba_start)))
|
|
{
|
|
AddPartition(PartFromType(ebr.partition.type), ebr_lba + next_erb_lba + le32(ebr.partition.lba_start),
|
|
le32(ebr.partition.block_count), (ebr.partition.status == PARTITION_BOOTABLE),
|
|
ebr.partition.type, PartNum);
|
|
}
|
|
// Get the start sector of the current partition
|
|
// and the next extended boot record in the chain
|
|
next_erb_lba = le32(ebr.next_ebr.lba_start);
|
|
}
|
|
while(next_erb_lba > 0);
|
|
}
|
|
|
|
static const u8 TYPE_UNUSED[16] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
|
|
static const u8 TYPE_BIOS[16] = { 0x48,0x61,0x68,0x21,0x49,0x64,0x6F,0x6E,0x74,0x4E,0x65,0x65,0x64,0x45,0x46,0x49 };
|
|
static const u8 TYPE_LINUX_MS_BASIC_DATA[16] = { 0xA2,0xA0,0xD0,0xEB,0xE5,0xB9,0x33,0x44,0x87,0xC0,0x68,0xB6,0xB7,0x26,0x99,0xC7 };
|
|
|
|
int PartitionHandle::CheckGPT(u8 PartNum)
|
|
{
|
|
GPT_HEADER gpt_header;
|
|
|
|
// Read and validate the extended boot record
|
|
if (!interface->readSectors(1, 1, &gpt_header))
|
|
return -1;
|
|
|
|
if(strncmp(gpt_header.magic, "EFI PART", 8) != 0)
|
|
return -1;
|
|
|
|
gpt_header.part_table_lba = le64(gpt_header.part_table_lba);
|
|
gpt_header.part_entries = le32(gpt_header.part_entries);
|
|
gpt_header.part_entry_size = le32(gpt_header.part_entry_size);
|
|
gpt_header.part_entry_checksum = le32(gpt_header.part_entry_checksum);
|
|
|
|
u8 * sector_buf = new u8[BYTES_PER_SECTOR];
|
|
|
|
u64 next_lba = gpt_header.part_table_lba;
|
|
|
|
for(u32 i = 0; i < gpt_header.part_entries; ++i)
|
|
{
|
|
if (!interface->readSectors(next_lba, 1, sector_buf))
|
|
break;
|
|
|
|
for(u32 n = 0; n < BYTES_PER_SECTOR/gpt_header.part_entry_size; ++n, ++i)
|
|
{
|
|
GUID_PART_ENTRY * part_entry = (GUID_PART_ENTRY *) (sector_buf+gpt_header.part_entry_size*n);
|
|
|
|
if(memcmp(part_entry->part_type_guid, TYPE_UNUSED, 16) == 0)
|
|
continue;
|
|
|
|
if(IsExisting(le64(part_entry->part_first_lba)))
|
|
continue;
|
|
|
|
bool bootable = (memcmp(part_entry->part_type_guid, TYPE_BIOS, 16) == 0);
|
|
|
|
AddPartition("GUID-Entry", le64(part_entry->part_first_lba), le64(part_entry->part_last_lba), bootable, PARTITION_TYPE_GPT, PartNum);
|
|
}
|
|
|
|
next_lba++;
|
|
}
|
|
|
|
delete [] sector_buf;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void PartitionHandle::AddPartition(const char * name, u64 lba_start, u64 sec_count, bool bootable, u8 part_type, u8 part_num)
|
|
{
|
|
char buffer[BYTES_PER_SECTOR];
|
|
|
|
if (!interface->readSectors(lba_start, 1, buffer))
|
|
return;
|
|
|
|
wbfs_head_t *head = (wbfs_head_t *) buffer;
|
|
|
|
if (head->magic == wbfs_htonl(WBFS_MAGIC))
|
|
{
|
|
name = "WBFS";
|
|
part_type = 0xBF; //Override partition type on WBFS
|
|
}
|
|
|
|
PartitionFS PartitionEntrie;
|
|
PartitionEntrie.FSName = name;
|
|
PartitionEntrie.LBA_Start = lba_start;
|
|
PartitionEntrie.SecCount = sec_count;
|
|
PartitionEntrie.Bootable = bootable;
|
|
PartitionEntrie.PartitionType = part_type;
|
|
PartitionEntrie.PartitionNum = part_num;
|
|
|
|
PartitionList.push_back(PartitionEntrie);
|
|
|
|
}
|