mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-14 21:37:52 -07:00
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
parent
c37bca75b6
commit
0ad71eda6b
@ -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,8 +39,10 @@ const char *is_cdrom_win32(const char c_drive_letter) {
|
||||
|
||||
uDriveType = GetDriveType(sz_win32_drive);
|
||||
|
||||
switch(uDriveType) {
|
||||
case DRIVE_CDROM: {
|
||||
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]);
|
||||
@ -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;
|
||||
}
|
||||
*/
|
||||
|
||||
@ -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"
|
||||
"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." :
|
||||
"Your GCM/ISO file seems to be invalid, or not a GC/Wii ISO.", m_strFilename.c_str());
|
||||
"\"%s\" is an invalid GCM/ISO file, or is not a GC/Wii ISO."
|
||||
, m_strFilename.c_str());
|
||||
return false;
|
||||
}
|
||||
m_strName = pVolume->GetName();
|
||||
|
||||
@ -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()
|
||||
|
||||
@ -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();
|
||||
|
||||
@ -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();
|
||||
|
||||
@ -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);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user