The-Homebrew-Cloud/usbloadergx
2
0
Fork 0
mirror of https://github.com/wiidev/usbloadergx.git synced 2024-11-22 03:09:15 +01:00
Code Issues Packages Projects Releases Wiki Activity

*let's get rid of last compile warning

Browse Source
This commit is contained in:
dimok321 2010-09-24 15:08:03 +00:00
parent f8c1692809
commit 5bf2c813b6
2 changed files with 420 additions and 419 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
HBC/META.XML
View File

@ -2,8 +2,8 @@
<app version="1">
<name> USB Loader GX</name>
<coder>USB Loader GX Team</coder>
<version>1.0 r967</version>
<release_date>201009241313</release_date>
<version>1.0 r968</version>
<release_date>201009241346</release_date>
<short_description>Loads games from USB-devices</short_description>
<long_description>USB Loader GX is a libwiigui based USB iso loader with a wii-like GUI. You can install games to your HDDs and boot them with shorter loading times.
The interactive GUI is completely controllable with WiiMote, Classic Controller or GC Controller.

835
source/usbloader/partition_usbloader.c
View File

@ -1,417 +1,418 @@
// Modified by oggzee
#include <stdio.h>
#include <string.h>
#include <ogcsys.h>
#include <unistd.h>
#include "partition_usbloader.h"
#include "sdhc.h"
#include "usbstorage2.h"
#include "utils.h"
#include "wbfs.h"
#include "libwbfs/libwbfs.h"
/* 'partition table' structure */
typedef struct
{
/* Zero bytes */
u8 padding[446];
/* Partition table entries */
partitionEntry entries[MAX_PARTITIONS];
}ATTRIBUTE_PACKED partitionTable;
s32 Partition_GetEntries(u32 device, partitionEntry *outbuf, u32 *outval)
{
static partitionTable table ATTRIBUTE_ALIGN( 32 );
u32 cnt, sector_size;
s32 ret;
/* Read from specified device */
switch (device)
{
case WBFS_DEVICE_USB:
{
/* Get sector size */
ret = USBStorage2_GetCapacity(&sector_size);
if (ret == 0) return -1;
/* Read partition table */
ret = USBStorage2_ReadSectors(0, 1, &table);
if (ret < 0) return ret;
break;
}
case WBFS_DEVICE_SDHC:
{
/* SDHC sector size */
sector_size = SDHC_SECTOR_SIZE;
/* Read partition table */
ret = SDHC_ReadSectors(0, 1, &table);
if (!ret) return -1;
break;
}
default:
return -1;
}
/* Swap endianess */
for (cnt = 0; cnt < 4; cnt++)
{
partitionEntry *entry = &table.entries[cnt];
entry->sector = swap32(entry->sector);
entry->size = swap32(entry->size);
}
/* Set partition entries */
memcpy(outbuf, table.entries, sizeof(table.entries));
/* Set sector size */
*outval = sector_size;
return 0;
}
bool Device_ReadSectors(u32 device, u32 sector, u32 count, void *buffer)
{
s32 ret;
/* Read from specified device */
switch (device)
{
case WBFS_DEVICE_USB:
ret = USBStorage2_ReadSectors(sector, count, buffer);
if (ret < 0) return false;
return true;
case WBFS_DEVICE_SDHC:
return SDHC_ReadSectors(sector, count, buffer);
}
return false;
}
bool Device_WriteSectors(u32 device, u32 sector, u32 count, void *buffer)
{
s32 ret;
/* Read from specified device */
switch (device)
{
case WBFS_DEVICE_USB:
ret = USBStorage2_WriteSectors(sector, count, buffer);
if (ret < 0) return false;
return true;
case WBFS_DEVICE_SDHC:
return SDHC_WriteSectors(sector, count, buffer);
}
return false;
}
s32 Partition_GetEntriesEx(u32 device, partitionEntry *outbuf, u32 *psect_size, u8 *num)
{
static partitionTable table ATTRIBUTE_ALIGN( 32 );
partitionEntry *entry;
u32 i, sector_size;
s32 ret;
int maxpart = *num;
// Get sector size
switch (device)
{
case WBFS_DEVICE_USB:
ret = USBStorage2_GetCapacity(&sector_size);
if (ret == 0) return -1;
break;
case WBFS_DEVICE_SDHC:
sector_size = SDHC_SECTOR_SIZE;
break;
default:
return -1;
}
/* Set sector size */
*psect_size = sector_size;
u32 ext = 0;
u32 next = 0;
// Read partition table
ret = Device_ReadSectors(device, 0, 1, &table);
if (!ret) return -1;
// Check if it's a RAW WBFS disc, without partition table
if (get_fs_type(&table) == FS_TYPE_WBFS)
{
memset(outbuf, 0, sizeof(table.entries));
wbfs_head_t *head = (wbfs_head_t*) &table;
outbuf->size = wbfs_ntohl( head->n_hd_sec );
*num = 1;
return 0;
}
/* Swap endianess */
for (i = 0; i < 4; i++)
{
entry = &table.entries[i];
entry->sector = swap32(entry->sector);
entry->size = swap32(entry->size);
if (!ext && part_is_extended(entry->type))
{
ext = entry->sector;
}
}
/* Set partition entries */
memcpy(outbuf, table.entries, sizeof(table.entries));
// num primary
*num = 4;
if (!ext) return 0;
next = ext;
// scan extended partition for logical
for (i = 0; i < maxpart - 4; i++)
{
ret = Device_ReadSectors(device, next, 1, &table);
if (!ret) break;
if (i == 0)
{
// handle the invalid scenario where wbfs is on an EXTENDED
// partition instead of on the Logical inside Extended.
if (get_fs_type(&table) == FS_TYPE_WBFS) break;
}
entry = &table.entries[0];
entry->sector = swap32(entry->sector);
entry->size = swap32(entry->size);
if (entry->type && entry->size && entry->sector)
{
// rebase to abolute address
entry->sector += next;
// add logical
memcpy(&outbuf[*num], entry, sizeof(*entry));
(*num)++;
// get next
entry++;
if (entry->type && entry->size && entry->sector)
{
next = ext + swap32(entry->sector);
}
else
{
break;
}
}
}
return 0;
}
bool part_is_extended(int type)
{
if (type == 0x05) return true;
if (type == 0x0f) return true;
return false;
}
bool part_is_data(int type)
{
if (type && !part_is_extended(type)) return true;
return false;
}
bool part_valid_data(partitionEntry *entry)
{
if (entry->size && entry->type && entry->sector)
{
return part_is_data(entry->type);
}
return false;
}
char* part_type_data(int type)
{
switch (type)
{
case 0x01:
return "FAT12";
case 0x04:
return "FAT16";
case 0x06:
return "FAT16"; //+
case 0x07:
return "NTFS";
case 0x0b:
return "FAT32";
case 0x0c:
return "FAT32";
case 0x0e:
return "FAT16";
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 0xe8:
return "LUKS";
}
return NULL;
}
char *part_type_name(int type)
{
static char unk[8];
if (type == 0) return "UNUSED";
if (part_is_extended(type)) return "EXTEND";
char *p = part_type_data(type);
if (p) return p;
sprintf(unk, "UNK-%02x", type);
return unk;
}
int get_fs_type(void *buff)
{
char *buf = buff;
// WBFS
wbfs_head_t *head = (wbfs_head_t *) buff;
if (head->magic == wbfs_htonl( WBFS_MAGIC )) return FS_TYPE_WBFS;
// 55AA
if (buf[0x1FE] == 0x55 && buf[0x1FF] == 0xAA)
{
// FAT
if (memcmp(buf + 0x36, "FAT", 3) == 0) return FS_TYPE_FAT16;
if (memcmp(buf + 0x52, "FAT", 3) == 0) return FS_TYPE_FAT32;
// NTFS
if (memcmp(buf + 0x03, "NTFS", 4) == 0) return FS_TYPE_NTFS;
}
return FS_TYPE_UNK;
}
int get_part_fs(int fs_type)
{
switch (fs_type)
{
case FS_TYPE_FAT32:
return PART_FS_FAT;
case FS_TYPE_NTFS:
return PART_FS_NTFS;
case FS_TYPE_WBFS:
return PART_FS_WBFS;
default:
return -1;
}
}
bool is_type_fat(int type)
{
return (type == FS_TYPE_FAT16 || type == FS_TYPE_FAT32);
}
char *get_fs_name(int i)
{
switch (i)
{
case FS_TYPE_FAT16:
return "FAT16";
case FS_TYPE_FAT32:
return "FAT32";
case FS_TYPE_NTFS:
return "NTFS";
case FS_TYPE_WBFS:
return "WBFS";
}
return "";
}
s32 Partition_GetList(u32 device, PartList *plist)
{
partitionEntry *entry = NULL;
PartInfo *pinfo = NULL;
int i, ret;
memset(plist, 0, sizeof(PartList));
// Get partition entries
plist->num = MAX_PARTITIONS_EX;
ret = Partition_GetEntriesEx(device, plist->pentry, &plist->sector_size, &plist->num);
if (ret < 0)
{
return -1;
}
// check for RAW WBFS disc
if (plist->num == 1)
{
pinfo = &plist->pinfo[0];
entry = &plist->pentry[0];
plist->wbfs_n = 1;
pinfo->wbfs_i = pinfo->index = 1;
return 0;
}
char buf[plist->sector_size];
// scan partitions for filesystem type
for (i = 0; i < plist->num; i++)
{
pinfo = &plist->pinfo[i];
entry = &plist->pentry[i];
if (!entry->size) continue;
if (!entry->type) continue;
if (!entry->sector) continue;
// even though wrong, it's possible WBFS is on an extended part.
//if (!part_is_data(entry->type)) continue;
if (!Device_ReadSectors(device, entry->sector, 1, buf)) continue;
pinfo->fs_type = get_fs_type(buf);
if (pinfo->fs_type == FS_TYPE_WBFS)
{
// multiple wbfs on sdhc not supported
if (device == WBFS_DEVICE_SDHC && (plist->wbfs_n > 1 || i > 4)) continue;
plist->wbfs_n++;
pinfo->wbfs_i = pinfo->index = plist->wbfs_n;
}
else if (is_type_fat(pinfo->fs_type))
{
plist->fat_n++;
pinfo->fat_i = pinfo->index = plist->fat_n;
}
else if (pinfo->fs_type == FS_TYPE_NTFS)
{
plist->ntfs_n++;
pinfo->ntfs_i = pinfo->index = plist->ntfs_n;
}
pinfo->part_fs = get_part_fs(pinfo->fs_type);
}
return 0;
}
int Partition_FixEXT(u32 device, u8 part)
{
static partitionTable table ATTRIBUTE_ALIGN( 32 );
int ret;
if (part > 3) return -1;
// Read partition table
ret = Device_ReadSectors(device, 0, 1, &table);
if (!ret) return -1;
if (part_is_extended(table.entries[part].type))
{
table.entries[part].type = 0x0b; // FAT32
ret = Device_WriteSectors(device, 0, 1, &table);
if (!ret) return -1;
return 0;
}
return -1;
}
// Modified by oggzee
#include <stdio.h>
#include <string.h>
#include <ogcsys.h>
#include <unistd.h>
#include "partition_usbloader.h"
#include "sdhc.h"
#include "usbstorage2.h"
#include "utils.h"
#include "wbfs.h"
#include "libwbfs/libwbfs.h"
/* 'partition table' structure */
typedef struct
{
/* Zero bytes */
u8 padding[446];
/* Partition table entries */
partitionEntry entries[MAX_PARTITIONS];
}ATTRIBUTE_PACKED partitionTable;
s32 Partition_GetEntries(u32 device, partitionEntry *outbuf, u32 *outval)
{
static partitionTable table ATTRIBUTE_ALIGN( 32 );
u32 cnt, sector_size;
s32 ret;
/* Read from specified device */
switch (device)
{
case WBFS_DEVICE_USB:
{
/* Get sector size */
ret = USBStorage2_GetCapacity(&sector_size);
if (ret == 0) return -1;
/* Read partition table */
ret = USBStorage2_ReadSectors(0, 1, &table);
if (ret < 0) return ret;
break;
}
case WBFS_DEVICE_SDHC:
{
/* SDHC sector size */
sector_size = SDHC_SECTOR_SIZE;
/* Read partition table */
ret = SDHC_ReadSectors(0, 1, &table);
if (!ret) return -1;
break;
}
default:
return -1;
}
/* Swap endianess */
for (cnt = 0; cnt < 4; cnt++)
{
partitionEntry *entry = &table.entries[cnt];
entry->sector = swap32(entry->sector);
entry->size = swap32(entry->size);
}
/* Set partition entries */
memcpy(outbuf, table.entries, sizeof(table.entries));
/* Set sector size */
*outval = sector_size;
return 0;
}
bool Device_ReadSectors(u32 device, u32 sector, u32 count, void *buffer)
{
s32 ret;
/* Read from specified device */
switch (device)
{
case WBFS_DEVICE_USB:
ret = USBStorage2_ReadSectors(sector, count, buffer);
if (ret < 0) return false;
return true;
case WBFS_DEVICE_SDHC:
return SDHC_ReadSectors(sector, count, buffer);
}
return false;
}
bool Device_WriteSectors(u32 device, u32 sector, u32 count, void *buffer)
{
s32 ret;
/* Read from specified device */
switch (device)
{
case WBFS_DEVICE_USB:
ret = USBStorage2_WriteSectors(sector, count, buffer);
if (ret < 0) return false;
return true;
case WBFS_DEVICE_SDHC:
return SDHC_WriteSectors(sector, count, buffer);
}
return false;
}
s32 Partition_GetEntriesEx(u32 device, partitionEntry *outbuf, u32 *psect_size, u8 *num)
{
static u8 Buffer[sizeof(partitionTable)] ATTRIBUTE_ALIGN( 32 );
partitionTable *table = (partitionTable *) Buffer;
partitionEntry *entry;
u32 i, sector_size;
s32 ret;
int maxpart = *num;
// Get sector size
switch (device)
{
case WBFS_DEVICE_USB:
ret = USBStorage2_GetCapacity(&sector_size);
if (ret == 0) return -1;
break;
case WBFS_DEVICE_SDHC:
sector_size = SDHC_SECTOR_SIZE;
break;
default:
return -1;
}
/* Set sector size */
*psect_size = sector_size;
u32 ext = 0;
u32 next = 0;
// Read partition table
ret = Device_ReadSectors(device, 0, 1, table);
if (!ret) return -1;
// Check if it's a RAW WBFS disc, without partition table
if (get_fs_type(table) == FS_TYPE_WBFS)
{
memset(outbuf, 0, sizeof(table->entries));
wbfs_head_t * head = (wbfs_head_t *) Buffer;
outbuf->size = wbfs_ntohl( head->n_hd_sec );
*num = 1;
return 0;
}
/* Swap endianess */
for (i = 0; i < 4; i++)
{
entry = &table->entries[i];
entry->sector = swap32(entry->sector);
entry->size = swap32(entry->size);
if (!ext && part_is_extended(entry->type))
{
ext = entry->sector;
}
}
/* Set partition entries */
memcpy(outbuf, table->entries, sizeof(table->entries));
// num primary
*num = 4;
if (!ext) return 0;
next = ext;
// scan extended partition for logical
for (i = 0; i < maxpart - 4; i++)
{
ret = Device_ReadSectors(device, next, 1, table);
if (!ret) break;
if (i == 0)
{
// handle the invalid scenario where wbfs is on an EXTENDED
// partition instead of on the Logical inside Extended.
if (get_fs_type(&table) == FS_TYPE_WBFS) break;
}
entry = &table->entries[0];
entry->sector = swap32(entry->sector);
entry->size = swap32(entry->size);
if (entry->type && entry->size && entry->sector)
{
// rebase to abolute address
entry->sector += next;
// add logical
memcpy(&outbuf[*num], entry, sizeof(*entry));
(*num)++;
// get next
entry++;
if (entry->type && entry->size && entry->sector)
{
next = ext + swap32(entry->sector);
}
else
{
break;
}
}
}
return 0;
}
bool part_is_extended(int type)
{
if (type == 0x05) return true;
if (type == 0x0f) return true;
return false;
}
bool part_is_data(int type)
{
if (type && !part_is_extended(type)) return true;
return false;
}
bool part_valid_data(partitionEntry *entry)
{
if (entry->size && entry->type && entry->sector)
{
return part_is_data(entry->type);
}
return false;
}
char* part_type_data(int type)
{
switch (type)
{
case 0x01:
return "FAT12";
case 0x04:
return "FAT16";
case 0x06:
return "FAT16"; //+
case 0x07:
return "NTFS";
case 0x0b:
return "FAT32";
case 0x0c:
return "FAT32";
case 0x0e:
return "FAT16";
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 0xe8:
return "LUKS";
}
return NULL;
}
char *part_type_name(int type)
{
static char unk[8];
if (type == 0) return "UNUSED";
if (part_is_extended(type)) return "EXTEND";
char *p = part_type_data(type);
if (p) return p;
sprintf(unk, "UNK-%02x", type);
return unk;
}
int get_fs_type(void *buff)
{
char *buf = buff;
// WBFS
wbfs_head_t *head = (wbfs_head_t *) buff;
if (head->magic == wbfs_htonl( WBFS_MAGIC )) return FS_TYPE_WBFS;
// 55AA
if (buf[0x1FE] == 0x55 && buf[0x1FF] == 0xAA)
{
// FAT
if (memcmp(buf + 0x36, "FAT", 3) == 0) return FS_TYPE_FAT16;
if (memcmp(buf + 0x52, "FAT", 3) == 0) return FS_TYPE_FAT32;
// NTFS
if (memcmp(buf + 0x03, "NTFS", 4) == 0) return FS_TYPE_NTFS;
}
return FS_TYPE_UNK;
}
int get_part_fs(int fs_type)
{
switch (fs_type)
{
case FS_TYPE_FAT32:
return PART_FS_FAT;
case FS_TYPE_NTFS:
return PART_FS_NTFS;
case FS_TYPE_WBFS:
return PART_FS_WBFS;
default:
return -1;
}
}
bool is_type_fat(int type)
{
return (type == FS_TYPE_FAT16 || type == FS_TYPE_FAT32);
}
char *get_fs_name(int i)
{
switch (i)
{
case FS_TYPE_FAT16:
return "FAT16";
case FS_TYPE_FAT32:
return "FAT32";
case FS_TYPE_NTFS:
return "NTFS";
case FS_TYPE_WBFS:
return "WBFS";
}
return "";
}
s32 Partition_GetList(u32 device, PartList *plist)
{
partitionEntry *entry = NULL;
PartInfo *pinfo = NULL;
int i, ret;
memset(plist, 0, sizeof(PartList));
// Get partition entries
plist->num = MAX_PARTITIONS_EX;
ret = Partition_GetEntriesEx(device, plist->pentry, &plist->sector_size, &plist->num);
if (ret < 0)
{
return -1;
}
// check for RAW WBFS disc
if (plist->num == 1)
{
pinfo = &plist->pinfo[0];
entry = &plist->pentry[0];
plist->wbfs_n = 1;
pinfo->wbfs_i = pinfo->index = 1;
return 0;
}
char buf[plist->sector_size];
// scan partitions for filesystem type
for (i = 0; i < plist->num; i++)
{
pinfo = &plist->pinfo[i];
entry = &plist->pentry[i];
if (!entry->size) continue;
if (!entry->type) continue;
if (!entry->sector) continue;
// even though wrong, it's possible WBFS is on an extended part.
//if (!part_is_data(entry->type)) continue;
if (!Device_ReadSectors(device, entry->sector, 1, buf)) continue;
pinfo->fs_type = get_fs_type(buf);
if (pinfo->fs_type == FS_TYPE_WBFS)
{
// multiple wbfs on sdhc not supported
if (device == WBFS_DEVICE_SDHC && (plist->wbfs_n > 1 || i > 4)) continue;
plist->wbfs_n++;
pinfo->wbfs_i = pinfo->index = plist->wbfs_n;
}
else if (is_type_fat(pinfo->fs_type))
{
plist->fat_n++;
pinfo->fat_i = pinfo->index = plist->fat_n;
}
else if (pinfo->fs_type == FS_TYPE_NTFS)
{
plist->ntfs_n++;
pinfo->ntfs_i = pinfo->index = plist->ntfs_n;
}
pinfo->part_fs = get_part_fs(pinfo->fs_type);
}
return 0;
}
int Partition_FixEXT(u32 device, u8 part)
{
static partitionTable table ATTRIBUTE_ALIGN( 32 );
int ret;
if (part > 3) return -1;
// Read partition table
ret = Device_ReadSectors(device, 0, 1, &table);
if (!ret) return -1;
if (part_is_extended(table.entries[part].type))
{
table.entries[part].type = 0x0b; // FAT32
ret = Device_WriteSectors(device, 0, 1, &table);
if (!ret) return -1;
return 0;
}
return -1;
}