/*

  Copyright (C) 2003-2006, 2008, 2010-2012, 2014-2015, 2017

   Rocky Bernstein <rocky@gnu.org>

  from vcdimager code:

  Copyright (C) 2001 Herbert Valerio Riedel <hvr@gnu.org>

  and VideoLAN code Copyright (C) 1998-2001 VideoLAN

      Authors: Johan Bilien <jobi@via.ecp.fr>

               Gildas Bazin <gbazin@netcourrier.com>

               Jon Lech Johansen <jon-vl@nanocrew.net>

               Derk-Jan Hartman <hartman at videolan.org>

               Justin F. Hallett <thesin@southofheaven.org>

  This program is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/* This file contains OSX-specific code and implements low-level

   control of the CD drive.

*/

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#ifdef HAVE_STDBOOL_H

# include <stdbool.h>

#endif

#include <cdio/logging.h>

#include <cdio/sector.h>

#include <cdio/util.h>

/* For SCSI TR_* enumerations */

typedef enum {

  TR_OK =            0,

  TR_EWRITE =        1  /**< Error writing packet command (transport) */,

  TR_EREAD =         2  /**< Error reading packet data (transport) */,

  TR_UNDERRUN =      3  /**< Read underrun */,

  TR_OVERRUN =       4  /**< Read overrun */,

  TR_ILLEGAL =       5  /**< Illegal/rejected request */,

  TR_MEDIUM =        6  /**< Medium error */,

  TR_BUSY =          7  /**< Device busy */,

  TR_NOTREADY =      8  /**< Device not ready */,

  TR_FAULT =         9  /**< Device failure */,

  TR_UNKNOWN =      10  /**< Unspecified error */,

  TR_STREAMING =    11  /**< loss of streaming */,

} transport_error_t;

#include "cdio_assert.h"

#include "cdio_private.h"

#include <string.h>

#ifdef HAVE_DARWIN_CDROM

#undef VERSION

#include <CoreFoundation/CoreFoundation.h>

#include <IOKit/IOKitLib.h>

#include <IOKit/storage/IOStorageDeviceCharacteristics.h>

#include <mach/mach.h>

#include <Carbon/Carbon.h>

#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1030

# include <IOKit/scsi/SCSITaskLib.h>

#else

# include <IOKit/scsi-commands/SCSITaskLib.h>

#endif

#include <IOKit/IOCFPlugIn.h>

#include <mach/mach_error.h>

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/ioctl.h>

#include <paths.h>

#include <CoreFoundation/CoreFoundation.h>

#include <IOKit/IOKitLib.h>

#include <IOKit/IOBSD.h>

#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1030

# include <IOKit/scsi/IOSCSIMultimediaCommandsDevice.h>

#else

# include <IOKit/scsi-commands/IOSCSIMultimediaCommandsDevice.h>

#endif

#include <IOKit/storage/IOCDTypes.h>

#include <IOKit/storage/IODVDTypes.h>

#include <IOKit/storage/IOMedia.h>

#include <IOKit/storage/IOCDMedia.h>

#include <IOKit/storage/IODVDMedia.h>

#include <IOKit/storage/IOCDMediaBSDClient.h>

#include <IOKit/storage/IODVDMediaBSDClient.h>

#include <IOKit/storage/IOBlockStorageDevice.h>

#include <IOKit/storage/IOStorageDeviceCharacteristics.h>

#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050

#include <IOKit/storage/IOBDTypes.h>

#include <IOKit/storage/IOBDMedia.h>

#include <IOKit/storage/IOBDMediaBSDClient.h>

#else

#define kIOBDMediaClass "IOBDMedia" // It does not hurt, simplyfies rest of code

#endif

#ifdef HAVE_DISKARBITRATION

#include <DiskArbitration/DiskArbitration.h>

#endif

/* FIXME */

#define MAX_BIG_BUFF_SIZE  65535

#define kIOCDBlockStorageDeviceClassString              "IOCDBlockStorageDevice"

/* Note leadout is normally defined 0xAA, But on OSX 0xA0 is "lead in" while

   0xA2 is "lead out". I don't understand the distinction, and therefore

   something could be wrong. */

#define OSX_CDROM_LEADOUT_TRACK 0xA2

#define TOTAL_TRACKS    (p_env->i_last_track - p_env->gen.i_first_track + 1)

#define CDROM_CDI_TRACK 0x1

#define CDROM_XA_TRACK  0x2

typedef enum {

  _AM_NONE,

  _AM_OSX,

} access_mode_t;

#define MAX_SERVICE_NAME 1000

typedef struct {

  /* Things common to all drivers like this.

     This must be first. */

  generic_img_private_t gen;

  access_mode_t access_mode;

  /* Track information */

  CDTOC *pTOC;

  int i_descriptors;

  track_t i_last_track;      /* highest track number */

  track_t i_last_session;    /* highest session number */

  track_t i_first_session;   /* first session number */

  lsn_t   *pp_lba;

  io_service_t MediaClass_service;

  char    psz_MediaClass_service[MAX_SERVICE_NAME];

  SCSITaskDeviceInterface **pp_scsiTaskDeviceInterface;

  // io_service_t obj;

  // SCSITaskDeviceInterface **scsi;

  SCSITaskInterface **scsi_task;

  MMCDeviceInterface **mmc;

  IOCFPlugInInterface **plugin;

  SCSI_Sense_Data sense;

  SCSITaskStatus status;

  UInt64 realized_len;

} _img_private_t;

static bool read_toc_osx (void *p_user_data);

static track_format_t get_track_format_osx(void *p_user_data,

                                           track_t i_track);

/**

 * GetRegistryEntryProperties - Gets the registry entry properties for

 *  an io_service_t.

 */

static CFMutableDictionaryRef

GetRegistryEntryProperties ( io_service_t service )

{

  IOReturn                      err     = kIOReturnSuccess;

  CFMutableDictionaryRef        dict    = 0;

  err = IORegistryEntryCreateCFProperties (service, &dict,

                                           kCFAllocatorDefault, 0);

  if ( err != kIOReturnSuccess )

    cdio_warn( "IORegistryEntryCreateCFProperties: 0x%08x", err );

  return dict;

}

/**

 * ProbeStorageDevices - Probe devices to detect changes.

 */

static bool

ProbeStorageDevices()

{

  io_service_t  next_service;

  mach_port_t   master_port;

  kern_return_t kern_result;

  io_iterator_t service_iterator;

  CFMutableDictionaryRef classes_to_match;

  kern_result = IOMasterPort( MACH_PORT_NULL, &master_port );

  if( kern_result != KERN_SUCCESS )

    {

      return false;

    }

  classes_to_match = IOServiceMatching( kIOBlockStorageDeviceClass );

  if( classes_to_match == NULL )

    {

      return false;

    }

  kern_result = IOServiceGetMatchingServices( master_port,

                                              classes_to_match,

                                              &service_iterator );

  if( kern_result != KERN_SUCCESS )

    {

      return false;

    }

  next_service = IOIteratorNext( service_iterator );

  if( next_service != 0 )

    {

      do

        {

          IOServiceRequestProbe( next_service, 0 );

          IOObjectRelease( next_service );

        } while( ( next_service = IOIteratorNext( service_iterator ) ) != 0 );

    }

  IOObjectRelease( service_iterator );

  return true;

}

#ifdef GET_SCSI_FIXED

static bool

get_scsi(_img_private_t *p_env)

{

  SInt32 score;

  kern_return_t err;

  HRESULT herr;

  err = IOCreatePlugInInterfaceForService(p_env->MediaClass_service,

                                          kIOMMCDeviceUserClientTypeID,

                                          kIOCFPlugInInterfaceID,

                                          &p_env->plugin,

                                          &score);

  if (err != noErr) {

    fprintf(stderr, "Error %x accessing MMC plugin.\n", err);

    return false;

    }

  herr = (*p_env->plugin) ->

    QueryInterface(p_env->plugin, CFUUIDGetUUIDBytes(kIOMMCDeviceInterfaceID),

                   (void *)&p_env->mmc);

  if (herr != S_OK) {

    fprintf(stderr, "Error %x accessing MMC interface.\n", (int) herr);

    IODestroyPlugInInterface(p_env->plugin);

    return false;

  }

  p_env->pp_scsiTaskDeviceInterface =

    (*p_env->mmc)->GetSCSITaskDeviceInterface(p_env->mmc);

  if (!p_env->pp_scsiTaskDeviceInterface) {

    fprintf(stderr,

            "Could not get SCSITaskkDevice interface from MMC interface.\n");

    (*p_env->mmc)->Release(p_env->mmc);

    IODestroyPlugInInterface(p_env->plugin);

    return false;

  }

  err = (*p_env->pp_scsiTaskDeviceInterface)->

    ObtainExclusiveAccess(p_env->pp_scsiTaskDeviceInterface);

  if (err != kIOReturnSuccess) {

    fprintf(stderr, "Could not obtain exclusive access to the device (%x).\n",

            err);

    if (err == kIOReturnBusy)

      fprintf(stderr, "The volume is already mounted.\n");

    else if (err == kIOReturnExclusiveAccess)

      fprintf(stderr, "Another application already has exclusive access "

              "to this device.\n");

    else

      fprintf(stderr, "I don't know why.\n");

    (*p_env->pp_scsiTaskDeviceInterface)->

      Release(p_env->pp_scsiTaskDeviceInterface);

    (*p_env->mmc)->Release(p_env->mmc);

    IODestroyPlugInInterface(p_env->plugin);

    return false;

  }

  p_env->scsi_task =

    (*p_env->pp_scsiTaskDeviceInterface) ->

    CreateSCSITask(p_env->pp_scsiTaskDeviceInterface);

  if (!p_env->scsi_task) {

    fprintf(stderr, "Could not create a SCSITask interface.\n");

    (*p_env->pp_scsiTaskDeviceInterface)->

      ReleaseExclusiveAccess(p_env->pp_scsiTaskDeviceInterface);

    (*p_env->pp_scsiTaskDeviceInterface)->

      Release(p_env->pp_scsiTaskDeviceInterface);

    (*p_env->mmc)->Release(p_env->mmc);

    IODestroyPlugInInterface(p_env->plugin);

    return false;

  }

  return true;

}

#endif

static bool

init_osx(_img_private_t *p_env) {

  char *psz_devname;

  kern_return_t ret;

  io_iterator_t iterator;

  /* Only open if not already opened. Otherwise, too many descriptors

     are holding the device busy.  */

  if (-1 == p_env->gen.fd)

    p_env->gen.fd = open( p_env->gen.source_name, O_RDONLY | O_NONBLOCK );

  if (-1 == p_env->gen.fd) {

    cdio_warn("Failed to open %s: %s", p_env->gen.source_name,

               strerror(errno));

    return false;

  }

  /* Get the device name. */

  psz_devname = strrchr( p_env->gen.source_name, '/');

  if( NULL != psz_devname )

    ++psz_devname;

  else

    psz_devname = p_env->gen.source_name;

  /* Unraw the device name. */

  if( *psz_devname == 'r' )

    ++psz_devname;

  ret = IOServiceGetMatchingServices( kIOMasterPortDefault,

                                      IOBSDNameMatching(kIOMasterPortDefault,

                                                        0, psz_devname),

                                      &iterator );

  /* Get service iterator for the device. */

  if( ret != KERN_SUCCESS )

    {

        cdio_warn( "IOServiceGetMatchingServices: 0x%08x", ret );

        return false;

    }

  /* first service */

  p_env->MediaClass_service = IOIteratorNext( iterator );

  IOObjectRelease( iterator );

  /* search for kIOCDMediaClass or kIODVDMediaClass or kIOBDMediaClass */

  while( p_env->MediaClass_service &&

         (!IOObjectConformsTo(p_env->MediaClass_service, kIOCDMediaClass)) &&

         (!IOObjectConformsTo(p_env->MediaClass_service, kIODVDMediaClass)) &&

         (!IOObjectConformsTo(p_env->MediaClass_service, kIOBDMediaClass)) )

    {

      ret = IORegistryEntryGetParentIterator( p_env->MediaClass_service,

                                              kIOServicePlane,

                                              &iterator );

      if( ret != KERN_SUCCESS )

        {

          cdio_warn( "IORegistryEntryGetParentIterator: 0x%08x", ret );

          IOObjectRelease( p_env->MediaClass_service );

          return false;

        }

      IOObjectRelease( p_env->MediaClass_service );

      p_env->MediaClass_service = IOIteratorNext( iterator );

      IOObjectRelease( iterator );

    }

  if ( 0 == p_env->MediaClass_service )     {

    cdio_warn( "search for kIOCDMediaClass/kIODVDMediaClass/kIOBDMediaClass came up empty" );

    return false;

  }

  /* Save the name so we can compare against this in case we have to do

     another scan. FIXME: this is hoaky and there's got to be a better

     variable to test or way to do.

   */

  IORegistryEntryGetPath(p_env->MediaClass_service, kIOServicePlane,

                         p_env->psz_MediaClass_service);

#ifdef GET_SCSI_FIXED

  return get_scsi(p_env);

#else

  return true;

#endif

}

/**

  Run a SCSI MMC command.

  cdio          CD structure set by cdio_open().

  i_timeout     time in milliseconds we will wait for the command

                to complete. If this value is -1, use the default

                time-out value.

  p_buf         Buffer for data, both sending and receiving

  i_buf         Size of buffer

  e_direction   direction the transfer is to go.

  cdb           CDB bytes. All values that are needed should be set on

                input. We'll figure out what the right CDB length should be.

  We return true if command completed successfully and false if not.

 */

#if 1

/* process a complete scsi command. */

static int

run_mmc_cmd_osx( void *p_user_data,

                 unsigned int i_timeout_ms,

                 unsigned int i_cdb, const mmc_cdb_t *p_cdb,

                 cdio_mmc_direction_t e_direction,

                 unsigned int i_buf, /*in/out*/ void *p_buf )

{

  _img_private_t *p_env = p_user_data;

  uint8_t cmdbuf[16];

  UInt8 dir;

  IOVirtualRange buf;

  IOReturn ret;

  if (!p_env->scsi_task) return DRIVER_OP_UNSUPPORTED;

  p_env->gen.scsi_mmc_sense_valid = 0;

  memcpy(cmdbuf, p_cdb, i_cdb);

  dir =

      (SCSI_MMC_DATA_READ == e_direction)

      ? kSCSIDataTransfer_FromTargetToInitiator :

      (SCSI_MMC_DATA_WRITE == e_direction)

      ? kSCSIDataTransfer_FromInitiatorToTarget

      : kSCSIDataTransfer_NoDataTransfer;

  if (!i_buf)

    dir = kSCSIDataTransfer_NoDataTransfer;

  if (i_buf > MAX_BIG_BUFF_SIZE) {

    fprintf(stderr, "Excessive request size: %d bytes\n", i_buf);

    return TR_ILLEGAL;

  }

  buf.address = (IOVirtualAddress)p_buf;

  buf.length = i_buf;

  ret = (*p_env->scsi_task)->SetCommandDescriptorBlock(p_env->scsi_task,

                                                       cmdbuf, i_cdb);

  if (ret != kIOReturnSuccess) {

    fprintf(stderr, "SetCommandDescriptorBlock: %x\n", ret);

    return TR_UNKNOWN;

  }

  ret = (*p_env->scsi_task)->SetScatterGatherEntries(p_env->scsi_task, &buf, 1,

                                                     i_buf, dir);

  if (ret != kIOReturnSuccess) {

    fprintf(stderr, "SetScatterGatherEntries: %x\n", ret);

    return TR_UNKNOWN;

  }

  ret = (*p_env->scsi_task)->ExecuteTaskSync(p_env->scsi_task, &p_env->sense,

                                             &p_env->status,

                                             &p_env->realized_len);

  if (ret != kIOReturnSuccess) {

    fprintf(stderr, "ExecuteTaskSync: %x\n", ret);

    return TR_UNKNOWN;

  }

  if (p_env->status != kSCSITaskStatus_GOOD) {

    int i;

    fprintf(stderr, "SCSI status: %x\n", p_env->status);

    fprintf(stderr, "Sense: %x %x %x\n",

            p_env->sense.SENSE_KEY,

            p_env->sense.ADDITIONAL_SENSE_CODE,

            p_env->sense.ADDITIONAL_SENSE_CODE_QUALIFIER);

    for (i = 0; i < i_cdb; i++)

      fprintf(stderr, "%02x ", cmdbuf[i]);

    fprintf(stderr, "\n");

    memcpy((void *) p_env->gen.scsi_mmc_sense, &p_env->sense, kSenseDefaultSize);

    return TR_UNKNOWN;

  }

  if (p_env->sense.VALID_RESPONSE_CODE) {

    char key = p_env->sense.SENSE_KEY & 0xf;

    char ASC = p_env->sense.ADDITIONAL_SENSE_CODE;

    char ASCQ = p_env->sense.ADDITIONAL_SENSE_CODE_QUALIFIER;

    switch (key) {

    case 0:

      if (errno == 0)

        errno = EIO;

      return (TR_UNKNOWN);

    case 1:

      break;

    case 2:

      if (errno == 0)

        errno = EBUSY;

      return (TR_BUSY);

    case 3:

      if (ASC == 0x0C && ASCQ == 0x09) {

        /* loss of streaming */

        if (errno == 0)

          errno = EIO;

        return (TR_STREAMING);

      } else {

        if (errno == 0)

          errno = EIO;

        return (TR_MEDIUM);

      }

    case 4:

      if (errno == 0)

        errno = EIO;

      return (TR_FAULT);

    case 5:

      if (errno == 0)

        errno = EINVAL;

      return (TR_ILLEGAL);

    default:

      if (errno == 0)

        errno = EIO;

      return (TR_UNKNOWN);

    }

  }

  errno = 0;

  return (0);

}

#endif

#if 0

/**

  Run a SCSI MMC command.

  cdio          CD structure set by cdio_open().

  i_timeout     time in milliseconds we will wait for the command

                to complete. If this value is -1, use the default

                time-out value.

  p_buf         Buffer for data, both sending and receiving

  i_buf         Size of buffer

  e_direction   direction the transfer is to go.

  cdb           CDB bytes. All values that are needed should be set on

                input. We'll figure out what the right CDB length should be.

  We return true if command completed successfully and false if not.

 */

static int

run_mmc_cmd_osx( const void *p_user_data,

                 unsigned int i_timeout_ms,

                 unsigned int i_cdb, const mmc_cdb_t *p_cdb,

                 cdio_mmc_direction_t e_direction,

                 unsigned int i_buf, /*in/out*/ void *p_buf )

{

#ifndef SCSI_MMC_FIXED

  return DRIVER_OP_UNSUPPORTED;

#else

  const _img_private_t *p_env = p_user_data;

  SCSITaskDeviceInterface **sc;

  SCSITaskInterface **cmd = NULL;

  IOVirtualRange iov;

  SCSI_Sense_Data senseData;

  SCSITaskStatus status;

  UInt64 bytesTransferred;

  IOReturn ioReturnValue;

  int ret = 0;

  if (NULL == p_user_data) return 2;

  /* Make sure pp_scsiTaskDeviceInterface is initialized. FIXME: The code

     should probably be reorganized better for this. */

  if (!p_env->gen.toc_init) read_toc_osx (p_user_data) ;

  sc = p_env->pp_scsiTaskDeviceInterface;

  if (NULL == sc) return 3;

  cmd = (*sc)->CreateSCSITask(sc);

  if (cmd == NULL) {

    cdio_warn("Failed to create SCSI task");

    return -1;

  }

  iov.address = (IOVirtualAddress) p_buf;

  iov.length = i_buf;

  ioReturnValue = (*cmd)->SetCommandDescriptorBlock(cmd, (UInt8 *) p_cdb,

                                                    i_cdb);

  if (ioReturnValue != kIOReturnSuccess) {

    cdio_warn("SetCommandDescriptorBlock failed with status %x",

              ioReturnValue);

    return -1;

  }

  ioReturnValue = (*cmd)->SetScatterGatherEntries(cmd, &iov, 1, i_buf,

                                                  (SCSI_MMC_DATA_READ == e_direction ) ?

                                                  kSCSIDataTransfer_FromTargetToInitiator :

                                                  kSCSIDataTransfer_FromInitiatorToTarget);

  if (ioReturnValue != kIOReturnSuccess) {

    cdio_warn("SetScatterGatherEntries failed with status %x", ioReturnValue);

    return -1;

  }

  ioReturnValue = (*cmd)->SetTimeoutDuration(cmd, i_timeout_ms );

  if (ioReturnValue != kIOReturnSuccess) {

    cdio_warn("SetTimeoutDuration failed with status %x", ioReturnValue);

    return -1;

  }

  memset(&senseData, 0, sizeof(senseData));

  ioReturnValue = (*cmd)->ExecuteTaskSync(cmd,&senseData, &status, &

                                          bytesTransferred);

  if (ioReturnValue != kIOReturnSuccess) {

    cdio_warn("Command execution failed with status %x", ioReturnValue);

    return -1;

  }

  if (cmd != NULL) {

    (*cmd)->Release(cmd);

  }

  return (ret);

#endif

}

#endif /* 0*/

/***************************************************************************

 * GetDeviceIterator - Gets an io_iterator_t for our class type

 ***************************************************************************/

static io_iterator_t

GetDeviceIterator ( const char * deviceClass )

{

  IOReturn      err      = kIOReturnSuccess;

  io_iterator_t iterator = MACH_PORT_NULL;

  err = IOServiceGetMatchingServices ( kIOMasterPortDefault,

                                       IOServiceMatching ( deviceClass ),

                                       &iterator );

  cdio_assert ( err == kIOReturnSuccess );

  return iterator;

}

/***************************************************************************

 * GetFeaturesFlagsForDrive -Gets the bitfield which represents the

 * features flags.

 ***************************************************************************/

static bool

GetFeaturesFlagsForDrive ( CFDictionaryRef dict,

                           uint32_t *i_cdFlags,

                           uint32_t *i_dvdFlags )

{

  CFDictionaryRef propertiesDict = 0;

  CFNumberRef     flagsNumberRef = 0;

  *i_cdFlags = 0;

  *i_dvdFlags= 0;

  propertiesDict = ( CFDictionaryRef )

    CFDictionaryGetValue ( dict,

                           CFSTR ( kIOPropertyDeviceCharacteristicsKey ) );

  if ( propertiesDict == 0 ) return false;

  /* Get the CD features */

  flagsNumberRef = ( CFNumberRef )

    CFDictionaryGetValue ( propertiesDict,

                           CFSTR ( kIOPropertySupportedCDFeatures ) );

  if ( flagsNumberRef != 0 ) {

    CFNumberGetValue ( flagsNumberRef, kCFNumberLongType, i_cdFlags );

  }

  /* Get the DVD features */

  flagsNumberRef = ( CFNumberRef )

    CFDictionaryGetValue ( propertiesDict,

                           CFSTR ( kIOPropertySupportedDVDFeatures ) );

  if ( flagsNumberRef != 0 ) {

    CFNumberGetValue ( flagsNumberRef, kCFNumberLongType, i_dvdFlags );

  }

  return true;

}

/**

  Get disc type associated with the cd object.

*/

static discmode_t

get_discmode_osx (void *p_user_data)

{

  _img_private_t *p_env = p_user_data;

  char str[10];

  int32_t i_discmode = CDIO_DISC_MODE_ERROR;

  CFDictionaryRef propertiesDict = 0;

  CFStringRef data;

  propertiesDict  = GetRegistryEntryProperties ( p_env->MediaClass_service );

  if ( propertiesDict == 0 ) return i_discmode;

  data = ( CFStringRef )

    CFDictionaryGetValue ( propertiesDict, CFSTR ( kIODVDMediaTypeKey ) );

  if( CFStringGetCString( data, str, sizeof(str),

                          kCFStringEncodingASCII ) ) {

    if (0 == strncmp(str, "DVD+R", strlen(str)) )

      i_discmode = CDIO_DISC_MODE_DVD_PR;

    else if (0 == strncmp(str, "DVD+RW", strlen(str)) )

      i_discmode = CDIO_DISC_MODE_DVD_PRW;

    else if (0 == strncmp(str, "DVD-R", strlen(str)) )

      i_discmode = CDIO_DISC_MODE_DVD_R;

    else if (0 == strncmp(str, "DVD-RW", strlen(str)) )

      i_discmode = CDIO_DISC_MODE_DVD_RW;

    else if (0 == strncmp(str, "DVD-ROM", strlen(str)) )

      i_discmode = CDIO_DISC_MODE_DVD_ROM;

    else if (0 == strncmp(str, "DVD-RAM", strlen(str)) )

      i_discmode = CDIO_DISC_MODE_DVD_RAM;

    else if (0 == strncmp(str, "CD-ROM", strlen(str)) )

      i_discmode = CDIO_DISC_MODE_CD_DATA;

    else if (0 == strncmp(str, "CDR", strlen(str)) )

      i_discmode = CDIO_DISC_MODE_CD_DATA;

    else if (0 == strncmp(str, "CDRW", strlen(str)) )

      i_discmode = CDIO_DISC_MODE_CD_DATA;

    //??  Handled by below? CFRelease( data );

  }

  CFRelease( propertiesDict );

  if (CDIO_DISC_MODE_CD_DATA == i_discmode) {

    /* Need to do more classification */

    return get_discmode_cd_generic(p_user_data);

  }

  return i_discmode;

}

static io_service_t

get_drive_service_osx(const _img_private_t *p_env)

{

  io_service_t  service;

  io_iterator_t service_iterator;

  service_iterator = GetDeviceIterator ( kIOCDBlockStorageDeviceClassString );

  if( service_iterator == MACH_PORT_NULL ) return 0;

  service = IOIteratorNext( service_iterator );

  if( service == 0 ) return 0;

  do

    {

      char psz_service[MAX_SERVICE_NAME];

      IORegistryEntryGetPath(service, kIOServicePlane, psz_service);

      psz_service[MAX_SERVICE_NAME-1] = '\0';

      /* FIXME: This is all hoaky. Here we need info from a parent class,

         psz_service of what we opened above. We are relying on the

         fact that the name  will be a substring of the name we

         openned with.

      */

      if (0 == strncmp(psz_service, p_env->psz_MediaClass_service,

                       strlen(psz_service))) {

        /* Found our device */

        IOObjectRelease( service_iterator );

        return service;

      }

      IOObjectRelease( service );

    } while( ( service = IOIteratorNext( service_iterator ) ) != 0 );

  IOObjectRelease( service_iterator );

  return service;

}

static void

get_drive_cap_osx(const void *p_user_data,

                  /*out*/ cdio_drive_read_cap_t  *p_read_cap,

                  /*out*/ cdio_drive_write_cap_t *p_write_cap,

                  /*out*/ cdio_drive_misc_cap_t  *p_misc_cap)

{

  const _img_private_t *p_env = p_user_data;

  uint32_t i_cdFlags;

  uint32_t i_dvdFlags;

  io_service_t  service = get_drive_service_osx(p_env);

  if( service == 0 ) goto err_exit;

  /* Found our device */

  {

    CFDictionaryRef  properties = GetRegistryEntryProperties ( service );

    if (! GetFeaturesFlagsForDrive ( properties, &i_cdFlags,

                                     &i_dvdFlags ) ) {

      IOObjectRelease( service );

      goto err_exit;

    }

    /* Reader */

    if ( 0 != (i_cdFlags & kCDFeaturesAnalogAudioMask) )

      *p_read_cap  |= CDIO_DRIVE_CAP_READ_AUDIO;

    if ( 0 != (i_cdFlags & kCDFeaturesWriteOnceMask) )

      *p_write_cap |= CDIO_DRIVE_CAP_WRITE_CD_R;

    if ( 0 != (i_cdFlags & kCDFeaturesCDDAStreamAccurateMask) )

      *p_read_cap  |= CDIO_DRIVE_CAP_READ_CD_DA;

    if ( 0 != (i_dvdFlags & kDVDFeaturesReadStructuresMask) )

      *p_read_cap  |= CDIO_DRIVE_CAP_READ_DVD_ROM;

    if ( 0 != (i_cdFlags & kCDFeaturesReWriteableMask) )

      *p_write_cap |= CDIO_DRIVE_CAP_WRITE_CD_RW;

    if ( 0 != (i_dvdFlags & kDVDFeaturesWriteOnceMask) )

      *p_write_cap |= CDIO_DRIVE_CAP_WRITE_DVD_R;

    if ( 0 != (i_dvdFlags & kDVDFeaturesRandomWriteableMask) )

      *p_write_cap |= CDIO_DRIVE_CAP_WRITE_DVD_RAM;

    if ( 0 != (i_dvdFlags & kDVDFeaturesReWriteableMask) )

      *p_write_cap |= CDIO_DRIVE_CAP_WRITE_DVD_RW;

    /***

        if ( 0 != (i_dvdFlags & kDVDFeaturesPlusRMask) )

        *p_write_cap |= CDIO_DRIVE_CAP_WRITE_DVD_PR;

        if ( 0 != (i_dvdFlags & kDVDFeaturesPlusRWMask )

        *p_write_cap |= CDIO_DRIVE_CAP_WRITE_DVD_PRW;

        ***/

    /* FIXME: fill out. For now assume CD-ROM is relatively modern. */

      *p_misc_cap = (

                     CDIO_DRIVE_CAP_MISC_CLOSE_TRAY

                     | CDIO_DRIVE_CAP_MISC_EJECT

                     | CDIO_DRIVE_CAP_MISC_LOCK

                     | CDIO_DRIVE_CAP_MISC_SELECT_SPEED

                     | CDIO_DRIVE_CAP_MISC_MULTI_SESSION

                     | CDIO_DRIVE_CAP_MISC_MEDIA_CHANGED

                     | CDIO_DRIVE_CAP_MISC_RESET

                     | CDIO_DRIVE_CAP_READ_MCN

                     | CDIO_DRIVE_CAP_READ_ISRC

                     );

    IOObjectRelease( service );

  }

  return;

 err_exit:

  *p_misc_cap = *p_write_cap = *p_read_cap = CDIO_DRIVE_CAP_UNKNOWN;

  return;

}

#if 1

/****************************************************************************