/****************************************************************************
* autoSaveMethod()
* Auto-determines and sets the save device
* Returns device set
****************************************************************************/
int autoSaveMethod(bool silent)
{
if(!silent)
ShowAction ("Attempting to determine save device...");
int device = DEVICE_AUTO;
if(ChangeInterface(DEVICE_SD, SILENT))
device = DEVICE_SD;
else if(ChangeInterface(DEVICE_USB, SILENT))
device = DEVICE_USB;
else if(ChangeInterface(DEVICE_SD_SLOTA, SILENT))
device = DEVICE_SD_SLOTA;
else if(ChangeInterface(DEVICE_SD_SLOTB, SILENT))
device = DEVICE_SD_SLOTB;
else if(ChangeInterface(DEVICE_SMB, SILENT))
device = DEVICE_SMB;
else if(!silent)
ErrorPrompt("Unable to locate a save device!");
if(GCSettings.SaveMethod == DEVICE_AUTO)
GCSettings.SaveMethod = device; // save device found for later use
CancelAction();
return device;
}
int
ParseDirectory()
{
bool mounted = false;
ResetBrowser(); // reset browser
// add trailing slash
if(browser.dir[strlen(browser.dir)-1] != '/')
strcat(browser.dir, "/");
mounted = ChangeInterface(browser.dir, SILENT);
if(mounted){
dir = opendir(browser.dir);
if(dir == NULL){ //Profile folder not found, attempt to create it.
char temp[128];
strcpy(temp, browser.dir);
temp[strlen(browser.dir)-1] = 0;
mkdir(temp, 0777);
dir = opendir(browser.dir);
}
}else{
return -1;
}
if (dir == NULL) return -1;
ParseProfilesDir(); // index first 20 entries
return browser.numEntries;
}
void CreateAppPath(char * origpath)
{
if(!origpath || origpath[0] == 0)
return;
char * path = strdup(origpath); // make a copy so we don't mess up original
if(!path)
return;
char * loc = strrchr(path,'/');
if (loc != NULL)
*loc = 0; // strip file name
int pos = 0;
// replace fat:/ with sd:/
if(strncmp(path, "fat:/", 5) == 0)
{
pos++;
path[1] = 's';
path[2] = 'd';
}
if(ChangeInterface(&path[pos], SILENT))
snprintf(appPath, MAXPATHLEN-1, "%s", &path[pos]);
free(path);
}
int LibusbDevice::SubmitTransfer(std::unique_ptr<CtrlMessage> cmd)
{
if (!m_device_attached)
return LIBUSB_ERROR_NOT_FOUND;
DEBUG_LOG(IOS_USB,
"[%04x:%04x %d] Control: bRequestType=%02x bRequest=%02x wValue=%04x"
" wIndex=%04x wLength=%04x",
m_vid, m_pid, m_active_interface, cmd->request_type, cmd->request, cmd->value,
cmd->index, cmd->length);
switch ((cmd->request_type << 8) | cmd->request)
{
// The following requests have to go through libusb and cannot be directly sent to the device.
case USBHDR(DIR_HOST2DEVICE, TYPE_STANDARD, REC_INTERFACE, REQUEST_SET_INTERFACE):
{
INFO_LOG(IOS_USB, "[%04x:%04x %d] REQUEST_SET_INTERFACE index=%04x value=%04x", m_vid, m_pid,
m_active_interface, cmd->index, cmd->value);
if (static_cast<u8>(cmd->index) != m_active_interface)
{
const int ret = ChangeInterface(static_cast<u8>(cmd->index));
if (ret < 0)
{
ERROR_LOG(IOS_USB, "[%04x:%04x %d] Failed to change interface to %d: %s", m_vid, m_pid,
m_active_interface, cmd->index, libusb_error_name(ret));
return ret;
}
}
const int ret = SetAltSetting(static_cast<u8>(cmd->value));
if (ret == 0)
m_ios.EnqueueIPCReply(cmd->ios_request, cmd->length);
return ret;
}
case USBHDR(DIR_HOST2DEVICE, TYPE_STANDARD, REC_DEVICE, REQUEST_SET_CONFIGURATION):
{
INFO_LOG(IOS_USB, "[%04x:%04x %d] REQUEST_SET_CONFIGURATION index=%04x value=%04x", m_vid,
m_pid, m_active_interface, cmd->index, cmd->value);
ReleaseAllInterfacesForCurrentConfig();
const int ret = libusb_set_configuration(m_handle, cmd->value);
if (ret == 0)
{
ClaimAllInterfaces(cmd->value);
m_ios.EnqueueIPCReply(cmd->ios_request, cmd->length);
}
return ret;
}
}
const size_t size = cmd->length + LIBUSB_CONTROL_SETUP_SIZE;
auto buffer = std::make_unique<u8[]>(size);
libusb_fill_control_setup(buffer.get(), cmd->request_type, cmd->request, cmd->value, cmd->index,
cmd->length);
Memory::CopyFromEmu(buffer.get() + LIBUSB_CONTROL_SETUP_SIZE, cmd->data_address, cmd->length);
libusb_transfer* transfer = libusb_alloc_transfer(0);
transfer->flags |= LIBUSB_TRANSFER_FREE_TRANSFER;
libusb_fill_control_transfer(transfer, m_handle, buffer.release(), CtrlTransferCallback, this, 0);
m_transfer_endpoints[0].AddTransfer(std::move(cmd), transfer);
return libusb_submit_transfer(transfer);
}
bool ChangeInterface(char * filepath, bool silent)
{
int device = -1;
if(!FindDevice(filepath, &device))
return false;
return ChangeInterface(device, silent);
}
bool ChangeInterface(char * filepath, int retryCount )
{
int device = -1;
if(!FindDevice(filepath, &device))
return false;
return ChangeInterface(device, retryCount );
}
bool CsBaseApplication::Run() {
if (!Init()) return false;
while (!mShutdown) {
mMenu = new CsMenu(mRoot, mWindow, mViewport, mSceneMgr);
ChangeInterface(mMenu);
int result = mMenu->Run();
delete mMenu; mMenu = NULL;
switch(result) {
case MENU_START_GAME:
CsGame::Create(mRoot, mWindow, mViewport, mSceneMgr);
mGame = CsGame::GetSingletonPtr();
ChangeInterface(mGame);
assert(mGame);
mGame->Run();
CsGame::Destroy();
mGame = NULL;
break;
case MENU_CREDITS:
case MENU_DEMO:
break;
case MENU_EXIT:
mShutdown = true;
break;
default:
break;
};
Ogre::WindowEventUtilities::messagePump();
//break;
// for test purposes, run only once
}
Cleanup();
return true;
}
bool LibusbDevice::AttachAndChangeInterface(const u8 interface)
{
if (!Attach())
return false;
if (interface != m_active_interface)
return ChangeInterface(interface) == 0;
return true;
}
/****************************************************************************
* autoLoadMethod()
* Auto-determines and sets the load device
* Returns device set
****************************************************************************/
int autoLoadMethod()
{
ShowAction ("Attempting to determine load device...");
int device = DEVICE_AUTO;
if(ChangeInterface(DEVICE_SD, SILENT))
device = DEVICE_SD;
else if(ChangeInterface(DEVICE_USB, SILENT))
device = DEVICE_USB;
else if(ChangeInterface(DEVICE_SD_SLOTA, SILENT))
device = DEVICE_SD_SLOTA;
else if(ChangeInterface(DEVICE_SD_SLOTB, SILENT))
device = DEVICE_SD_SLOTB;
else if(ChangeInterface(DEVICE_DVD, SILENT))
device = DEVICE_DVD;
else if(ChangeInterface(DEVICE_SMB, SILENT))
device = DEVICE_SMB;
else
ErrorPrompt("Unable to locate a load device!");
if(GCSettings.LoadMethod == DEVICE_AUTO)
GCSettings.LoadMethod = device; // save device found for later use
CancelAction();
return device;
}
/*
* Provides an opportunity for the specified menu to do something during
* a display cycle.
*
* menu The menu
*/
void wii_menu_handle_update( TREENODE *menu )
{
switch( menu->node_type )
{
case NODETYPE_LOAD_ROM:
if( !games_read )
{
LOCK_RENDER_MUTEX();
if( mount_pending )
{
const char* roms = wii_get_roms_dir();
if( strlen( roms ) > 0 )
{
char mount[WII_MAX_PATH];
Util_strlcpy( mount, roms, sizeof(mount) );
resetSmbErrorMessage(); // Reset the SMB error message
if( !ChangeInterface( mount, FS_RETRY_COUNT ) )
{
wii_set_roms_dir( "" );
const char* netMsg = getSmbErrorMessage();
if( netMsg != NULL )
{
wii_set_status_message( netMsg );
}
else
{
char msg[256];
snprintf( msg, sizeof(msg), "%s: %s",
gettextmsg("Unable to mount"), mount );
wii_set_status_message( msg );
}
}
}
mount_pending = FALSE;
}
wii_read_game_list( roms_menu );
wii_menu_reset_indexes();
wii_menu_move( roms_menu, 1 );
UNLOCK_RENDER_MUTEX();
}
break;
default:
/* do nothing */
break;
}
}
bool DownloadUpdate()
{
bool result = false;
if(updateURL[0] == 0 || appPath[0] == 0 || !ChangeInterface(appPath, NOTSILENT))
{
ErrorPrompt("Update failed!");
updateFound = false; // updating is finished (successful or not!)
return false;
}
// stop checking if devices were removed/inserted
// since we're saving a file
HaltDeviceThread();
int device;
FindDevice(appPath, &device);
char updateFile[50];
sprintf(updateFile, "%s%s Update.zip", pathPrefix[device], APPNAME);
FILE * hfile = fopen (updateFile, "wb");
if (hfile)
{
if(http_request(updateURL, hfile, NULL, (1024*1024*10), NOTSILENT) > 0)
{
fclose (hfile);
result = unzipArchive(updateFile, (char *)pathPrefix[device]);
}
else
{
fclose (hfile);
}
remove(updateFile); // delete update file
}
// go back to checking if devices were inserted/removed
ResumeDeviceThread();
if(result)
InfoPrompt("Update successful!");
else
ErrorPrompt("Update failed!");
updateFound = false; // updating is finished (successful or not!)
return result;
}
/****************************************************************************
* SaveFile
* Write buffer to file
***************************************************************************/
size_t
SaveFile (char * buffer, char *filepath, size_t datasize, bool silent)
{
size_t written = 0;
size_t writesize, nextwrite;
int retry = 1;
int device;
if(!FindDevice(filepath, &device))
return 0;
if(datasize == 0)
return 0;
// stop checking if devices were removed/inserted
// since we're saving a file
HaltDeviceThread();
// halt parsing
HaltParseThread();
ShowAction("Saving...");
while(!written && retry == 1)
{
if(!ChangeInterface(device, silent))
break;
file = fopen (filepath, "wb");
if(!file)
{
if(silent)
break;
retry = ErrorPromptRetry("Error creating file!");
continue;
}
while(written < datasize)
{
if(datasize - written > 4096) nextwrite=4096;
else nextwrite = datasize-written;
writesize = fwrite (buffer+written, 1, nextwrite, file);
if(writesize != nextwrite) break; // write failure
written += writesize;
}
fclose (file);
if(written != datasize) written = 0;
if(!written)
{
unmountRequired[device] = true;
if(silent) break;
retry = ErrorPromptRetry("Error saving file!");
}
}
// go back to checking if devices were inserted/removed
ResumeDeviceThread();
CancelAction();
return written;
}
/****************************************************************************
* LoadFile
***************************************************************************/
size_t
LoadFile (char * rbuffer, char *filepath, size_t length, bool silent)
{
char zipbuffer[2048];
size_t size = 0, offset = 0, readsize = 0;
int retry = 1;
int device;
if(!FindDevice(filepath, &device))
return 0;
// stop checking if devices were removed/inserted
// since we're loading a file
HaltDeviceThread();
// halt parsing
HaltParseThread();
// open the file
while(retry)
{
if(!ChangeInterface(device, silent))
break;
file = fopen (filepath, "rb");
if(!file)
{
if(silent)
break;
retry = ErrorPromptRetry("Error opening file!");
continue;
}
if(length > 0 && length <= 2048) // do a partial read (eg: to check file header)
{
size = fread (rbuffer, 1, length, file);
}
else // load whole file
{
readsize = fread (zipbuffer, 1, 32, file);
if(!readsize)
{
unmountRequired[device] = true;
retry = ErrorPromptRetry("Error reading file!");
fclose (file);
continue;
}
if (IsZipFile (zipbuffer))
{
size = UnZipBuffer ((unsigned char *)rbuffer); // unzip
}
else
{
fseeko(file,0,SEEK_END);
size = ftello(file);
fseeko(file,0,SEEK_SET);
while(!feof(file))
{
// If the size requested is *less* than the filesize, only read that much - we don't want to overrun the buffer
int toread = 4096;
if (length > 0 && offset+toread > length) {
toread = length - offset;
}
ShowProgress ("Loading...", offset, size);
readsize = fread (rbuffer + offset, 1, 4096, file); // read in next chunk
if(readsize <= 0)
break; // reading finished (or failed)
offset += readsize;
if (length > 0 && offset >= length) {
break;
}
}
size = offset;
CancelAction();
}
}
retry = 0;
fclose (file);
}
// go back to checking if devices were inserted/removed
ResumeDeviceThread();
CancelAction();
return size;
}
/***************************************************************************
* Browse subdirectories
**************************************************************************/
int
ParseDirectory(bool waitParse, bool filter)
{
int retry = 1;
bool mounted = false;
parseFilter = filter;
ResetBrowser(); // reset browser
// add trailing slash
if(browser.dir[strlen(browser.dir)-1] != '/')
strcat(browser.dir, "/");
// open the directory
while(dir == NULL && retry == 1)
{
mounted = ChangeInterface(browser.dir, NOTSILENT);
if(mounted)
dir = opendir(browser.dir);
else
return -1;
if(dir == NULL)
retry = ErrorPromptRetry("Error opening directory!");
}
// if we can't open the dir, try higher levels
if (dir == NULL)
{
char * devEnd = strrchr(browser.dir, '/');
while(!IsDeviceRoot(browser.dir))
{
devEnd[0] = 0; // strip slash
devEnd = strrchr(browser.dir, '/');
if(devEnd == NULL)
break;
devEnd[1] = 0; // strip remaining file listing
dir = opendir(browser.dir);
if (dir)
break;
}
}
if(dir == NULL)
return -1;
if(IsDeviceRoot(browser.dir))
{
AddBrowserEntry();
sprintf(browserList[0].filename, "..");
sprintf(browserList[0].displayname, "Up One Level");
browserList[0].length = 0;
browserList[0].isdir = 1; // flag this as a dir
browserList[0].icon = ICON_FOLDER;
browser.numEntries++;
}
parseHalt = false;
ParseDirEntries(); // index first 20 entries
LWP_ResumeThread(parsethread); // index remaining entries
if(waitParse) // wait for complete parsing
{
ShowAction("Loading...");
while(!LWP_ThreadIsSuspended(parsethread))
usleep(THREAD_SLEEP);
CancelAction();
}
return browser.numEntries;
}
bool LoadPrefs()
{
if(prefLoaded) // already attempted loading
return true;
bool prefFound = false;
char filepath[5][MAXPATHLEN];
int numDevices;
#ifdef HW_RVL
numDevices = 5;
sprintf(filepath[0], "%s", appPath);
sprintf(filepath[1], "sd:/apps/%s", APPFOLDER);
sprintf(filepath[2], "usb:/apps/%s", APPFOLDER);
sprintf(filepath[3], "sd:/%s", APPFOLDER);
sprintf(filepath[4], "usb:/%s", APPFOLDER);
#else
numDevices = 2;
sprintf(filepath[0], "carda:/%s", APPFOLDER);
sprintf(filepath[1], "cardb:/%s", APPFOLDER);
#endif
for(int i=0; i<numDevices; i++)
{
prefFound = LoadPrefsFromMethod(filepath[i]);
if(prefFound)
break;
}
prefLoaded = true; // attempted to load preferences
if(prefFound)
FixInvalidSettings();
// rename snes9x to snes9xgx
if(GCSettings.LoadMethod == DEVICE_SD)
{
if(ChangeInterface(DEVICE_SD, NOTSILENT) && opendir("sd:/snes9x"))
rename("sd:/snes9x", "sd:/snes9xgx");
}
else if(GCSettings.LoadMethod == DEVICE_USB)
{
if(ChangeInterface(DEVICE_USB, NOTSILENT) && opendir("usb:/snes9x"))
rename("usb:/snes9x", "usb:/snes9xgx");
}
else if(GCSettings.LoadMethod == DEVICE_SMB)
{
if(ChangeInterface(DEVICE_SMB, NOTSILENT) && opendir("smb:/snes9x"))
rename("smb:/snes9x", "smb:/snes9xgx");
}
// update folder locations
if(strcmp(GCSettings.LoadFolder, "snes9x/roms") == 0)
sprintf(GCSettings.LoadFolder, "snes9xgx/roms");
if(strcmp(GCSettings.SaveFolder, "snes9x/saves") == 0)
sprintf(GCSettings.SaveFolder, "snes9xgx/saves");
if(strcmp(GCSettings.CheatFolder, "snes9x/cheats") == 0)
sprintf(GCSettings.CheatFolder, "snes9xgx/cheats");
if(strcmp(GCSettings.ScreenshotsFolder, "snes9x/screenshots") == 0)
sprintf(GCSettings.ScreenshotsFolder, "snes9xgx/screenshots");
ResetText();
return prefFound;
}
bool DownloadUpdate()
{
bool result = false;
if(updateURL[0] == 0 || appPath[0] == 0 || !ChangeInterface(appPath, NOTSILENT))
{
ErrorPrompt("Did you unplug your SD/USB?");
return false;
}
// stop checking if devices were removed/inserted
// since we're saving a file
HaltDeviceThread();
int device;
FindDevice(appPath, &device);
char updateFile[50];
sprintf(updateFile, "%s%sUpdate.zip", pathPrefix[device], APPNAME);
FILE * hfile = fopen (updateFile, "wb");
if (hfile)
{
if(http_request(updateURL, hfile, NULL, (1024*1024*10), NOTSILENT, 0) > 0)
{
ShowAction("Extracting update...");
fclose (hfile);
CSHA1 sha1;
if(sha1.HashFile(updateFile)){
char fileHash[41]="";
sha1.Final();
sha1.ReportHash(fileHash, 0);
if(!strcasecmp(fileHash, updateHash)){
char destPath[256];
sprintf(destPath, "%sapps", pathPrefix[device]);
result = unzipArchive(updateFile, destPath);
}else{
ErrorPrompt("Corrupted file!");
}
}else{
ErrorPrompt("Could not verify file!");
}
}
else
{
ErrorPrompt("Unable to download!");
fclose (hfile);
}
remove(updateFile); // delete update file
}else{
ErrorPrompt("Unable to write to SD/USB!");
}
// go back to checking if devices were inserted/removed
ResumeDeviceThread();
if(result){
InfoPrompt("Update successful!");
}
CancelAction();
return result;
}