usbloadergx/source/wad/nandtitle.cpp

#include "nandtitle.h"
#include "gecko.h"

extern "C"
{
    extern s32 MagicPatches(s32);
}

static u8 tmd_buf[ MAX_SIGNED_TMD_SIZE ] ATTRIBUTE_ALIGN( 32 );

NandTitle::NandTitle()
{
    numTitles = 0;
    currentIndex = 0;
    currentType = 0;
    list = NULL;
    nameList = NULL;
}

NandTitle::~NandTitle()
{
    if( list )
    {
	free( list );
	list = NULL;
    }

    if( nameList )
    {
	free( nameList );
	nameList = NULL;
    }
}

s32 NandTitle::Get()
{
    s32 ret;

    if( list )
    {
	free( list );
	list = NULL;
    }

    if( nameList )
    {
	free( nameList );
	nameList = NULL;
    }

    ret = ES_GetNumTitles( &numTitles );
    if(ret < 0)
	    return WII_EINTERNAL;

    list = (u64*)memalign( 32, numTitles * sizeof( u64 ) );
    if( !list )
    {
	return -1;
    }

    ret = ES_GetTitles( list, numTitles );
    if( ret < 0 )
    {
	free( list );
	return WII_EINTERNAL;
    }

    nameList = (char*)malloc( IMET_MAX_NAME_LEN * numTitles );
    if( !nameList )
    {
	free( nameList );
	return -2;
    }
    memset( nameList, 0, IMET_MAX_NAME_LEN * numTitles );

    MagicPatches( 1 );
    int language = CONF_GetLanguage();
    ISFS_Initialize();

    wchar_t name[ IMET_MAX_NAME_LEN ];

    for( u32 i = 0; i < numTitles; i++)
    {
	bool r = GetName( list[ i ], language, name );
	if( r )
	{
	    wString *wsname = new wString( name );
	    memcpy( nameList + ( IMET_MAX_NAME_LEN * i ), (wsname->toUTF8()).c_str(), strlen( (wsname->toUTF8()).c_str() ) );
	    //gprintf("adding: %s\n", (wsname->toUTF8()).c_str() );
	    delete wsname;
	}
    }

    ISFS_Deinitialize();
    MagicPatches( 0 );
    return 1;
}

tmd* NandTitle::GetTMD( u64 tid )
{
    //gprintf("GetTMD( %016llx ): ", tid );
    signed_blob *s_tmd = (signed_blob *)tmd_buf;
    u32 tmd_size;

    if( ES_GetStoredTMDSize( tid, &tmd_size ) < 0 )
    {
	//gprintf("!size\n");
	return NULL;
    }

    s32 ret = ES_GetStoredTMD( tid, s_tmd, tmd_size );
    if( ret < 0 )
    {
	//gprintf("!tmd - %04x\n", ret );
	return NULL;
    }

    tmd *t = (tmd*)SIGNATURE_PAYLOAD(s_tmd);
    //gprintf("ok\n");

    return t;
}

bool NandTitle::GetName( u64 tid, int language, wchar_t* name )
{
    if( TITLE_UPPER( tid ) != 0x10001 && TITLE_UPPER( tid ) != 0x10002 && TITLE_UPPER( tid ) != 0x10004 )
	return false;
    //gprintf("GetName( %016llx ): ", tid );
    char app[ ISFS_MAXPATH ];
    IMET *imet = (IMET*)memalign( 32, sizeof( IMET ) );

    tmd* titleTmd = GetTMD( tid );
    if( !titleTmd )
    {
	//gprintf("no TMD\n");
	free( imet );
	return false;
    }

    u16 i;
    bool ok = false;
    for( i = 0; i < titleTmd->num_contents; i++ )
    {
	if( !titleTmd->contents[ i ].index )
	{
	    ok = true;
	    break;
	}
    }
    if( !ok )
    {
	free( imet );
	return false;
    }

    snprintf( app, sizeof( app ), "/title/%08x/%08x/content/%08x.app", TITLE_UPPER( tid ), TITLE_LOWER( tid ), titleTmd->contents[ i ].cid );
    //gprintf("%s\n", app );

    if( language > CONF_LANG_KOREAN )
	    language = CONF_LANG_ENGLISH;

    s32 fd = ISFS_Open( app, ISFS_OPEN_READ );
    if( fd < 0 )
    {
	//gprintf("fd: %d\n", fd );
	free( imet );
	return false;
    }

    if( ISFS_Seek( fd, IMET_OFFSET, SEEK_SET ) != IMET_OFFSET )
    {
	ISFS_Close( fd );
	free( imet );
	return false;
    }

    if( ISFS_Read( fd, imet, sizeof( IMET ) ) != sizeof( IMET ) )
    {
	ISFS_Close( fd );
	free( imet );
	return false;
    }

    ISFS_Close( fd );

    if( imet->sig != IMET_SIGNATURE )
    {
	free( imet );
	return false;
    }

    if( imet->name_japanese[ language * IMET_MAX_NAME_LEN ] == 0 )
    {
	// channel name is not available in system language
	if( imet->name_english[ 0 ] != 0 )
	{
	    language = CONF_LANG_ENGLISH;
	}
	else
	{
	    // channel name is also not available on english, get ascii name
	    for (int i = 0; i < 4; i++)
	    {
		name[ i ] = ( TITLE_LOWER( tid ) >> ( 24 - i * 8 ) ) & 0xFF;
	    }
	    name[ 4 ] = 0;
	    free( imet );
	    return true;
	}
    }

    // retrieve channel name in system language or on english
    for( int i = 0; i < IMET_MAX_NAME_LEN; i++ )
    {
	name[ i ] = imet->name_japanese[ i + ( language * IMET_MAX_NAME_LEN ) ];
    }

    free( imet );

    return true;
}

bool NandTitle::Exists( u64 tid )
{
    char app[ ISFS_MAXPATH ];
    tmd* titleTmd = GetTMD( tid );
    if( !titleTmd )
    	return false;

    u16 i;
    bool ok = false;
    for( i = 0; i < titleTmd->num_contents; i++ )
    {
	if( !titleTmd->contents[ i ].index )
	{
	    ok = true;
	    break;
	}
    }
    if( !ok )
	return false;


    snprintf( app, sizeof( app ), "/title/%08x/%08x/content/%08x.app", TITLE_UPPER( tid ), TITLE_LOWER( tid ), titleTmd->contents[ i ].cid );
    s32 fd = ISFS_Open( app, ISFS_OPEN_READ );
    if( fd >= 0 )
	ISFS_Close( fd );

    //gprintf(" fd: %d\n", fd );
    return fd >= 0 || fd == -102; //102 means it exists, but we dont have permission to open it

}

bool NandTitle::ExistsFromIndex( u32 i )
{
    if( i > numTitles || i < 0 )
	return false;

    return Exists( list[ i ] );
}

u64 NandTitle::At( u32 i )
{
    if( i > numTitles || i < 0 )
	return 0;

    return list[ i ];
}

int NandTitle::IndexOf( u64 tid )
{
    for( u32 i = 0; i < numTitles; i++ )
    {
	if( list[ i ] == tid )
	    return i;
    }

    return WII_EINSTALL;
}

char* NandTitle::NameOf( u64 tid )
{
    for( u32 i = 0; i < numTitles; i++ )
    {
	if( list[ i ] == tid )
	{
	    if( !nameList[ IMET_MAX_NAME_LEN * i ] )
		return NULL;

	    return nameList + ( IMET_MAX_NAME_LEN * i );
	}

    }
    return NULL;

}

char* NandTitle::NameFromIndex( u32 i )
{
    if( i > numTitles || i < 0 )
	return NULL;

    if( !nameList[ IMET_MAX_NAME_LEN * i ] )
	return NULL;

    return nameList + ( IMET_MAX_NAME_LEN * i );
}

u16 NandTitle::VersionOf( u64 tid )
{
    for( u32 i = 0; i < numTitles; i++ )
    {
	if( list[ i ] == tid )
	{
	    tmd* Tmd = GetTMD( tid );
	    if( !Tmd )
		break;

	    return Tmd->title_version;
	}
    }
    return 0;

}

u16 NandTitle::VersionFromIndex( u32 i )
{
    if( i > numTitles || i < 0 )
	return 0;

    tmd* Tmd = GetTMD( list[ i ] );
    if( !Tmd )
	return 0;

    return Tmd->title_version;
}

u32 NandTitle::CountType( u32 type )
{
    u32 ret = 0;
    for( u32 i = 0; i < numTitles; i++ )
    {
	if( TITLE_UPPER( list[ i ] ) == type )
	{
	    ret++;
	}
    }
    return ret;
}

u32 NandTitle::SetType( u32 upper )
{
    currentType = upper;
    currentIndex = 0;

    return CountType( upper );
}

u64 NandTitle::Next()
{
    u64 ret = 0;
    //gprintf("Next( %08x, %u )\n", currentType, currentIndex );
    u32 i;
    for( i = currentIndex; i < numTitles; i++ )
    {
	if( currentType )
	{
	    if( currentType == TITLE_UPPER( list[ i ] ) )
	    {
		ret = list[ i ];
		break;
	    }
	}
	else
	{
	    ret = list[ i ];
	    break;
	}
    }
    currentIndex = i + 1;

    return ret;
}

void NandTitle::ResetCounter()
{
    currentIndex = 0;
}

void NandTitle::AsciiTID( u64 tid, char* out )
{
    //gprintf("AsciiTID( %016llx ): ");
    out[ 0 ] = ascii( TITLE_3( tid ) );
    out[ 1 ] = ascii( TITLE_2( tid ) );
    out[ 2 ] = ascii( TITLE_1( tid ) );
    out[ 3 ] = ascii( (u8)( tid ) );
    out[ 4 ] = 0;
    //gprintf("%s\n", out );
}

void NandTitle::AsciiFromIndex( u32 i, char* out )
{
    if( i > numTitles || i < 0 )
    {
	out[ 0 ] = 0;
	return;
    }

    AsciiTID( list[ i ], out );
}

s32 NandTitle::GetTicketViews( u64 tid, tikview **outbuf, u32 *outlen )
{
    tikview *views = NULL;

    u32 nb_views;
    s32 ret;

    /* Get number of ticket views */
    ret = ES_GetNumTicketViews(tid, &nb_views);
    if (ret < 0)
	return ret;

    /* Allocate memory */
    views = (tikview *)memalign(32, sizeof(tikview) * nb_views);
    if (!views)
	return -1;

    /* Get ticket views */
    ret = ES_GetTicketViews(tid, views, nb_views);
    if (ret < 0)
	goto err;

    /* Set values */
    *outbuf = views;
    *outlen = nb_views;

    return 0;

err:
    /* Free memory */
    if (views)
	free(views);

    return ret;
}