445 lines
11 KiB
C++
445 lines
11 KiB
C++
// Most of the code in this file was shamelessly ripped from libcdio With minor adjustments
|
|
|
|
#include "CDUtils.h"
|
|
#include "Common.h"
|
|
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#define PATH_MAX MAX_PATH
|
|
|
|
#elif __APPLE__
|
|
#include <paths.h>
|
|
#include <Carbon/Carbon.h>
|
|
#include <IOKit/IOKitLib.h>
|
|
#include <IOKit/storage/IOCDMedia.h>
|
|
#include <IOKit/storage/IOMedia.h>
|
|
#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
|
|
}
|
|
|
|
|
|
|
|
// Add/allocate a drive to the end of drives.
|
|
// Use cdio_free_device_list() to free this device_list.
|
|
void cdio_add_device_list(char **device_list[], const char *drive,
|
|
unsigned int *num_drives) {
|
|
if (NULL != drive) {
|
|
unsigned int j;
|
|
char real_device_1[PATH_MAX];
|
|
char real_device_2[PATH_MAX];
|
|
cdio_follow_symlink(drive, real_device_1);
|
|
/* Check if drive is already in list. */
|
|
for (j=0; j<*num_drives; j++) {
|
|
cdio_follow_symlink((*device_list)[j], real_device_2);
|
|
if (strcmp(real_device_1, real_device_2) == 0) break;
|
|
}
|
|
|
|
if (j==*num_drives) {
|
|
/* Drive not in list. Add it. */
|
|
(*num_drives)++;
|
|
*device_list = (char **)realloc(*device_list, (*num_drives) * sizeof(char *));
|
|
(*device_list)[*num_drives-1] = __strdup(drive);
|
|
}
|
|
|
|
} else {
|
|
(*num_drives)++;
|
|
if (*device_list) {
|
|
*device_list = (char **)realloc(*device_list, (*num_drives) * sizeof(char *));
|
|
} else {
|
|
*device_list = (char **)malloc((*num_drives) * sizeof(char *));
|
|
}
|
|
(*device_list)[*num_drives-1] = NULL;
|
|
}
|
|
}
|
|
|
|
// Free device list returned by cdio_get_devices or
|
|
// cdio_get_devices_with_cap.
|
|
void cdio_free_device_list(char * ppsz_device_list[]) {
|
|
char **ppsz_device_list_save=ppsz_device_list;
|
|
if (!ppsz_device_list) return;
|
|
for ( ; NULL != *ppsz_device_list ; ppsz_device_list++ ) {
|
|
free(*ppsz_device_list);
|
|
*ppsz_device_list = NULL;
|
|
}
|
|
free(ppsz_device_list_save);
|
|
}
|
|
|
|
|
|
#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) {
|
|
|
|
UINT uDriveType;
|
|
char sz_win32_drive[4];
|
|
|
|
sz_win32_drive[0]= c_drive_letter;
|
|
sz_win32_drive[1]=':';
|
|
sz_win32_drive[2]='\\';
|
|
sz_win32_drive[3]='\0';
|
|
|
|
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]);
|
|
}
|
|
default:
|
|
//cdio_debug("Drive %c is not a CD-ROM", c_drive_letter);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
// Returns a pointer to an array of strings with the device names
|
|
char ** cdio_get_devices_win32() {
|
|
char **drives = NULL;
|
|
unsigned int num_drives=0;
|
|
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);
|
|
if (drive_str != NULL) {
|
|
cdio_add_device_list(&drives, drive_str, &num_drives);
|
|
}
|
|
}
|
|
cdio_add_device_list(&drives, NULL, &num_drives);
|
|
return drives;
|
|
}
|
|
#endif // WIN32
|
|
|
|
|
|
#ifdef __APPLE__
|
|
|
|
/*
|
|
Returns a pointer to an array of strings with the device names
|
|
*/
|
|
char **cdio_get_devices_osx(void) {
|
|
io_object_t next_media;
|
|
mach_port_t master_port;
|
|
kern_return_t kern_result;
|
|
io_iterator_t media_iterator;
|
|
CFMutableDictionaryRef classes_to_match;
|
|
char **drives = NULL;
|
|
unsigned int num_drives=0;
|
|
|
|
kern_result = IOMasterPort( MACH_PORT_NULL, &master_port );
|
|
if( kern_result != KERN_SUCCESS ) {
|
|
return( NULL );
|
|
}
|
|
|
|
classes_to_match = IOServiceMatching( kIOCDMediaClass );
|
|
if( classes_to_match == NULL ) {
|
|
return( NULL );
|
|
}
|
|
|
|
CFDictionarySetValue( classes_to_match, CFSTR(kIOMediaEjectableKey),
|
|
kCFBooleanTrue );
|
|
|
|
kern_result = IOServiceGetMatchingServices( master_port,
|
|
classes_to_match,
|
|
&media_iterator );
|
|
if( kern_result != KERN_SUCCESS) {
|
|
return( NULL );
|
|
}
|
|
|
|
next_media = IOIteratorNext( media_iterator );
|
|
if( next_media != 0 ) {
|
|
char psz_buf[0x32];
|
|
size_t dev_path_length;
|
|
CFTypeRef str_bsd_path;
|
|
|
|
do {
|
|
str_bsd_path =
|
|
IORegistryEntryCreateCFProperty( next_media,
|
|
CFSTR( kIOBSDNameKey ),
|
|
kCFAllocatorDefault,
|
|
0 );
|
|
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. */
|
|
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)) {
|
|
cdio_add_device_list(&drives, strdup(psz_buf), &num_drives);
|
|
}
|
|
CFRelease( str_bsd_path );
|
|
IOObjectRelease( next_media );
|
|
|
|
} while( ( next_media = IOIteratorNext( media_iterator ) ) != 0 );
|
|
}
|
|
IOObjectRelease( media_iterator );
|
|
cdio_add_device_list(&drives, NULL, &num_drives);
|
|
return drives;
|
|
}
|
|
#endif
|
|
|
|
#ifdef __linux__
|
|
/* checklist: /dev/cdrom, /dev/dvd /dev/hd?, /dev/scd? /dev/sr? */
|
|
static char checklist1[][40] = {
|
|
{"cdrom"}, {"dvd"}, {""}
|
|
};
|
|
|
|
static struct
|
|
{
|
|
const char * format;
|
|
unsigned int num_min;
|
|
unsigned int num_max;
|
|
} checklist2[] =
|
|
{
|
|
{ "/dev/hd%c", 'a', 'z' },
|
|
{ "/dev/scd%d", 0, 27 },
|
|
{ "/dev/sr%d", 0, 27 },
|
|
{ /* End of array */ }
|
|
};
|
|
|
|
|
|
/*
|
|
Returns true if a device is a block or char device
|
|
*/
|
|
bool cdio_is_device_quiet_generic(const char *source_name) {
|
|
struct stat buf;
|
|
if (0 != stat(source_name, &buf)) {
|
|
return false;
|
|
}
|
|
return (S_ISBLK(buf.st_mode) || S_ISCHR(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) {
|
|
bool is_cd=false;
|
|
int cdfd;
|
|
|
|
/* If it doesn't exist, return -1 */
|
|
if ( !cdio_is_device_quiet_generic(drive) ) {
|
|
return(false);
|
|
}
|
|
|
|
/* If it does exist, verify that it's an available CD-ROM */
|
|
cdfd = open(drive, (O_RDONLY|O_NONBLOCK), 0);
|
|
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
|
|
char **cdio_get_devices_linux () {
|
|
|
|
unsigned int i;
|
|
char drive[40];
|
|
char *ret_drive;
|
|
char **drives = NULL;
|
|
unsigned int num_drives=0;
|
|
|
|
// 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 ) {
|
|
cdio_add_device_list(&drives, drive, &num_drives);
|
|
}
|
|
}
|
|
|
|
/* Now check the currently mounted CD drives */
|
|
if (NULL != (ret_drive = check_mounts_linux("/etc/mtab"))) {
|
|
cdio_add_device_list(&drives, ret_drive, &num_drives);
|
|
free(ret_drive);
|
|
}
|
|
|
|
/* Finally check possible mountable drives in /etc/fstab */
|
|
if (NULL != (ret_drive = check_mounts_linux("/etc/fstab"))) {
|
|
cdio_add_device_list(&drives, ret_drive, &num_drives);
|
|
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 ) {
|
|
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 ) {
|
|
cdio_add_device_list(&drives, drive, &num_drives);
|
|
}
|
|
}
|
|
}
|
|
cdio_add_device_list(&drives, NULL, &num_drives);
|
|
return drives;
|
|
}
|
|
#endif
|
|
|
|
// Returns a pointer to an array of strings with the device names
|
|
char **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
|
|
// todo add somewarning
|
|
#endif
|
|
}
|
|
|
|
// Need to be tested, does calling this function twice cause any damage?
|
|
|
|
// Returns true if device is cdrom/dvd
|
|
|
|
bool cdio_is_cdrom(const char *device) {
|
|
char **devices = cdio_get_devices();
|
|
bool res = false;
|
|
for (int i = 0; devices[i] != NULL; i++) {
|
|
if (strncmp(devices[i], device, PATH_MAX) == 0) {
|
|
res = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
cdio_free_device_list(devices);
|
|
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;
|
|
}
|
|
*/
|