/*

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

  Copyright (C) 2002-2006, 2008-2013, 2017 Rocky Bernstein

  <rocky@gnu.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 Linux-specific code and implements low-level

   control of the CD drive.

*/

#ifdef HAVE_CONFIG_H

# include "config.h"

# define __CDIO_CONFIG_H__ 1

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#endif

#include <cdio/sector.h>

#include <cdio/util.h>

#include <cdio/types.h>

#include <cdio/mmc_cmds.h>

#include <cdio/audio.h>

#include <cdio/cdtext.h>

#include "cdio_assert.h"

#include "cdio_private.h"

#ifdef HAVE_LINUX_CDROM

#include <sys/types.h>

#include <sys/wait.h>

#include <limits.h>

#if defined(HAVE_LINUX_VERSION_H)

# include <linux/version.h>

# if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,16)

#   define __CDIO_LINUXCD_BUILD

# else

#  error "You need a kernel greater than 2.2.16 to have CDROM support"

# endif

#else

#  error "You need <linux/version.h> to have CDROM support"

#endif

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#include <mntent.h>

#include <linux/cdrom.h>

#include <scsi/scsi.h>

#include <scsi/sg.h>

#include <scsi/scsi_ioctl.h>

#include <sys/mount.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/ioctl.h>

#ifndef PATH_MAX

#define PATH_MAX 4096

#endif

typedef enum {

  _AM_NONE,

  _AM_IOCTL,

  _AM_READ_CD,

  _AM_READ_10,

  _AM_MMC_RDWR,

  _AM_MMC_RDWR_EXCL,

} access_mode_t;

typedef struct {

  /* Things common to all drivers like this.

     This must be first. */

  generic_img_private_t gen;

  access_mode_t access_mode;

  /* Some of the more OS specific things. */

  /* Entry info for each track, add 1 for leadout. */

  struct cdrom_tocentry  tocent[CDIO_CD_MAX_TRACKS+1];

  struct cdrom_tochdr    tochdr;

} _img_private_t;

/* Some ioctl() errno values which occur when the tray is empty */

#define ERRNO_TRAYEMPTY(errno)  \

        ((errno == EIO) || (errno == ENOENT) || (errno == EINVAL))

/**** prototypes for static functions ****/

static bool is_cdrom_linux(const char *drive, char *mnttype);

static bool read_toc_linux (void *p_user_data);

static driver_return_code_t

run_mmc_cmd_linux( void *p_user_data,

                   unsigned int i_timeout,

                   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 );

static access_mode_t

str_to_access_mode_linux(const char *psz_access_mode)

{

  const access_mode_t default_access_mode = _AM_IOCTL;

  if (NULL==psz_access_mode) return default_access_mode;

  if (!strcmp(psz_access_mode, "IOCTL"))

    return _AM_IOCTL;

  else if (!strcmp(psz_access_mode, "READ_CD"))

    return _AM_READ_CD;

  else if (!strcmp(psz_access_mode, "READ_10"))

    return _AM_READ_10;

  else if (!strcmp(psz_access_mode, "MMC_RDWR"))

    return _AM_MMC_RDWR;

  else if (!strcmp(psz_access_mode, "MMC_RDWR_EXCL"))

    return _AM_MMC_RDWR_EXCL;

  else {

    cdio_warn ("unknown access type: %s. Default IOCTL used.",

               psz_access_mode);

    return default_access_mode;

  }

}

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 = 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 = 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 ( mnt_type && mnt_dev ) {

	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;

}

/*!

  Get the volume of an audio CD.

  @param p_cdio the CD object to be acted upon.

*/

static driver_return_code_t

audio_get_volume_linux (void *p_user_data,

                        /*out*/ cdio_audio_volume_t *p_volume)

{

  const _img_private_t *p_env = p_user_data;

  return ioctl(p_env->gen.fd, CDROMVOLREAD, p_volume);

}

/*!

  Pause playing CD through analog output

  @param p_cdio the CD object to be acted upon.

*/

static driver_return_code_t

audio_pause_linux (void *p_user_data)

{

  const _img_private_t *p_env = p_user_data;

  return ioctl(p_env->gen.fd, CDROMPAUSE);

}

/*!

  Playing starting at given MSF through analog output

  @param p_cdio the CD object to be acted upon.

*/

static driver_return_code_t

audio_play_msf_linux (void *p_user_data, msf_t *p_start_msf, msf_t *p_end_msf)

{

  const _img_private_t *p_env = p_user_data;

  struct cdrom_msf cdrom_msf;

  cdrom_msf.cdmsf_min0   = cdio_from_bcd8(p_start_msf->m);

  cdrom_msf.cdmsf_sec0   = cdio_from_bcd8(p_start_msf->s);

  cdrom_msf.cdmsf_frame0 = cdio_from_bcd8(p_start_msf->f);

  cdrom_msf.cdmsf_min1   = cdio_from_bcd8(p_end_msf->m);

  cdrom_msf.cdmsf_sec1   = cdio_from_bcd8(p_end_msf->s);

  cdrom_msf.cdmsf_frame1 = cdio_from_bcd8(p_end_msf->f);

  return ioctl(p_env->gen.fd, CDROMPLAYMSF, &cdrom_msf);

}

/*!

  Playing CD through analog output at the desired track and index

  @param p_cdio the CD object to be acted upon.

  @param p_track_index location to start/end.

*/

static driver_return_code_t

audio_play_track_index_linux (void *p_user_data,

                              cdio_track_index_t *p_track_index)

{

  const _img_private_t *p_env = p_user_data;

  return ioctl(p_env->gen.fd, CDROMPLAYTRKIND, p_track_index);

}

/*!

  Read Audio Subchannel information

  @param p_user_data the CD object to be acted upon.

  @param p_subchannel returned information

*/

static driver_return_code_t

audio_read_subchannel_linux (void *p_user_data,

                             /*out*/ cdio_subchannel_t *p_subchannel)

{

  const _img_private_t *p_env = p_user_data;

  struct cdrom_subchnl subchannel;

  int   i_rc;

  subchannel.cdsc_format = CDIO_CDROM_MSF;

  i_rc = ioctl(p_env->gen.fd, CDROMSUBCHNL, &subchannel);

  if (0 == i_rc) {

    p_subchannel->control      = subchannel.cdsc_ctrl;

    p_subchannel->track        = subchannel.cdsc_trk;

    p_subchannel->index        = subchannel.cdsc_ind;

    p_subchannel->abs_addr.m   =

      cdio_to_bcd8(subchannel.cdsc_absaddr.msf.minute);

    p_subchannel->abs_addr.s   =

      cdio_to_bcd8(subchannel.cdsc_absaddr.msf.second);

    p_subchannel->abs_addr.f   =

      cdio_to_bcd8(subchannel.cdsc_absaddr.msf.frame);

    p_subchannel->rel_addr.m   =

      cdio_to_bcd8(subchannel.cdsc_reladdr.msf.minute);

    p_subchannel->rel_addr.s   =

      cdio_to_bcd8(subchannel.cdsc_reladdr.msf.second);

    p_subchannel->rel_addr.f   =

      cdio_to_bcd8(subchannel.cdsc_reladdr.msf.frame);

    p_subchannel->audio_status = subchannel.cdsc_audiostatus;

    return DRIVER_OP_SUCCESS;

  } else {

    cdio_info ("ioctl CDROMSUBCHNL failed: %s\n", strerror(errno));

    return DRIVER_OP_ERROR;

  }

}

/*!

  Resume playing an audio CD.

  @param p_cdio the CD object to be acted upon.

*/

static driver_return_code_t

audio_resume_linux (void *p_user_data)

{

  const _img_private_t *p_env = p_user_data;

  return ioctl(p_env->gen.fd, CDROMRESUME, 0);

}

/*!

  Set the volume of an audio CD.

  @param p_user_data the CD object to be acted upon.

*/

static driver_return_code_t

audio_set_volume_linux (void *p_user_data, cdio_audio_volume_t *p_volume)

{

  const _img_private_t *p_env = p_user_data;

  return ioctl(p_env->gen.fd, CDROMVOLCTRL, p_volume);

}

/*!

  Stop playing an audio CD.

  @param p_user_data the CD object to be acted upon.

*/

static driver_return_code_t

audio_stop_linux (void *p_user_data)

{

  const _img_private_t *p_env = p_user_data;

  return ioctl(p_env->gen.fd, CDROMSTOP);

}

static bool

is_mmc_supported(void *user_data)

{

    _img_private_t *env = user_data;

    return (_AM_NONE == env->access_mode) ? false : true;

}

/*!

  Return the value associated with the key "arg".

*/

static const char *

get_arg_linux (void *env, const char key[])

{

  _img_private_t *_obj = env;

  if (!strcmp (key, "source")) {

    return _obj->gen.source_name;

  } else if (!strcmp (key, "access-mode")) {

    switch (_obj->access_mode) {

    case _AM_IOCTL:

      return "IOCTL";

    case _AM_READ_CD:

      return "READ_CD";

    case _AM_READ_10:

      return "READ_10";

    case _AM_MMC_RDWR:

      return "MMC_RDWR";

    case _AM_MMC_RDWR_EXCL:

      return "MMC_RDWR_EXCL";

    case _AM_NONE:

      return "no access method";

    }

  } else if (!strcmp (key, "scsi-tuple")) {

    return _obj->gen.scsi_tuple;

  } else if (!strcmp (key, "mmc-supported?")) {

      return is_mmc_supported(env) ? "true" : "false";

  }

  return NULL;

}

#undef USE_LINUX_CAP

#ifdef USE_LINUX_CAP

/*!

  Return the the kind of drive capabilities of device.

  Note: string is malloc'd so caller should free() then returned

  string when done with it.

 */

static void

get_drive_cap_linux (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;

  int32_t i_drivetype;

  i_drivetype = ioctl (p_env->gen.fd, CDROM_GET_CAPABILITY, CDSL_CURRENT);

  if (i_drivetype < 0) {

    *p_read_cap  = CDIO_DRIVE_CAP_ERROR;

    *p_write_cap = CDIO_DRIVE_CAP_ERROR;

    *p_misc_cap  = CDIO_DRIVE_CAP_ERROR;

    return;

  }

  *p_read_cap  = 0;

  *p_write_cap = 0;

  *p_misc_cap  = 0;

  /* Reader */

  if (i_drivetype & CDC_PLAY_AUDIO)

    *p_read_cap  |= CDIO_DRIVE_CAP_READ_AUDIO;

  if (i_drivetype & CDC_CD_R)

    *p_read_cap  |= CDIO_DRIVE_CAP_READ_CD_R;

  if (i_drivetype & CDC_CD_RW)

    *p_read_cap  |= CDIO_DRIVE_CAP_READ_CD_RW;

  if (i_drivetype & CDC_DVD)

    *p_read_cap  |= CDIO_DRIVE_CAP_READ_DVD_ROM;

  /* Writer */

  if (i_drivetype & CDC_CD_RW)

    *p_read_cap  |= CDIO_DRIVE_CAP_WRITE_CD_RW;

  if (i_drivetype & CDC_DVD_R)

    *p_read_cap  |= CDIO_DRIVE_CAP_WRITE_DVD_R;

  if (i_drivetype & CDC_DVD_RAM)

    *p_read_cap  |= CDIO_DRIVE_CAP_WRITE_DVD_RAM;

  /* Misc */

  if (i_drivetype & CDC_CLOSE_TRAY)

    *p_misc_cap  |= CDIO_DRIVE_CAP_MISC_CLOSE_TRAY;

  if (i_drivetype & CDC_OPEN_TRAY)

    *p_misc_cap  |= CDIO_DRIVE_CAP_MISC_EJECT;

  if (i_drivetype & CDC_LOCK)

    *p_misc_cap  |= CDIO_DRIVE_CAP_MISC_LOCK;

  if (i_drivetype & CDC_SELECT_SPEED)

    *p_misc_cap  |= CDIO_DRIVE_CAP_MISC_SELECT_SPEED;

  if (i_drivetype & CDC_SELECT_DISC)

    *p_misc_cap  |= CDIO_DRIVE_CAP_MISC_SELECT_DISC;

  if (i_drivetype & CDC_MULTI_SESSION)

    *p_misc_cap  |= CDIO_DRIVE_CAP_MISC_MULTI_SESSION;

  if (i_drivetype & CDC_MEDIA_CHANGED)

    *p_misc_cap  |= CDIO_DRIVE_CAP_MISC_MEDIA_CHANGED;

  if (i_drivetype & CDC_RESET)

    *p_misc_cap  |= CDIO_DRIVE_CAP_MISC_RESET;

}

#endif

/*! Get the LSN of the first track of the last session of

  on the CD.

  @param p_cdio the CD object to be acted upon.

  @param i_last_session pointer to the session number to be returned.

*/

static driver_return_code_t

get_last_session_linux (void *p_user_data,

                        /*out*/ lsn_t *i_last_session)

{

  const _img_private_t *p_env = p_user_data;

  struct cdrom_multisession ms;

  int i_rc;

  ms.addr_format = CDROM_LBA;

  i_rc = ioctl(p_env->gen.fd, CDROMMULTISESSION, &ms);

  if (0 == i_rc) {

    *i_last_session = ms.addr.lba;

    return DRIVER_OP_SUCCESS;

  } else {

    cdio_warn ("ioctl CDROMMULTISESSION failed: %s\n", strerror(errno));

    return DRIVER_OP_ERROR;

  }

}

/*!

  Find out if media has changed since the last call.

  @param p_user_data the environment object to be acted upon.

  @return 1 if media has changed since last call, 0 if not. Error

  return codes are the same as driver_return_code_t

*/

static int

get_media_changed_linux (const void *p_user_data) {

  const _img_private_t *p_env = p_user_data;

  return ioctl(p_env->gen.fd, CDROM_MEDIA_CHANGED, 0);

}

/*!

  Return the media catalog number MCN.

  Note: string is malloc'd so caller should free() then returned

  string when done with it.

 */

static char *

get_mcn_linux (const void *p_user_data) {

  struct cdrom_mcn mcn;

  const _img_private_t *p_env = p_user_data;

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

  if (ioctl(p_env->gen.fd, CDROM_GET_MCN, &mcn) != 0)

    return NULL;

  return strdup((char *)mcn.medium_catalog_number);

}

/*!

  Return the international standard recording code ISRC.

  Note: string is malloc'd so caller should free() then returned

  string when done with it.

 */

static char *

get_track_isrc_linux (const void *p_user_data, track_t i_track) {

  const _img_private_t *p_env = p_user_data;

  return mmc_get_track_isrc( p_env->gen.cdio, i_track );

}

/*!

  Get format of track.

*/

static track_format_t

get_track_format_linux(void *p_user_data, track_t i_track)

{

  _img_private_t *p_env = p_user_data;

  if ( !p_env ) return TRACK_FORMAT_ERROR;

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

  if (i_track > (p_env->gen.i_tracks+p_env->gen.i_first_track)

      || i_track < p_env->gen.i_first_track)

    return TRACK_FORMAT_ERROR;

  i_track -= p_env->gen.i_first_track;

  /* This is pretty much copied from the "badly broken" cdrom_count_tracks

     in linux/cdrom.c.

   */

  if (p_env->tocent[i_track].cdte_ctrl & CDIO_CDROM_DATA_TRACK) {

    if (p_env->tocent[i_track].cdte_format == CDIO_CDROM_CDI_TRACK)

      return TRACK_FORMAT_CDI;

    else if (p_env->tocent[i_track].cdte_format == CDIO_CDROM_XA_TRACK)

      return TRACK_FORMAT_XA;

    else

      return TRACK_FORMAT_DATA;

  } else

    return TRACK_FORMAT_AUDIO;

}

/*!

  Return true if we have XA data (green, mode2 form1) or

  XA data (green, mode2 form2). That is track begins:

  sync - header - subheader

  12     4      -  8

  FIXME: there's gotta be a better design for this and get_track_format?

*/

static bool

get_track_green_linux(void *p_user_data, track_t i_track)

{

  _img_private_t *p_env = p_user_data;

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

  if (i_track >= (p_env->gen.i_tracks+p_env->gen.i_first_track)

      || i_track < p_env->gen.i_first_track)

    return false;

  i_track -= p_env->gen.i_first_track;

  /* FIXME: Dunno if this is the right way, but it's what

     I was using in cd-info for a while.

   */

  return ((p_env->tocent[i_track].cdte_ctrl & 2) != 0);

}

/*!

  Return the starting MSF (minutes/secs/frames) for track number

  track_num in obj.  Track numbers usually start at something

  greater than 0, usually 1.

  The "leadout" track is specified either by

  using i_track LEADOUT_TRACK or the total tracks+1.

  False is returned if there is no track entry.

*/

static bool

get_track_msf_linux(void *p_user_data, track_t i_track, msf_t *msf)

{

  _img_private_t *p_env = p_user_data;

  if (NULL == msf ||

      (i_track > CDIO_CD_MAX_TRACKS && i_track != CDIO_CDROM_LEADOUT_TRACK))

    return false;

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

  if (i_track == CDIO_CDROM_LEADOUT_TRACK)

    i_track = p_env->gen.i_tracks + p_env->gen.i_first_track;

  if (i_track > (p_env->gen.i_tracks+p_env->gen.i_first_track)

      || i_track < p_env->gen.i_first_track) {

    return false;

  } else {

    struct cdrom_msf0  *msf0=

      &p_env->tocent[i_track-p_env->gen.i_first_track].cdte_addr.msf;

    msf->m = cdio_to_bcd8(msf0->minute);

    msf->s = cdio_to_bcd8(msf0->second);

    msf->f = cdio_to_bcd8(msf0->frame);

    return true;

  }

}

/*!

  Check, if a device is mounted and return the target (=mountpoint)

  needed for umounting (idea taken from libunieject).

 */

static int is_mounted (const char * device, char * target) {

  FILE * fp;

  char real_device_1[PATH_MAX];

  char real_device_2[PATH_MAX];

  char file_device[PATH_MAX];

  char file_target[PATH_MAX];

  fp = fopen ( "/proc/mounts", "r");

  /* Older systems just have /etc/mtab */

  if(!fp)

    fp = fopen ( "/etc/mtab", "r");

  /* Neither /proc/mounts nor /etc/mtab could be opened, give up here */

  if(!fp) return 0;

  /* Get real device */

  if (NULL == cdio_realpath(device, real_device_1)) {

    cdio_warn("Problems resolving device %s: %s\n", device, strerror(errno));

  }

  /* Read entries */

  while ( fscanf(fp, "%s %s %*s %*s %*d %*d\n", file_device, file_target) != EOF ) {

      if (NULL == cdio_realpath(file_device, real_device_2)) {

          cdio_debug("Problems resolving device %s: %s\n",

                     file_device, strerror(errno));

      }

    if(!strcmp(real_device_1, real_device_2)) {

      strcpy(target, file_target);

      fclose(fp);

      return 1;

    }

  }

  fclose(fp);

  return 0;

}

/*!

  Umount a filesystem specified by it's mountpoint. We must do this

  by forking and calling the umount command, because the raw umount

  (or umount2) system calls will *always* trigger an EPERM even if

  we are allowed to umount the filesystem. The umount command is

  suid root.

  Code here is inspired by the standard linux eject command by

  Jeff Tranter and Frank Lichtenheld.

 */

static int do_umount(char * target) {

  int status;

  switch (fork()) {

  case 0: /* child */

    execlp("pumount", "pumount", target, NULL);

    execlp("umount", "umount", target, NULL);

    return -1;

  case -1:

    return -1;

  default: /* parent */

    wait(&status);

    if (WIFEXITED(status) == 0) {

      return -1;

    }

    if (WEXITSTATUS(status) != 0) {

      return -1;

    }

    break;

  }

  return 0;

}

/*!

  Eject media in CD-ROM drive. Return DRIVER_OP_SUCCESS if successful,

  DRIVER_OP_ERROR on error.

 */

static driver_return_code_t

eject_media_linux (void *p_user_data) {

  _img_private_t *p_env = p_user_data;

  driver_return_code_t ret=DRIVER_OP_SUCCESS;

  int status;

  bool was_open = false;

  char mount_target[PATH_MAX];

  /* Make sure the device is opened in read/write mode. */

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

    close(p_env->gen.fd);

    was_open = true;

  }

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

  if ( p_env->gen.fd <= -1 ) return DRIVER_OP_ERROR;

  if ((status = ioctl(p_env->gen.fd, CDROM_DRIVE_STATUS, CDSL_CURRENT)) > 0) {

    switch(status) {

    case CDS_TRAY_OPEN:

      cdio_info ("Drive status reports that tray is open\n");

      break;

    default:

      cdio_info ("Unknown state of CD-ROM (%d)\n", status);

      /* Fall through */

    case CDS_DISC_OK:

      /* Some systems automount the drive, so we must umount it.

         We check if the drive is actually mounted */

      if(is_mounted (p_env->gen.source_name, mount_target)) {

        /* Try to umount the drive */

        if(do_umount(mount_target)) {

          cdio_log(CDIO_LOG_WARN, "Could not umount %s\n",

                   p_env->gen.source_name);

          ret=DRIVER_OP_ERROR;

          break;

        }

        /* For some reason, we must close and reopen the device after

           it got umounted (at least the commandline eject program

           opens the device just after umounting it) */

        close(p_env->gen.fd);

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

      }

      if((ret = ioctl(p_env->gen.fd, CDROMEJECT)) != 0) {

        int eject_error = errno;

        /* Try ejecting the MMC way... */

        ret = mmc_eject_media(p_env->gen.cdio);

        if (0 != ret) {

          cdio_info("ioctl CDROMEJECT and MMC eject failed: %s",

                    strerror(eject_error));

          ret = DRIVER_OP_ERROR;

        }

      }

      /* force kernel to reread partition table when new disc inserted */

      if (0 != ioctl(p_env->gen.fd, BLKRRPART)) {

        cdio_info ("BLKRRPART request failed: %s\n", strerror(errno));

      }

      break;

    }

  } else {

    cdio_warn ("CDROM_DRIVE_STATUS failed: %s\n", strerror(errno));

    ret=DRIVER_OP_ERROR;

  }

  if(!was_open) {

    close(p_env->gen.fd);

    p_env->gen.fd = -1;

  }

  return ret;

}

/*!

  Get disc type associated with cd object.

*/

static discmode_t

dvd_discmode_linux (_img_private_t *p_env)

{

  discmode_t discmode=CDIO_DISC_MODE_NO_INFO;

  /* See if this is a DVD. */

  cdio_dvd_struct_t dvd;  /* DVD READ STRUCT for layer 0. */

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

  dvd.physical.type = CDIO_DVD_STRUCT_PHYSICAL;

  dvd.physical.layer_num = 0;

  if (0 == ioctl (p_env->gen.fd, DVD_READ_STRUCT, &dvd)) {

    switch(dvd.physical.layer[0].book_type) {

    case CDIO_DVD_BOOK_DVD_ROM:  return CDIO_DISC_MODE_DVD_ROM;

    case CDIO_DVD_BOOK_DVD_RAM:  return CDIO_DISC_MODE_DVD_RAM;

    case CDIO_DVD_BOOK_DVD_R:    return CDIO_DISC_MODE_DVD_R;

    case CDIO_DVD_BOOK_DVD_RW:   return CDIO_DISC_MODE_DVD_RW;

    case CDIO_DVD_BOOK_DVD_PR:   return CDIO_DISC_MODE_DVD_PR;

    case CDIO_DVD_BOOK_DVD_PRW:  return CDIO_DISC_MODE_DVD_PRW;

    default:                     return CDIO_DISC_MODE_DVD_OTHER;

    }

  }

  return discmode;

}

/*!

  Get disc type associated with the cd object.

*/

static discmode_t

get_discmode_linux (void *p_user_data)

{

  _img_private_t *p_env = p_user_data;

  discmode_t discmode;

  if (!p_env) return CDIO_DISC_MODE_ERROR;

  /* Try DVD types first. See note below. */

  discmode = dvd_discmode_linux(p_env);

  if (CDIO_DISC_MODE_NO_INFO != discmode) return discmode;

  /*

     Justin B Ruggles <jruggle@earthlink.net> reports that the

     GNU/Linux ioctl(.., CDROM_DISC_STATUS) does not return "CD DATA

     Form 2" for SVCD's even though they are are form 2.  In

     mmc_get_discmode we issue a SCSI MMC-2 TOC command first to

     try get more accurate information. But we took care above *not*

     to issue a FULL TOC on DVD media.

  */

  discmode = mmc_get_discmode(p_env->gen.cdio);

  if (CDIO_DISC_MODE_NO_INFO != discmode)

    return discmode;

  else {

    int32_t i_discmode = ioctl (p_env->gen.fd, CDROM_DISC_STATUS);

    if (i_discmode < 0) return CDIO_DISC_MODE_ERROR;

    switch(i_discmode) {

    case CDS_AUDIO:

      return CDIO_DISC_MODE_CD_DA;

    case CDS_DATA_1:

    case CDS_DATA_2: /* Actually, recent GNU/Linux kernels don't return

                        CDS_DATA_2, but just in case. */

      return CDIO_DISC_MODE_CD_DATA;

    case CDS_MIXED:

      return CDIO_DISC_MODE_CD_MIXED;

    case CDS_XA_2_1:

    case CDS_XA_2_2:

      return CDIO_DISC_MODE_CD_XA;

    case CDS_NO_INFO:

      return CDIO_DISC_MODE_NO_INFO;

    default:

      return CDIO_DISC_MODE_ERROR;

    }

  }

}

/* 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 .