ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revise the way that cdrom and dvd rom drives are identified in linux to remove reduntant drive listings. Also no longer checking mount points (in fstap and mtab). This can give redundant listings, and GC/Wii backup discs can not be mounted anyway. This prevents multiple listings from appearing in the GameListCtrl when "Show Drives" is selected. 

Some general code cleanup, and removed a PanicAlert (made it a NOTICE_LOG instead) so that only one panic alert is shown when attempting to load from dvd/cdrom drives, and none are shown when "Show Drives" is selected from the menu.  

Also removed the hack introduced in revision 5564 that prevents the GameListCtrl from being properly updated when a game is loaded from the command line or via the autostart feature of the debugger.


git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5848 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
Glenn Rice 2010-07-07 19:47:45 +00:00
parent c37bca75b6
commit 0ad71eda6b
6 changed files with 91 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

313
Source/Core/Common/Src/CDUtils.cpp
View File

@ -16,46 +16,18 @@
#include <IOKit/IOBSD.h>
#elif __linux__
#include <mntent.h>
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <linux/cdrom.h>
#endif // WIN32
// Follow symlinks until we have the real device file (idea taken from libunieject).
void cdio_follow_symlink(const char * src, char * dst) {
#ifndef _WIN32
char tmp_src[PATH_MAX+1];
char tmp_dst[PATH_MAX+1];
int len;
strcpy(tmp_src, src);
while(1) {
len = readlink(tmp_src, tmp_dst, PATH_MAX);
if(len < 0) {
strncpy(dst, tmp_src, PATH_MAX);
return;
}
else {
tmp_dst[len] = '\0';
strncpy(tmp_src, tmp_dst, PATH_MAX);
}
}
#else
strncpy(dst, src, PATH_MAX);
#endif
}
#ifdef _WIN32
// Returns a string that can be used in a CreateFile call if
// c_drive letter is a character. If not NULL is returned.
const char *is_cdrom_win32(const char c_drive_letter) {
const char *is_cdrom(const char c_drive_letter)
{
UINT uDriveType;
char sz_win32_drive[4];
@ -67,12 +39,14 @@ const char *is_cdrom_win32(const char c_drive_letter) {
uDriveType = GetDriveType(sz_win32_drive);
switch(uDriveType) {
case DRIVE_CDROM: {
char sz_win32_drive_full[] = "\\\\.\\X:";
sz_win32_drive_full[4] = c_drive_letter;
return __strdup(&sz_win32_drive_full[4]);
}
switch(uDriveType)
{
case DRIVE_CDROM:
{
char sz_win32_drive_full[] = "\\\\.\\X:";
sz_win32_drive_full[4] = c_drive_letter;
return __strdup(&sz_win32_drive_full[4]);
}
default:
//cdio_debug("Drive %c is not a CD-ROM", c_drive_letter);
return NULL;
@ -80,14 +54,13 @@ const char *is_cdrom_win32(const char c_drive_letter) {
}
// Returns a pointer to an array of strings with the device names
std::vector<std::string> cdio_get_devices_win32() {
std::vector<std::string> cdio_get_devices() {
std::vector<std::string> drives;
char drive_letter;
// Scan the system for CD-ROM drives.
// Not always 100% reliable, so use the USE_MNTENT code above first.
for (drive_letter='A'; drive_letter <= 'Z'; drive_letter++) {
const char *drive_str=is_cdrom_win32(drive_letter);
const char *drive_str=is_cdrom(drive_letter);
if (drive_str != NULL) {
drives.push_back(drive_str);
delete drive_str;
@ -95,15 +68,10 @@ std::vector<std::string> cdio_get_devices_win32() {
}
return drives;
}
#endif // WIN32
#ifdef __APPLE__
/*
Returns a pointer to an array of strings with the device names
*/
std::vector<std::string> cdio_get_devices_osx(void) {
#elif defined __APPLE__
// Returns a pointer to an array of strings with the device names
std::vector<std::string> cdio_get_devices()
{
io_object_t next_media;
mach_port_t master_port;
kern_return_t kern_result;
@ -112,14 +80,12 @@ std::vector<std::string> cdio_get_devices_osx(void) {
std::vector<std::string> drives;
kern_result = IOMasterPort( MACH_PORT_NULL, &master_port );
if( kern_result != KERN_SUCCESS ) {
if( kern_result != KERN_SUCCESS )
return( drives );
}
classes_to_match = IOServiceMatching( kIOCDMediaClass );
if( classes_to_match == NULL ) {
if( classes_to_match == NULL )
return( drives );
}
CFDictionarySetValue( classes_to_match, CFSTR(kIOMediaEjectableKey),
kCFBooleanTrue );
@ -127,37 +93,40 @@ std::vector<std::string> cdio_get_devices_osx(void) {
kern_result = IOServiceGetMatchingServices( master_port,
classes_to_match,
&media_iterator );
if( kern_result != KERN_SUCCESS) {
if( kern_result != KERN_SUCCESS)
return( drives );
}
next_media = IOIteratorNext( media_iterator );
if( next_media != 0 ) {
if( next_media != 0 )
{
char psz_buf[0x32];
size_t dev_path_length;
CFTypeRef str_bsd_path;
do {
do
{
str_bsd_path =
IORegistryEntryCreateCFProperty( next_media,
CFSTR( kIOBSDNameKey ),
kCFAllocatorDefault,
0 );
if( str_bsd_path == NULL ) {
if( str_bsd_path == NULL )
{
IOObjectRelease( next_media );
continue;
}
/* Below, by appending 'r' to the BSD node name, we indicate
a raw disk. Raw disks receive I/O requests directly and
don't go through a buffer cache. */
// Below, by appending 'r' to the BSD node name, we indicate
// a raw disk. Raw disks receive I/O requests directly and
// don't go through a buffer cache.
snprintf( psz_buf, sizeof(psz_buf), "%s%c", _PATH_DEV, 'r' );
dev_path_length = strlen( psz_buf );
if( CFStringGetCString( (CFStringRef)str_bsd_path,
(char*)&psz_buf + dev_path_length,
sizeof(psz_buf) - dev_path_length,
kCFStringEncodingASCII)) {
kCFStringEncodingASCII))
{
if(psz_buf != NULL)
{
std::string str = psz_buf;
@ -172,178 +141,71 @@ std::vector<std::string> cdio_get_devices_osx(void) {
IOObjectRelease( media_iterator );
return drives;
}
#endif
#ifdef __linux__
/* checklist: /dev/cdrom, /dev/dvd /dev/hd?, /dev/scd? /dev/sr? */
static char checklist1[][40] = {
{"cdrom"}, {"dvd"}, {""}
};
#elif defined __linux__
// checklist: /dev/cdrom, /dev/dvd /dev/hd?, /dev/scd? /dev/sr?
static struct
{
const char * format;
unsigned int num_min;
unsigned int num_max;
} checklist2[] =
} checklist[] =
{
{ "/dev/cdrom", 0, 0},
{ "/dev/dvd", 0, 0},
{ "/dev/hd%c", 'a', 'z' },
{ "/dev/scd%d", 0, 27 },
{ "/dev/sr%d", 0, 27 },
{ /* End of array */ }
{ NULL }
};
/*
Returns true if a device is a block or char device
*/
bool cdio_is_device_quiet_generic(const char *source_name) {
// Returns true if a device is a block or char device and not a symbolic link
bool is_device(const char *source_name)
{
struct stat buf;
if (0 != stat(source_name, &buf)) {
if (0 != lstat(source_name, &buf))
return false;
}
return (S_ISBLK(buf.st_mode) || S_ISCHR(buf.st_mode));
return ((S_ISBLK(buf.st_mode) || S_ISCHR(buf.st_mode)) && !S_ISLNK(buf.st_mode));
}
/*
Check a drive to see if it is a CD-ROM
Return 1 if a CD-ROM. 0 if it exists but isn't a CD-ROM drive
and -1 if no device exists .
*/
static bool is_cdrom_linux(const char *drive, char *mnttype) {
// Check a device to see if it is a DVD/CD-ROM drive
static bool is_cdrom(const char *drive, char *mnttype)
{
bool is_cd=false;
int cdfd;
/* If it doesn't exist, return -1 */
if ( !cdio_is_device_quiet_generic(drive) ) {
// Check if the device exists
if (!is_device(drive))
return(false);
}
/* If it does exist, verify that it's an available CD-ROM */
// If it does exist, verify that it is a cdrom/dvd drive
cdfd = open(drive, (O_RDONLY|O_NONBLOCK), 0);
if ( cdfd >= 0 ) {
if ( ioctl(cdfd, CDROM_GET_CAPABILITY, 0) != -1 ) {
if ( cdfd >= 0 )
{
if (ioctl(cdfd, CDROM_GET_CAPABILITY, 0) != -1)
is_cd = true;
}
close(cdfd);
}
/* Even if we can't read it, it might be mounted */
else if ( mnttype && (strcmp(mnttype, "iso9660") == 0) ) {
is_cd = true;
}
return(is_cd);
}
/*
Recive an mtab formated file and returns path to cdrom device
*/
static char *check_mounts_linux(const char *mtab)
{
FILE *mntfp;
struct mntent *mntent;
mntfp = setmntent(mtab, "r");
if ( mntfp != NULL ) {
char *tmp;
char *mnt_type;
char *mnt_dev;
unsigned int i_mnt_type;
unsigned int i_mnt_dev;
while ( (mntent=getmntent(mntfp)) != NULL ) {
i_mnt_type = strlen(mntent->mnt_type) + 1;
mnt_type = (char *)calloc(1, i_mnt_type);
if (mnt_type == NULL)
continue; /* maybe you'll get lucky next time. */
i_mnt_dev = strlen(mntent->mnt_fsname) + 1;
mnt_dev = (char *)calloc(1, i_mnt_dev);
if (mnt_dev == NULL) {
free(mnt_type);
continue;
}
strncpy(mnt_type, mntent->mnt_type, i_mnt_type);
strncpy(mnt_dev, mntent->mnt_fsname, i_mnt_dev);
/* Handle "supermount" filesystem mounts */
if ( strcmp(mnt_type, "supermount") == 0 ) {
tmp = strstr(mntent->mnt_opts, "fs=");
if ( tmp ) {
free(mnt_type);
mnt_type = __strdup(tmp + strlen("fs="));
if ( mnt_type ) {
tmp = strchr(mnt_type, ',');
if ( tmp ) {
*tmp = '\0';
}
}
}
tmp = strstr(mntent->mnt_opts, "dev=");
if ( tmp ) {
free(mnt_dev);
mnt_dev = __strdup(tmp + strlen("dev="));
if ( mnt_dev ) {
tmp = strchr(mnt_dev, ',');
if ( tmp ) {
*tmp = '\0';
}
}
}
}
if ( strcmp(mnt_type, "iso9660") == 0 ) {
if (is_cdrom_linux(mnt_dev, mnt_type) > 0) {
free(mnt_type);
endmntent(mntfp);
return mnt_dev;
}
}
free(mnt_dev);
free(mnt_type);
}
endmntent(mntfp);
}
return NULL;
}
// Returns a pointer to an array of strings with the device names
std::vector<std::string> cdio_get_devices_linux () {
std::vector<std::string> cdio_get_devices ()
{
unsigned int i;
char drive[40];
char *ret_drive;
std::vector<std::string> drives;
// Scan the system for CD-ROM drives.
for ( i=0; strlen(checklist1[i]) > 0; ++i ) {
sprintf(drive, "/dev/%s", checklist1[i]);
if ( is_cdrom_linux(drive, NULL) > 0 ) {
std::string str = drive;
drives.push_back(str);
}
}
/* Now check the currently mounted CD drives */
if (NULL != (ret_drive = check_mounts_linux("/etc/mtab"))) {
std::string str = ret_drive;
drives.push_back(str);
free(ret_drive);
}
/* Finally check possible mountable drives in /etc/fstab */
if (NULL != (ret_drive = check_mounts_linux("/etc/fstab"))) {
std::string str = ret_drive;
drives.push_back(str);
free(ret_drive);
}
// Scan the system for CD-ROM drives.
// Not always 100% reliable, so use the USE_MNTENT code above first.
for ( i=0; checklist2[i].format; ++i ) {
// Scan the system for DVD/CD-ROM drives.
for ( i=0; checklist[i].format; ++i )
{
unsigned int j;
for ( j=checklist2[i].num_min; j<=checklist2[i].num_max; ++j ) {
sprintf(drive, checklist2[i].format, j);
if ( (is_cdrom_linux(drive, NULL)) > 0 ) {
for ( j=checklist[i].num_min; j<=checklist[i].num_max; ++j )
{
sprintf(drive, checklist[i].format, j);
if ( (is_cdrom(drive, NULL)) > 0 )
{
std::string str = drive;
drives.push_back(str);
}
@ -353,47 +215,38 @@ std::vector<std::string> cdio_get_devices_linux () {
}
#endif
// Returns a pointer to an array of strings with the device names
std::vector<std::string> cdio_get_devices() {
#ifdef _WIN32
return cdio_get_devices_win32();
#elif __APPLE__
return cdio_get_devices_osx();
#elif __linux__
return cdio_get_devices_linux();
#else
#warning CDIO not supported on your platform!
// Returns true if device is a cdrom/dvd drive
bool cdio_is_cdrom(std::string device)
{
#ifdef __linux__
// Resolve symbolic links. This allows symbolic links to valid cdrom/dvd drives to
// be passed from the command line with the -e flag.
char *devname = realpath(device.c_str(), NULL);
if (!devname)
return false;
#endif
}
// Need to be tested, does calling this function twice cause any damage?
// Returns true if device is cdrom/dvd
bool cdio_is_cdrom(std::string device) {
std::vector<std::string> devices = cdio_get_devices();
bool res = false;
for (unsigned int i = 0; i < devices.size(); i++) {
if (strncmp(devices[i].c_str(), device.c_str(), PATH_MAX) == 0) {
for (unsigned int i = 0; i < devices.size(); i++)
{
#ifdef __linux__
if (strncmp(devices[i].c_str(), devname, PATH_MAX) == 0)
#else
if (strncmp(devices[i].c_str(), device.c_str(), PATH_MAX) == 0)
#endif
{
res = true;
break;
}
}
#ifdef __linux__
if (devname)
free(devname);
#endif
devices.clear();
return res;
}
// Can we remove this?
/*
int main() {
char** res = cdio_get_devices();
int i = 0;
for (i = 0; res[i] != NULL; i++) {
printf("%s\n", res[i]);
}
cdio_free_device_list(res);
return 0;
}
*/

9
Source/Core/Core/Src/CoreParameter.cpp
View File

@ -120,7 +120,7 @@ bool SCoreStartupParameter::AutoSetup(EBootBS2 _BootBS2)
// that gave an incorrect file name
if (!bootDrive && !File::Exists(m_strFilename.c_str()))
{
PanicAlert("The file you specified (%s) does not exists", m_strFilename.c_str());
PanicAlert("The specified file \"%s\" does not exist", m_strFilename.c_str());
return false;
}
@ -136,9 +136,10 @@ bool SCoreStartupParameter::AutoSetup(EBootBS2 _BootBS2)
if (pVolume == NULL)
{
PanicAlert(bootDrive ?
"Disc in %s could not be read - no disc, or not a GC/Wii backup.\n"
"Please note that original Gamecube and Wii discs cannot be read by most PC DVD drives.":
"Your GCM/ISO file seems to be invalid, or not a GC/Wii ISO.", m_strFilename.c_str());
"Could not read \"%s\". There is no disc in the drive, or it is not a GC/Wii backup. "
"Please note that original Gamecube and Wii discs cannot be read by most PC DVD drives." :
"\"%s\" is an invalid GCM/ISO file, or is not a GC/Wii ISO."
, m_strFilename.c_str());
return false;
}
m_strName = pVolume->GetName();

4
Source/Core/DiscIO/Src/DriveBlob.cpp
View File

@ -63,9 +63,7 @@ DriveReader::DriveReader(const char *drive)
#endif
}
else
{
PanicAlert("Load from DVD backup failed or no disc in drive %s", drive);
}
NOTICE_LOG(DISCIO, "Load from DVD backup failed or no disc in drive %s", drive);
} // DriveReader::DriveReader
DriveReader::~DriveReader()

2
Source/Core/DolphinWX/Src/Frame.cpp
View File

@ -498,6 +498,8 @@ CFrame::CFrame(wxFrame* parent,
m_bControlsCreated = true;
UpdateGUI();
if (m_GameListCtrl) m_GameListCtrl->Update();
// If we are rerecording create the status bar now instead of later when a game starts
#ifdef RERECORDING
ModifyStatusBar();

15
Source/Core/DolphinWX/Src/Main.cpp
View File

@ -48,10 +48,6 @@
IMPLEMENT_APP(DolphinApp)
BEGIN_EVENT_TABLE(DolphinApp, wxApp)
EVT_TIMER(wxID_ANY, DolphinApp::AfterInit)
END_EVENT_TABLE()
#include <wx/stdpaths.h>
bool wxMsgAlert(const char*, const char*, bool, int);
@ -423,20 +419,9 @@ bool DolphinApp::OnInit()
XInitThreads();
#endif
// Postpone final actions until event handler is running
m_afterinit = new wxTimer(this, wxID_ANY);
m_afterinit->Start(1, wxTIMER_ONE_SHOT);
return true;
}
void DolphinApp::AfterInit(wxTimerEvent& WXUNUSED(event))
{
delete m_afterinit;
main_frame->UpdateGameList();
}
void DolphinApp::OnEndSession()
{
SConfig::GetInstance().SaveSettings();

7
Source/Core/DolphinWX/Src/Main.h
View File

@ -29,13 +29,6 @@ public:
void OnEndSession();
int OnExit();
CFrame* GetCFrame();
private:
DECLARE_EVENT_TABLE()
wxTimer *m_afterinit;
void AfterInit(wxTimerEvent& WXUNUSED(event));
};
DECLARE_APP(DolphinApp);