git.oblomov.eu Git - wine/blob - dlls/ntdll/cdrom.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2 /* Main file for CD-ROM support
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  * Copyright 1999, 2001, 2003 Eric Pouech
   6  * Copyright 2000 Andreas Mohr
   7  * Copyright 2005 Ivan Leo Puoti
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #ifdef HAVE_IO_H
  32 # include <io.h>
  33 #endif
  34 #ifdef HAVE_UNISTD_H
  35 # include <unistd.h>
  36 #endif
  37 #include <fcntl.h>
  38 #ifdef HAVE_SYS_STAT_H
  39 # include <sys/stat.h>
  40 #endif
  41 #include <sys/types.h>
  42
  43 #ifdef HAVE_SYS_IOCTL_H
  44 #include <sys/ioctl.h>
  45 #endif
  46 #ifdef HAVE_SCSI_SG_H
  47 # include <scsi/sg.h>
  48 #endif
  49 #ifdef HAVE_SCSI_SCSI_H
  50 # include <scsi/scsi.h>
  51 # undef REASSIGN_BLOCKS  /* avoid conflict with winioctl.h */
  52 # undef FAILED           /* avoid conflict with winerror.h */
  53 #endif
  54 #ifdef HAVE_SCSI_SCSI_IOCTL_H
  55 # include <scsi/scsi_ioctl.h>
  56 #endif
  57 #ifdef HAVE_LINUX_MAJOR_H
  58 # include <linux/major.h>
  59 #endif
  60 #ifdef HAVE_LINUX_HDREG_H
  61 # include <linux/hdreg.h>
  62 #endif
  63 #ifdef HAVE_LINUX_PARAM_H
  64 # include <linux/param.h>
  65 #endif
  66 #ifdef HAVE_LINUX_CDROM_H
  67 # include <linux/cdrom.h>
  68 #endif
  69 #ifdef HAVE_LINUX_UCDROM_H
  70 # include <linux/ucdrom.h>
  71 #endif
  72 #ifdef HAVE_SYS_CDIO_H
  73 # include <sys/cdio.h>
  74 #endif
  75 #ifdef HAVE_SYS_SCSIIO_H
  76 # include <sys/scsiio.h>
  77 #endif
  78
  79 #ifdef HAVE_IOKIT_IOKITLIB_H
  80 # include <libkern/OSByteOrder.h>
  81 # include <sys/disk.h>
  82 # include <IOKit/IOKitLib.h>
  83 # include <IOKit/storage/IOMedia.h>
  84 # include <IOKit/storage/IOCDMediaBSDClient.h>
  85 # include <IOKit/storage/IODVDMediaBSDClient.h>
  86 # include <IOKit/scsi/SCSITask.h>
  87 # include <IOKit/scsi/SCSICmds_REQUEST_SENSE_Defs.h>
  88 # define SENSEBUFLEN kSenseDefaultSize
  89
  90 typedef struct
  91 {
  92     uint32_t attribute;
  93     uint32_t timeout;
  94     uint32_t response;
  95     uint32_t status;
  96     uint8_t direction;
  97     uint8_t cdbSize;
  98     uint8_t reserved0144[2];
  99     uint8_t cdb[16];
 100     void* buffer;
 101     uint64_t bufferSize;
 102     void* sense;
 103     uint64_t senseLen;
 104 } dk_scsi_command_t;
 105
 106 typedef struct
 107 {
 108     uint64_t bus;
 109     uint64_t port;
 110     uint64_t target;
 111     uint64_t lun;
 112 } dk_scsi_identify_t;
 113
 114 #define DKIOCSCSICOMMAND _IOWR('d', 253, dk_scsi_command_t)
 115 #define DKIOCSCSIIDENTIFY _IOR('d', 254, dk_scsi_identify_t)
 116
 117 #endif
 118
 119 #define NONAMELESSUNION
 120 #define NONAMELESSSTRUCT
 121 #include "ntstatus.h"
 122 #define WIN32_NO_STATUS
 123 #include "windef.h"
 124 #include "winternl.h"
 125 #include "winioctl.h"
 126 #include "ntddstor.h"
 127 #include "ntddcdrm.h"
 128 #include "ddk/ntddcdvd.h"
 129 #include "ntddscsi.h"
 130 #include "ntdll_misc.h"
 131 #include "wine/server.h"
 132 #include "wine/library.h"
 133 #include "wine/debug.h"
 134
 135 WINE_DEFAULT_DEBUG_CHANNEL(cdrom);
 136
 137 /* Non-Linux systems do not have linux/cdrom.h and the like, and thus
 138    lack the following constants. */
 139
 140 #ifndef CD_SECS
 141 # define CD_SECS              60 /* seconds per minute */
 142 #endif
 143 #ifndef CD_FRAMES
 144 # define CD_FRAMES            75 /* frames per second */
 145 #endif
 146
 147 #ifdef WORDS_BIGENDIAN
 148 #define GET_BE_DWORD(x) (x)
 149 #else
 150 #define GET_BE_DWORD(x) RtlUlongByteSwap(x)
 151 #endif
 152
 153 static const struct iocodexs
 154 {
 155   DWORD code;
 156   const char *codex;
 157 } iocodextable[] = {
 158 #define X(x) { x, #x },
 159 X(IOCTL_CDROM_CHECK_VERIFY)
 160 X(IOCTL_CDROM_CURRENT_POSITION)
 161 X(IOCTL_CDROM_DISK_TYPE)
 162 X(IOCTL_CDROM_GET_CONTROL)
 163 X(IOCTL_CDROM_GET_DRIVE_GEOMETRY)
 164 X(IOCTL_CDROM_GET_VOLUME)
 165 X(IOCTL_CDROM_LOAD_MEDIA)
 166 X(IOCTL_CDROM_MEDIA_CATALOG)
 167 X(IOCTL_CDROM_MEDIA_REMOVAL)
 168 X(IOCTL_CDROM_PAUSE_AUDIO)
 169 X(IOCTL_CDROM_PLAY_AUDIO_MSF)
 170 X(IOCTL_CDROM_RAW_READ)
 171 X(IOCTL_CDROM_READ_Q_CHANNEL)
 172 X(IOCTL_CDROM_READ_TOC)
 173 X(IOCTL_CDROM_RESUME_AUDIO)
 174 X(IOCTL_CDROM_SEEK_AUDIO_MSF)
 175 X(IOCTL_CDROM_SET_VOLUME)
 176 X(IOCTL_CDROM_STOP_AUDIO)
 177 X(IOCTL_CDROM_TRACK_ISRC)
 178 X(IOCTL_DISK_GET_MEDIA_TYPES)
 179 X(IOCTL_DISK_MEDIA_REMOVAL)
 180 X(IOCTL_DVD_END_SESSION)
 181 X(IOCTL_DVD_GET_REGION)
 182 X(IOCTL_DVD_READ_KEY)
 183 X(IOCTL_DVD_READ_STRUCTURE)
 184 X(IOCTL_DVD_SEND_KEY)
 185 X(IOCTL_DVD_START_SESSION)
 186 X(IOCTL_SCSI_GET_ADDRESS)
 187 X(IOCTL_SCSI_GET_CAPABILITIES)
 188 X(IOCTL_SCSI_GET_INQUIRY_DATA)
 189 X(IOCTL_SCSI_PASS_THROUGH)
 190 X(IOCTL_SCSI_PASS_THROUGH_DIRECT)
 191 X(IOCTL_STORAGE_CHECK_VERIFY)
 192 X(IOCTL_STORAGE_CHECK_VERIFY2)
 193 X(IOCTL_STORAGE_EJECTION_CONTROL)
 194 X(IOCTL_STORAGE_EJECT_MEDIA)
 195 X(IOCTL_STORAGE_GET_DEVICE_NUMBER)
 196 X(IOCTL_STORAGE_GET_MEDIA_TYPES)
 197 X(IOCTL_STORAGE_GET_MEDIA_TYPES_EX)
 198 X(IOCTL_STORAGE_LOAD_MEDIA)
 199 X(IOCTL_STORAGE_MEDIA_REMOVAL)
 200 X(IOCTL_STORAGE_RESET_DEVICE)
 201 #undef X
 202 };
 203 static const char *iocodex(DWORD code)
 204 {
 205    unsigned int i;
 206    static char buffer[25];
 207    for(i=0; i<sizeof(iocodextable)/sizeof(struct iocodexs); i++)
 208       if (code==iocodextable[i].code)
 209          return iocodextable[i].codex;
 210    sprintf(buffer, "IOCTL_CODE_%x", (int)code);
 211    return buffer;
 212 }
 213
 214 #define INQ_REPLY_LEN 36
 215 #define INQ_CMD_LEN 6
 216
 217 #define FRAME_OF_ADDR(a) (((int)(a)[1] * CD_SECS + (a)[2]) * CD_FRAMES + (a)[3])
 218 #define FRAME_OF_MSF(a) (((int)(a).M * CD_SECS + (a).S) * CD_FRAMES + (a).F)
 219 #define FRAME_OF_TOC(toc, idx)  FRAME_OF_ADDR((toc).TrackData[idx - (toc).FirstTrack].Address)
 220 #define MSF_OF_FRAME(m,fr) {int f=(fr); ((UCHAR *)&(m))[2]=f%CD_FRAMES;f/=CD_FRAMES;((UCHAR *)&(m))[1]=f%CD_SECS;((UCHAR *)&(m))[0]=f/CD_SECS;}
 221
 222 /* The documented format of DVD_LAYER_DESCRIPTOR is wrong. Even the format in the
 223  * DDK's header is wrong. There are four bytes at the start  defined by
 224  * MMC-5. The first two are the size of the structure in big-endian order as
 225  * defined by MMC-5. The other two are reserved.
 226  */
 227 typedef struct
 228 {
 229     DVD_DESCRIPTOR_HEADER Header;
 230     DVD_LAYER_DESCRIPTOR Descriptor;
 231     UCHAR Padding;
 232 } internal_dvd_layer_descriptor;
 233 C_ASSERT(sizeof(internal_dvd_layer_descriptor) == 22);
 234
 235 typedef struct
 236 {
 237     DVD_DESCRIPTOR_HEADER Header;
 238     DVD_MANUFACTURER_DESCRIPTOR Descriptor;
 239     UCHAR Padding;
 240 } internal_dvd_manufacturer_descriptor;
 241 C_ASSERT(sizeof(internal_dvd_manufacturer_descriptor) == 2053);
 242
 243 static NTSTATUS CDROM_ReadTOC(int, int, CDROM_TOC*);
 244 static NTSTATUS CDROM_GetStatusCode(int);
 245
 246
 247 #ifdef linux
 248
 249 # ifndef IDE6_MAJOR
 250 #  define IDE6_MAJOR 88
 251 # endif
 252 # ifndef IDE7_MAJOR
 253 #  define IDE7_MAJOR 89
 254 # endif
 255
 256 # ifdef CDROM_SEND_PACKET
 257 /* structure for CDROM_PACKET_COMMAND ioctl */
 258 /* not all Linux versions have all the fields, so we define the
 259  * structure ourselves to make sure */
 260 struct linux_cdrom_generic_command
 261 {
 262     unsigned char          cmd[CDROM_PACKET_SIZE];
 263     unsigned char         *buffer;
 264     unsigned int           buflen;
 265     int                    stat;
 266     struct request_sense  *sense;
 267     unsigned char          data_direction;
 268     int                    quiet;
 269     int                    timeout;
 270     void                  *reserved[1];
 271 };
 272 # endif  /* CDROM_SEND_PACKET */
 273
 274 #endif  /* linux */
 275
 276 /* FIXME: this is needed because we can't open simultaneously several times /dev/cdrom
 277  * this should be removed when a proper device interface is implemented
 278  *
 279  * (WS) We need this to keep track of current position and to safely
 280  * detect media changes. Besides this should provide a great speed up
 281  * for toc inquiries.
 282  */
 283 struct cdrom_cache {
 284     dev_t       device;
 285     ino_t       inode;
 286     char        toc_good; /* if false, will reread TOC from disk */
 287     CDROM_TOC   toc;
 288     SUB_Q_CURRENT_POSITION CurrentPosition;
 289 };
 290 /* who has more than 5 cdroms on his/her machine ?? */
 291 /* FIXME: this should grow depending on the number of cdroms we install/configure
 292  * at startup
 293  */
 294 #define MAX_CACHE_ENTRIES       5
 295 static struct cdrom_cache cdrom_cache[MAX_CACHE_ENTRIES];
 296
 297 static RTL_CRITICAL_SECTION cache_section;
 298 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
 299 {
 300     0, 0, &cache_section,
 301     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 302       0, 0, { (DWORD_PTR)(__FILE__ ": cache_section") }
 303 };
 304 static RTL_CRITICAL_SECTION cache_section = { &critsect_debug, -1, 0, 0, 0, 0 };
 305
 306 /* Proposed media change function: not really needed at this time */
 307 /* This is a 1 or 0 type of function */
 308 #if 0
 309 static int CDROM_MediaChanged(int dev)
 310 {
 311    int i;
 312
 313    struct cdrom_tochdr  hdr;
 314    struct cdrom_tocentry entry;
 315
 316    if (dev < 0 || dev >= MAX_CACHE_ENTRIES)
 317       return 0;
 318    if ( ioctl(cdrom_cache[dev].fd, CDROMREADTOCHDR, &hdr) == -1 )
 319       return 0;
 320
 321    if ( memcmp(&hdr, &cdrom_cache[dev].hdr, sizeof(struct cdrom_tochdr)) )
 322       return 1;
 323
 324    for (i=hdr.cdth_trk0; i<=hdr.cdth_trk1+1; i++)
 325    {
 326       if (i == hdr.cdth_trk1 + 1)
 327       {
 328          entry.cdte_track = CDROM_LEADOUT;
 329       } else {
 330          entry.cdte_track = i;
 331       }
 332       entry.cdte_format = CDROM_MSF;
 333       if ( ioctl(cdrom_cache[dev].fd, CDROMREADTOCENTRY, &entry) == -1)
 334          return 0;
 335       if ( memcmp(&entry, cdrom_cache[dev].entry+i-hdr.cdth_trk0,
 336                               sizeof(struct cdrom_tocentry)) )
 337          return 1;
 338    }
 339    return 0;
 340 }
 341 #endif
 342
 343
 344 /******************************************************************
 345  *              get_parent_device
 346  *
 347  * On Mac OS, get the device for the whole disk from a fd that points to a partition.
 348  * This is ugly and inefficient, but we have no choice since the partition fd doesn't
 349  * support the eject ioctl.
 350  */
 351 #ifdef __APPLE__
 352 static NTSTATUS get_parent_device( int fd, char *name, size_t len )
 353 {
 354     NTSTATUS status = STATUS_NO_SUCH_FILE;
 355     struct stat st;
 356     int i;
 357     io_service_t service;
 358     CFMutableDictionaryRef dict;
 359     CFTypeRef val;
 360
 361     if (fstat( fd, &st ) == -1) return FILE_GetNtStatus();
 362     if (!S_ISCHR( st.st_mode )) return STATUS_OBJECT_TYPE_MISMATCH;
 363
 364     /* create a dictionary with the right major/minor numbers */
 365
 366     if (!(dict = IOServiceMatching( kIOMediaClass ))) return STATUS_NO_MEMORY;
 367
 368     i = major( st.st_rdev );
 369     val = CFNumberCreate( NULL, kCFNumberIntType, &i );
 370     CFDictionaryAddValue( dict, CFSTR( "BSD Major" ), val );
 371     CFRelease( val );
 372
 373     i = minor( st.st_rdev );
 374     val = CFNumberCreate( NULL, kCFNumberIntType, &i );
 375     CFDictionaryAddValue( dict, CFSTR( "BSD Minor" ), val );
 376     CFRelease( val );
 377
 378     CFDictionaryAddValue( dict, CFSTR("Removable"), kCFBooleanTrue );
 379
 380     service = IOServiceGetMatchingService( kIOMasterPortDefault, dict );
 381
 382     /* now look for the parent that has the "Whole" attribute set to TRUE */
 383
 384     while (service)
 385     {
 386         io_service_t parent = 0;
 387         CFBooleanRef whole;
 388         CFStringRef str;
 389         int ok;
 390
 391         if (!IOObjectConformsTo( service, kIOMediaClass ))
 392             goto next;
 393         if (!(whole = IORegistryEntryCreateCFProperty( service, CFSTR("Whole"), NULL, 0 )))
 394             goto next;
 395         ok = (whole == kCFBooleanTrue);
 396         CFRelease( whole );
 397         if (!ok) goto next;
 398
 399         if ((str = IORegistryEntryCreateCFProperty( service, CFSTR("BSD Name"), NULL, 0 )))
 400         {
 401             strcpy( name, "/dev/r" );
 402             CFStringGetCString( str, name + 6, len - 6, kCFStringEncodingUTF8 );
 403             CFRelease( str );
 404             status = STATUS_SUCCESS;
 405         }
 406         IOObjectRelease( service );
 407         break;
 408
 409 next:
 410         IORegistryEntryGetParentEntry( service, kIOServicePlane, &parent );
 411         IOObjectRelease( service );
 412         service = parent;
 413     }
 414     return status;
 415 }
 416 #endif
 417
 418
 419 /******************************************************************
 420  *              CDROM_SyncCache                          [internal]
 421  *
 422  * Read the TOC in and store it in the cdrom_cache structure.
 423  * Further requests for the TOC will be copied from the cache
 424  * unless certain events like disk ejection is detected, in which
 425  * case the cache will be cleared, causing it to be resynced.
 426  * The cache section must be held by caller.
 427  */
 428 static NTSTATUS CDROM_SyncCache(int dev, int fd)
 429 {
 430 #ifdef linux
 431    int i, tsz;
 432    struct cdrom_tochdr          hdr;
 433    struct cdrom_tocentry        entry;
 434
 435    CDROM_TOC *toc = &cdrom_cache[dev].toc;
 436    cdrom_cache[dev].toc_good = 0;
 437
 438    if (ioctl(fd, CDROMREADTOCHDR, &hdr) == -1)
 439    {
 440       WARN("(%d) -- Error occurred (%s)!\n", dev, strerror(errno));
 441       return FILE_GetNtStatus();
 442    }
 443
 444    toc->FirstTrack = hdr.cdth_trk0;
 445    toc->LastTrack  = hdr.cdth_trk1;
 446    tsz = sizeof(toc->FirstTrack) + sizeof(toc->LastTrack)
 447        + sizeof(TRACK_DATA) * (toc->LastTrack-toc->FirstTrack+2);
 448    toc->Length[0] = tsz >> 8;
 449    toc->Length[1] = tsz;
 450
 451    TRACE("caching toc from=%d to=%d\n", toc->FirstTrack, toc->LastTrack );
 452
 453    for (i = toc->FirstTrack; i <= toc->LastTrack + 1; i++)
 454    {
 455      if (i == toc->LastTrack + 1)
 456        entry.cdte_track = CDROM_LEADOUT;
 457      else
 458        entry.cdte_track = i;
 459      entry.cdte_format = CDROM_MSF;
 460      if (ioctl(fd, CDROMREADTOCENTRY, &entry) == -1)
 461      {
 462        WARN("error read entry (%s)\n", strerror(errno));
 463        return FILE_GetNtStatus();
 464      }
 465      toc->TrackData[i - toc->FirstTrack].Control = entry.cdte_ctrl;
 466      toc->TrackData[i - toc->FirstTrack].Adr = entry.cdte_adr;
 467      /* marking last track with leadout value as index */
 468      toc->TrackData[i - toc->FirstTrack].TrackNumber = entry.cdte_track;
 469      toc->TrackData[i - toc->FirstTrack].Address[0] = 0;
 470      toc->TrackData[i - toc->FirstTrack].Address[1] = entry.cdte_addr.msf.minute;
 471      toc->TrackData[i - toc->FirstTrack].Address[2] = entry.cdte_addr.msf.second;
 472      toc->TrackData[i - toc->FirstTrack].Address[3] = entry.cdte_addr.msf.frame;
 473    }
 474    cdrom_cache[dev].toc_good = 1;
 475    return STATUS_SUCCESS;
 476
 477 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
 478
 479    int i, tsz;
 480    struct ioc_toc_header hdr;
 481    struct ioc_read_toc_entry entry;
 482    struct cd_toc_entry toc_buffer;
 483
 484    CDROM_TOC *toc = &cdrom_cache[dev].toc;
 485    cdrom_cache[dev].toc_good = 0;
 486
 487     if (ioctl(fd, CDIOREADTOCHEADER, &hdr) == -1)
 488     {
 489         WARN("(%d) -- Error occurred (%s)!\n", dev, strerror(errno));
 490         return FILE_GetNtStatus();
 491     }
 492     toc->FirstTrack = hdr.starting_track;
 493     toc->LastTrack  = hdr.ending_track;
 494     tsz = sizeof(toc->FirstTrack) + sizeof(toc->LastTrack)
 495         + sizeof(TRACK_DATA) * (toc->LastTrack-toc->FirstTrack+2);
 496     toc->Length[0] = tsz >> 8;
 497     toc->Length[1] = tsz;
 498
 499     TRACE("caching toc from=%d to=%d\n", toc->FirstTrack, toc->LastTrack );
 500
 501     for (i = toc->FirstTrack; i <= toc->LastTrack + 1; i++)
 502     {
 503         if (i == toc->LastTrack + 1)
 504         {
 505 #define LEADOUT 0xaa
 506             entry.starting_track = LEADOUT;
 507         } else {
 508             entry.starting_track = i;
 509         }
 510         memset(&toc_buffer, 0, sizeof(toc_buffer));
 511         entry.address_format = CD_MSF_FORMAT;
 512         entry.data_len = sizeof(toc_buffer);
 513         entry.data = &toc_buffer;
 514         if (ioctl(fd, CDIOREADTOCENTRYS, &entry) == -1)
 515         {
 516             WARN("error read entry (%s)\n", strerror(errno));
 517             return FILE_GetNtStatus();
 518         }
 519         toc->TrackData[i - toc->FirstTrack].Control = toc_buffer.control;
 520         toc->TrackData[i - toc->FirstTrack].Adr = toc_buffer.addr_type;
 521         /* marking last track with leadout value as index */
 522         toc->TrackData[i - toc->FirstTrack].TrackNumber = entry.starting_track;
 523         toc->TrackData[i - toc->FirstTrack].Address[0] = 0;
 524         toc->TrackData[i - toc->FirstTrack].Address[1] = toc_buffer.addr.msf.minute;
 525         toc->TrackData[i - toc->FirstTrack].Address[2] = toc_buffer.addr.msf.second;
 526         toc->TrackData[i - toc->FirstTrack].Address[3] = toc_buffer.addr.msf.frame;
 527     }
 528     cdrom_cache[dev].toc_good = 1;
 529     return STATUS_SUCCESS;
 530
 531 #elif defined(__APPLE__)
 532     int i;
 533     dk_cd_read_toc_t hdr;
 534     CDROM_TOC *toc = &cdrom_cache[dev].toc;
 535     cdrom_cache[dev].toc_good = 0;
 536
 537     memset( &hdr, 0, sizeof(hdr) );
 538     hdr.buffer = toc;
 539     hdr.bufferLength = sizeof(*toc);
 540     if (ioctl(fd, DKIOCCDREADTOC, &hdr) == -1)
 541     {
 542         WARN("(%d) -- Error occurred (%s)!\n", dev, strerror(errno));
 543         return FILE_GetNtStatus();
 544     }
 545     for (i = toc->FirstTrack; i <= toc->LastTrack + 1; i++)
 546     {
 547         /* convert address format */
 548         TRACK_DATA *data = &toc->TrackData[i - toc->FirstTrack];
 549         DWORD frame = (((DWORD)data->Address[0] << 24) | ((DWORD)data->Address[1] << 16) |
 550                        ((DWORD)data->Address[2] << 8) | data->Address[3]);
 551         MSF_OF_FRAME( data->Address[1], frame );
 552         data->Address[0] = 0;
 553     }
 554
 555     cdrom_cache[dev].toc_good = 1;
 556     return STATUS_SUCCESS;
 557 #else
 558     FIXME("not supported on this O/S\n");
 559     return STATUS_NOT_SUPPORTED;
 560 #endif
 561 }
 562
 563 static void CDROM_ClearCacheEntry(int dev)
 564 {
 565     RtlEnterCriticalSection( &cache_section );
 566     cdrom_cache[dev].toc_good = 0;
 567     RtlLeaveCriticalSection( &cache_section );
 568 }
 569
 570
 571
 572 /******************************************************************
 573  *              CDROM_GetInterfaceInfo
 574  *
 575  * Determines the ide interface (the number after the ide), and the
 576  * number of the device on that interface for ide cdroms (*iface <= 1).
 577  * Determines the scsi information for scsi cdroms (*iface >= 2).
 578  * Returns false if the info cannot not be obtained.
 579  */
 580 static int CDROM_GetInterfaceInfo(int fd, UCHAR* iface, UCHAR* port, UCHAR* device, UCHAR* lun)
 581 {
 582 #if defined(linux)
 583     struct stat st;
 584     if ( fstat(fd, &st) == -1 || ! S_ISBLK(st.st_mode)) return 0;
 585     *port = 0;
 586     *iface = 0;
 587     *device = 0;
 588     *lun = 0;
 589     switch (major(st.st_rdev)) {
 590     case IDE0_MAJOR: *iface = 0; break;
 591     case IDE1_MAJOR: *iface = 1; break;
 592     case IDE2_MAJOR: *iface = 2; break;
 593     case IDE3_MAJOR: *iface = 3; break;
 594     case IDE4_MAJOR: *iface = 4; break;
 595     case IDE5_MAJOR: *iface = 5; break;
 596     case IDE6_MAJOR: *iface = 6; break;
 597     case IDE7_MAJOR: *iface = 7; break;
 598     default: *port = 1; break;
 599     }
 600
 601     if (*port == 0)
 602         *device = (minor(st.st_rdev) >> 6);
 603     else
 604     {
 605 #ifdef SCSI_IOCTL_GET_IDLUN
 606         UINT32 idlun[2];
 607         if (ioctl(fd, SCSI_IOCTL_GET_IDLUN, idlun) != -1)
 608         {
 609             *port = (idlun[0] >> 24) & 0xff;
 610             *iface = ((idlun[0] >> 16) & 0xff) + 2;
 611             *device = idlun[0] & 0xff;
 612             *lun = (idlun[0] >> 8) & 0xff;
 613         }
 614         else
 615 #endif
 616         {
 617             WARN("CD-ROM device (%d, %d) not supported\n", major(st.st_rdev), minor(st.st_rdev));
 618             return 0;
 619         }
 620     }
 621     return 1;
 622 #elif defined(__NetBSD__)
 623     struct scsi_addr addr;
 624     if (ioctl(fd, SCIOCIDENTIFY, &addr) != -1)
 625     {
 626         switch (addr.type)
 627         {
 628         case TYPE_SCSI:
 629             *port = 1;
 630             *iface = addr.addr.scsi.scbus;
 631             *device = addr.addr.scsi.target;
 632             *lun = addr.addr.scsi.lun;
 633             return 1;
 634         case TYPE_ATAPI:
 635             *port = 0;
 636             *iface = addr.addr.atapi.atbus;
 637             *device = addr.addr.atapi.drive;
 638             *lun = 0;
 639             return 1;
 640         }
 641     }
 642     return 0;
 643 #elif defined(__APPLE__)
 644     dk_scsi_identify_t addr;
 645     if (ioctl(fd, DKIOCSCSIIDENTIFY, &addr) != -1)
 646     {
 647        *port = addr.bus;
 648        *iface = addr.port;
 649        *device = addr.target;
 650        *lun = addr.lun;
 651        return 1;
 652     }
 653     return 0;
 654 #else
 655     FIXME("not implemented on this O/S\n");
 656     return 0;
 657 #endif
 658 }
 659
 660
 661 /******************************************************************
 662  *              CDROM_Open
 663  *
 664  */
 665 static NTSTATUS CDROM_Open(int fd, int* dev)
 666 {
 667     struct stat st;
 668     NTSTATUS ret = STATUS_SUCCESS;
 669     int         empty = -1;
 670
 671     fstat(fd, &st);
 672
 673     RtlEnterCriticalSection( &cache_section );
 674     for (*dev = 0; *dev < MAX_CACHE_ENTRIES; (*dev)++)
 675     {
 676         if (empty == -1 &&
 677             cdrom_cache[*dev].device == 0 &&
 678             cdrom_cache[*dev].inode == 0)
 679             empty = *dev;
 680         else if (cdrom_cache[*dev].device == st.st_dev &&
 681                  cdrom_cache[*dev].inode == st.st_ino)
 682             break;
 683     }
 684     if (*dev == MAX_CACHE_ENTRIES)
 685     {
 686         if (empty == -1) ret = STATUS_NOT_IMPLEMENTED;
 687         else
 688         {
 689             *dev = empty;
 690             cdrom_cache[*dev].device  = st.st_dev;
 691             cdrom_cache[*dev].inode   = st.st_ino;
 692         }
 693     }
 694     RtlLeaveCriticalSection( &cache_section );
 695
 696     TRACE("%d, %d\n", *dev, fd);
 697     return ret;
 698 }
 699
 700 /******************************************************************
 701  *              CDROM_GetStatusCode
 702  *
 703  *
 704  */
 705 static NTSTATUS CDROM_GetStatusCode(int io)
 706 {
 707     if (io == 0) return STATUS_SUCCESS;
 708     return FILE_GetNtStatus();
 709 }
 710
 711 /******************************************************************
 712  *              CDROM_GetControl
 713  *
 714  */
 715 static NTSTATUS CDROM_GetControl(int dev, int fd, CDROM_AUDIO_CONTROL* cac)
 716 {
 717 #ifdef __APPLE__
 718     uint16_t speed;
 719     int io = ioctl( fd, DKIOCCDGETSPEED, &speed );
 720     if (io != 0) return CDROM_GetStatusCode( io );
 721     /* DKIOCCDGETSPEED returns the speed in kilobytes per second,
 722      * so convert to logical blocks (assumed to be ~2 KB).
 723      */
 724     cac->LogicalBlocksPerSecond = speed/2;
 725 #else
 726     cac->LogicalBlocksPerSecond = 1; /* FIXME */
 727 #endif
 728     cac->LbaFormat = 0; /* FIXME */
 729     return  STATUS_NOT_SUPPORTED;
 730 }
 731
 732 /******************************************************************
 733  *              CDROM_GetDeviceNumber
 734  *
 735  */
 736 static NTSTATUS CDROM_GetDeviceNumber(int dev, STORAGE_DEVICE_NUMBER* devnum)
 737 {
 738     FIXME( "stub\n" );
 739     devnum->DeviceType = FILE_DEVICE_DISK;
 740     devnum->DeviceNumber = 1;
 741     devnum->PartitionNumber = 1;
 742     return STATUS_SUCCESS;
 743 }
 744
 745 /******************************************************************
 746  *              CDROM_GetDriveGeometry
 747  *
 748  */
 749 static NTSTATUS CDROM_GetDriveGeometry(int dev, int fd, DISK_GEOMETRY* dg)
 750 {
 751   CDROM_TOC     toc;
 752   NTSTATUS      ret = 0;
 753   int           fsize = 0;
 754
 755   if ((ret = CDROM_ReadTOC(dev, fd, &toc)) != 0) return ret;
 756
 757   fsize = FRAME_OF_TOC(toc, toc.LastTrack+1)
 758         - FRAME_OF_TOC(toc, 1); /* Total size in frames */
 759
 760   dg->Cylinders.u.LowPart = fsize / (64 * 32);
 761   dg->Cylinders.u.HighPart = 0;
 762   dg->MediaType = RemovableMedia;
 763   dg->TracksPerCylinder = 64;
 764   dg->SectorsPerTrack = 32;
 765   dg->BytesPerSector= 2048;
 766   return ret;
 767 }
 768
 769 /******************************************************************
 770  *              CDROM_GetMediaType
 771  *
 772  */
 773 static NTSTATUS CDROM_GetMediaType(int dev, GET_MEDIA_TYPES* medtype)
 774 {
 775     FIXME(": faking success\n");
 776     medtype->DeviceType = FILE_DEVICE_CD_ROM;
 777     medtype->MediaInfoCount = 0;
 778     return STATUS_SUCCESS;
 779 }
 780
 781 /**************************************************************************
 782  *                              CDROM_Reset                     [internal]
 783  */
 784 static NTSTATUS CDROM_ResetAudio(int fd)
 785 {
 786 #if defined(linux)
 787     return CDROM_GetStatusCode(ioctl(fd, CDROMRESET));
 788 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
 789     return CDROM_GetStatusCode(ioctl(fd, CDIOCRESET, NULL));
 790 #else
 791     FIXME("not supported on this O/S\n");
 792     return STATUS_NOT_SUPPORTED;
 793 #endif
 794 }
 795
 796 /******************************************************************
 797  *              CDROM_SetTray
 798  *
 799  *
 800  */
 801 static NTSTATUS CDROM_SetTray(int fd, BOOL doEject)
 802 {
 803 #if defined(linux)
 804     return CDROM_GetStatusCode(ioctl(fd, doEject ? CDROMEJECT : CDROMCLOSETRAY));
 805 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
 806     return CDROM_GetStatusCode((ioctl(fd, CDIOCALLOW, NULL)) ||
 807                                (ioctl(fd, doEject ? CDIOCEJECT : CDIOCCLOSE, NULL)) ||
 808                                (ioctl(fd, CDIOCPREVENT, NULL)));
 809 #elif defined(__APPLE__)
 810     if (doEject) return CDROM_GetStatusCode( ioctl( fd, DKIOCEJECT, NULL ) );
 811     else return STATUS_NOT_SUPPORTED;
 812 #else
 813     FIXME("not supported on this O/S\n");
 814     return STATUS_NOT_SUPPORTED;
 815 #endif
 816 }
 817
 818 /******************************************************************
 819  *              CDROM_ControlEjection
 820  *
 821  *
 822  */
 823 static NTSTATUS CDROM_ControlEjection(int fd, const PREVENT_MEDIA_REMOVAL* rmv)
 824 {
 825 #if defined(linux)
 826     return CDROM_GetStatusCode(ioctl(fd, CDROM_LOCKDOOR, rmv->PreventMediaRemoval));
 827 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
 828     return CDROM_GetStatusCode(ioctl(fd, (rmv->PreventMediaRemoval) ? CDIOCPREVENT : CDIOCALLOW, NULL));
 829 #else
 830     FIXME("not supported on this O/S\n");
 831     return STATUS_NOT_SUPPORTED;
 832 #endif
 833 }
 834
 835 /******************************************************************
 836  *              CDROM_ReadTOC
 837  *
 838  *
 839  */
 840 static NTSTATUS CDROM_ReadTOC(int dev, int fd, CDROM_TOC* toc)
 841 {
 842     NTSTATUS       ret = STATUS_NOT_SUPPORTED;
 843
 844     if (dev < 0 || dev >= MAX_CACHE_ENTRIES)
 845         return STATUS_INVALID_PARAMETER;
 846
 847     RtlEnterCriticalSection( &cache_section );
 848     if (cdrom_cache[dev].toc_good || !(ret = CDROM_SyncCache(dev, fd)))
 849     {
 850         *toc = cdrom_cache[dev].toc;
 851         ret = STATUS_SUCCESS;
 852     }
 853     RtlLeaveCriticalSection( &cache_section );
 854     return ret;
 855 }
 856
 857 /******************************************************************
 858  *              CDROM_GetDiskData
 859  *
 860  *
 861  */
 862 static NTSTATUS CDROM_GetDiskData(int dev, int fd, CDROM_DISK_DATA* data)
 863 {
 864     CDROM_TOC   toc;
 865     NTSTATUS    ret;
 866     int         i;
 867
 868     if ((ret = CDROM_ReadTOC(dev, fd, &toc)) != 0) return ret;
 869     data->DiskData = 0;
 870     for (i = toc.FirstTrack; i <= toc.LastTrack; i++) {
 871         if (toc.TrackData[i-toc.FirstTrack].Control & 0x04)
 872             data->DiskData |= CDROM_DISK_DATA_TRACK;
 873         else
 874             data->DiskData |= CDROM_DISK_AUDIO_TRACK;
 875     }
 876     return STATUS_SUCCESS;
 877 }
 878
 879 /******************************************************************
 880  *              CDROM_ReadQChannel
 881  *
 882  *
 883  */
 884 static NTSTATUS CDROM_ReadQChannel(int dev, int fd, const CDROM_SUB_Q_DATA_FORMAT* fmt,
 885                                    SUB_Q_CHANNEL_DATA* data)
 886 {
 887     NTSTATUS            ret = STATUS_NOT_SUPPORTED;
 888 #ifdef linux
 889     SUB_Q_HEADER*       hdr = (SUB_Q_HEADER*)data;
 890     int                 io;
 891     struct cdrom_subchnl        sc;
 892     sc.cdsc_format = CDROM_MSF;
 893
 894     io = ioctl(fd, CDROMSUBCHNL, &sc);
 895     if (io == -1)
 896     {
 897         TRACE("opened or no_media (%s)!\n", strerror(errno));
 898         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 899         CDROM_ClearCacheEntry(dev);
 900         goto end;
 901     }
 902
 903     hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
 904
 905     switch (sc.cdsc_audiostatus) {
 906     case CDROM_AUDIO_INVALID:
 907         CDROM_ClearCacheEntry(dev);
 908         hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
 909         break;
 910     case CDROM_AUDIO_NO_STATUS:
 911         CDROM_ClearCacheEntry(dev);
 912         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 913         break;
 914     case CDROM_AUDIO_PLAY:
 915         hdr->AudioStatus = AUDIO_STATUS_IN_PROGRESS;
 916         break;
 917     case CDROM_AUDIO_PAUSED:
 918         hdr->AudioStatus = AUDIO_STATUS_PAUSED;
 919         break;
 920     case CDROM_AUDIO_COMPLETED:
 921         hdr->AudioStatus = AUDIO_STATUS_PLAY_COMPLETE;
 922         break;
 923     case CDROM_AUDIO_ERROR:
 924         hdr->AudioStatus = AUDIO_STATUS_PLAY_ERROR;
 925         break;
 926     default:
 927         TRACE("status=%02X !\n", sc.cdsc_audiostatus);
 928         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
 929     }
 930     switch (fmt->Format)
 931     {
 932     case IOCTL_CDROM_CURRENT_POSITION:
 933         RtlEnterCriticalSection( &cache_section );
 934         if (hdr->AudioStatus==AUDIO_STATUS_IN_PROGRESS) {
 935           data->CurrentPosition.FormatCode = IOCTL_CDROM_CURRENT_POSITION;
 936           data->CurrentPosition.Control = sc.cdsc_ctrl;
 937           data->CurrentPosition.ADR = sc.cdsc_adr;
 938           data->CurrentPosition.TrackNumber = sc.cdsc_trk;
 939           data->CurrentPosition.IndexNumber = sc.cdsc_ind;
 940
 941           data->CurrentPosition.AbsoluteAddress[0] = 0;
 942           data->CurrentPosition.AbsoluteAddress[1] = sc.cdsc_absaddr.msf.minute;
 943           data->CurrentPosition.AbsoluteAddress[2] = sc.cdsc_absaddr.msf.second;
 944           data->CurrentPosition.AbsoluteAddress[3] = sc.cdsc_absaddr.msf.frame;
 945
 946           data->CurrentPosition.TrackRelativeAddress[0] = 0;
 947           data->CurrentPosition.TrackRelativeAddress[1] = sc.cdsc_reladdr.msf.minute;
 948           data->CurrentPosition.TrackRelativeAddress[2] = sc.cdsc_reladdr.msf.second;
 949           data->CurrentPosition.TrackRelativeAddress[3] = sc.cdsc_reladdr.msf.frame;
 950
 951           cdrom_cache[dev].CurrentPosition = data->CurrentPosition;
 952         }
 953         else /* not playing */
 954         {
 955           cdrom_cache[dev].CurrentPosition.Header = *hdr; /* Preserve header info */
 956           data->CurrentPosition = cdrom_cache[dev].CurrentPosition;
 957         }
 958         RtlLeaveCriticalSection( &cache_section );
 959         break;
 960     case IOCTL_CDROM_MEDIA_CATALOG:
 961         data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
 962         {
 963             struct cdrom_mcn mcn;
 964             if ((io = ioctl(fd, CDROM_GET_MCN, &mcn)) == -1) goto end;
 965
 966             data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
 967             data->MediaCatalog.Mcval = 0; /* FIXME */
 968             memcpy(data->MediaCatalog.MediaCatalog, mcn.medium_catalog_number, 14);
 969             data->MediaCatalog.MediaCatalog[14] = 0;
 970         }
 971         break;
 972     case IOCTL_CDROM_TRACK_ISRC:
 973         FIXME("TrackIsrc: NIY on linux\n");
 974         data->TrackIsrc.FormatCode = IOCTL_CDROM_TRACK_ISRC;
 975         data->TrackIsrc.Tcval = 0;
 976         io = 0;
 977         break;
 978     }
 979
 980  end:
 981     ret = CDROM_GetStatusCode(io);
 982 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
 983     SUB_Q_HEADER*       hdr = (SUB_Q_HEADER*)data;
 984     int                 io;
 985     struct ioc_read_subchannel  read_sc;
 986     struct cd_sub_channel_info  sc;
 987
 988     read_sc.address_format = CD_MSF_FORMAT;
 989     read_sc.track          = 0;
 990     read_sc.data_len       = sizeof(sc);
 991     read_sc.data           = &sc;
 992     switch (fmt->Format)
 993     {
 994     case IOCTL_CDROM_CURRENT_POSITION:
 995         read_sc.data_format    = CD_CURRENT_POSITION;
 996         break;
 997     case IOCTL_CDROM_MEDIA_CATALOG:
 998         read_sc.data_format    = CD_MEDIA_CATALOG;
 999         break;
1000     case IOCTL_CDROM_TRACK_ISRC:
1001         read_sc.data_format    = CD_TRACK_INFO;
1002         sc.what.track_info.track_number = data->TrackIsrc.Track;
1003         break;
1004     }
1005     io = ioctl(fd, CDIOCREADSUBCHANNEL, &read_sc);
1006     if (io == -1)
1007     {
1008         TRACE("opened or no_media (%s)!\n", strerror(errno));
1009         CDROM_ClearCacheEntry(dev);
1010         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
1011         goto end;
1012     }
1013
1014     hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
1015
1016     switch (sc.header.audio_status) {
1017     case CD_AS_AUDIO_INVALID:
1018         CDROM_ClearCacheEntry(dev);
1019         hdr->AudioStatus = AUDIO_STATUS_NOT_SUPPORTED;
1020         break;
1021     case CD_AS_NO_STATUS:
1022         CDROM_ClearCacheEntry(dev);
1023         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
1024         break;
1025     case CD_AS_PLAY_IN_PROGRESS:
1026         hdr->AudioStatus = AUDIO_STATUS_IN_PROGRESS;
1027         break;
1028     case CD_AS_PLAY_PAUSED:
1029         hdr->AudioStatus = AUDIO_STATUS_PAUSED;
1030         break;
1031     case CD_AS_PLAY_COMPLETED:
1032         hdr->AudioStatus = AUDIO_STATUS_PLAY_COMPLETE;
1033         break;
1034     case CD_AS_PLAY_ERROR:
1035         hdr->AudioStatus = AUDIO_STATUS_PLAY_ERROR;
1036         break;
1037     default:
1038         TRACE("status=%02X !\n", sc.header.audio_status);
1039         hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
1040     }
1041     switch (fmt->Format)
1042     {
1043     case IOCTL_CDROM_CURRENT_POSITION:
1044         RtlEnterCriticalSection( &cache_section );
1045         if (hdr->AudioStatus==AUDIO_STATUS_IN_PROGRESS) {
1046           data->CurrentPosition.FormatCode = IOCTL_CDROM_CURRENT_POSITION;
1047           data->CurrentPosition.Control = sc.what.position.control;
1048           data->CurrentPosition.ADR = sc.what.position.addr_type;
1049           data->CurrentPosition.TrackNumber = sc.what.position.track_number;
1050           data->CurrentPosition.IndexNumber = sc.what.position.index_number;
1051
1052           data->CurrentPosition.AbsoluteAddress[0] = 0;
1053           data->CurrentPosition.AbsoluteAddress[1] = sc.what.position.absaddr.msf.minute;
1054           data->CurrentPosition.AbsoluteAddress[2] = sc.what.position.absaddr.msf.second;
1055           data->CurrentPosition.AbsoluteAddress[3] = sc.what.position.absaddr.msf.frame;
1056           data->CurrentPosition.TrackRelativeAddress[0] = 0;
1057           data->CurrentPosition.TrackRelativeAddress[1] = sc.what.position.reladdr.msf.minute;
1058           data->CurrentPosition.TrackRelativeAddress[2] = sc.what.position.reladdr.msf.second;
1059           data->CurrentPosition.TrackRelativeAddress[3] = sc.what.position.reladdr.msf.frame;
1060           cdrom_cache[dev].CurrentPosition = data->CurrentPosition;
1061         }
1062         else { /* not playing */
1063           cdrom_cache[dev].CurrentPosition.Header = *hdr; /* Preserve header info */
1064           data->CurrentPosition = cdrom_cache[dev].CurrentPosition;
1065         }
1066         RtlLeaveCriticalSection( &cache_section );
1067         break;
1068     case IOCTL_CDROM_MEDIA_CATALOG:
1069         data->MediaCatalog.FormatCode = IOCTL_CDROM_MEDIA_CATALOG;
1070         data->MediaCatalog.Mcval = sc.what.media_catalog.mc_valid;
1071         memcpy(data->MediaCatalog.MediaCatalog, sc.what.media_catalog.mc_number, 15);
1072         break;
1073     case IOCTL_CDROM_TRACK_ISRC:
1074         data->TrackIsrc.FormatCode = IOCTL_CDROM_TRACK_ISRC;
1075         data->TrackIsrc.Tcval = sc.what.track_info.ti_valid;
1076         memcpy(data->TrackIsrc.TrackIsrc, sc.what.track_info.ti_number, 15);
1077         break;
1078     }
1079
1080  end:
1081     ret = CDROM_GetStatusCode(io);
1082 #elif defined(__APPLE__)
1083     SUB_Q_HEADER* hdr = (SUB_Q_HEADER*)data;
1084     int io = 0;
1085     union
1086     {
1087         dk_cd_read_mcn_t mcn;
1088         dk_cd_read_isrc_t isrc;
1089     } ioc;
1090     /* We need IOCDAudioControl for IOCTL_CDROM_CURRENT_POSITION */
1091     if (fmt->Format == IOCTL_CDROM_CURRENT_POSITION)
1092     {
1093         FIXME("NIY\n");
1094         return STATUS_NOT_SUPPORTED;
1095     }
1096     /* No IOCDAudioControl support; just set the audio status to none */
1097     hdr->AudioStatus = AUDIO_STATUS_NO_STATUS;
1098     switch(fmt->Format)
1099     {
1100     case IOCTL_CDROM_MEDIA_CATALOG:
1101         if ((io = ioctl(fd, DKIOCCDREADMCN, &ioc.mcn)) == -1) break;
1102         memcpy(data->MediaCatalog.MediaCatalog, ioc.mcn.mcn, kCDMCNMaxLength);
1103         data->MediaCatalog.Mcval = 1;
1104         break;
1105     case IOCTL_CDROM_TRACK_ISRC:
1106         ioc.isrc.track = fmt->Track;
1107         if ((io = ioctl(fd, DKIOCCDREADISRC, &ioc.isrc)) == -1) break;
1108         memcpy(data->TrackIsrc.TrackIsrc, ioc.isrc.isrc, kCDISRCMaxLength);
1109         data->TrackIsrc.Tcval = 1;
1110         data->TrackIsrc.Track = ioc.isrc.track;
1111     }
1112     ret = CDROM_GetStatusCode(io);
1113 #endif
1114     return ret;
1115 }
1116
1117 /******************************************************************
1118  *              CDROM_Verify
1119  *  Implements: IOCTL_STORAGE_CHECK_VERIFY
1120  *              IOCTL_CDROM_CHECK_VERIFY
1121  *              IOCTL_DISK_CHECK_VERIFY
1122  *
1123  */
1124 static NTSTATUS CDROM_Verify(int dev, int fd)
1125 {
1126 #if defined(linux)
1127     int ret;
1128
1129     ret = ioctl(fd,  CDROM_DRIVE_STATUS, NULL);
1130     if(ret == -1) {
1131         TRACE("ioctl CDROM_DRIVE_STATUS failed(%s)!\n", strerror(errno));
1132         return CDROM_GetStatusCode(ret);
1133     }
1134
1135     if(ret == CDS_DISC_OK)
1136         return STATUS_SUCCESS;
1137     else
1138         return STATUS_NO_MEDIA_IN_DEVICE;
1139 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
1140     int ret;
1141     ret = ioctl(fd, CDIOCSTART, NULL);
1142     if(ret == 0)
1143         return STATUS_SUCCESS;
1144     else
1145         return STATUS_NO_MEDIA_IN_DEVICE;
1146 #elif defined(__APPLE__)
1147         /* At this point, we know that we have media, because in Mac OS X, the
1148          * device file is only created when media is present. */
1149         return STATUS_SUCCESS;
1150 #else
1151     FIXME("not supported on this O/S\n");
1152     return STATUS_NOT_SUPPORTED;
1153 #endif
1154 }
1155
1156 /******************************************************************
1157  *              CDROM_PlayAudioMSF
1158  *
1159  *
1160  */
1161 static NTSTATUS CDROM_PlayAudioMSF(int fd, const CDROM_PLAY_AUDIO_MSF* audio_msf)
1162 {
1163     NTSTATUS       ret = STATUS_NOT_SUPPORTED;
1164 #ifdef linux
1165     struct      cdrom_msf       msf;
1166     int         io;
1167
1168     msf.cdmsf_min0   = audio_msf->StartingM;
1169     msf.cdmsf_sec0   = audio_msf->StartingS;
1170     msf.cdmsf_frame0 = audio_msf->StartingF;
1171     msf.cdmsf_min1   = audio_msf->EndingM;
1172     msf.cdmsf_sec1   = audio_msf->EndingS;
1173     msf.cdmsf_frame1 = audio_msf->EndingF;
1174
1175     io = ioctl(fd, CDROMSTART);
1176     if (io == -1)
1177     {
1178         WARN("motor doesn't start !\n");
1179         goto end;
1180     }
1181     io = ioctl(fd, CDROMPLAYMSF, &msf);
1182     if (io == -1)
1183     {
1184         WARN("device doesn't play !\n");
1185         goto end;
1186     }
1187     TRACE("msf = %d:%d:%d %d:%d:%d\n",
1188           msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0,
1189           msf.cdmsf_min1, msf.cdmsf_sec1, msf.cdmsf_frame1);
1190  end:
1191     ret = CDROM_GetStatusCode(io);
1192 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
1193     struct      ioc_play_msf    msf;
1194     int         io;
1195
1196     msf.start_m      = audio_msf->StartingM;
1197     msf.start_s      = audio_msf->StartingS;
1198     msf.start_f      = audio_msf->StartingF;
1199     msf.end_m        = audio_msf->EndingM;
1200     msf.end_s        = audio_msf->EndingS;
1201     msf.end_f        = audio_msf->EndingF;
1202
1203     io = ioctl(fd, CDIOCSTART, NULL);
1204     if (io == -1)
1205     {
1206         WARN("motor doesn't start !\n");
1207         goto end;
1208     }
1209     io = ioctl(fd, CDIOCPLAYMSF, &msf);
1210     if (io == -1)
1211     {
1212         WARN("device doesn't play !\n");
1213         goto end;
1214     }
1215     TRACE("msf = %d:%d:%d %d:%d:%d\n",
1216           msf.start_m, msf.start_s, msf.start_f,
1217           msf.end_m,   msf.end_s,   msf.end_f);
1218 end:
1219     ret = CDROM_GetStatusCode(io);
1220 #endif
1221     return ret;
1222 }
1223
1224 /******************************************************************
1225  *              CDROM_SeekAudioMSF
1226  *
1227  *
1228  */
1229 static NTSTATUS CDROM_SeekAudioMSF(int dev, int fd, const CDROM_SEEK_AUDIO_MSF* audio_msf)
1230 {
1231     CDROM_TOC toc;
1232     int i, io, frame;
1233     SUB_Q_CURRENT_POSITION *cp;
1234 #if defined(linux)
1235     struct cdrom_msf0   msf;
1236     struct cdrom_subchnl sc;
1237 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
1238     struct ioc_play_msf msf;
1239     struct ioc_read_subchannel  read_sc;
1240     struct cd_sub_channel_info  sc;
1241     int final_frame;
1242 #endif
1243
1244     /* Use the information on the TOC to compute the new current
1245      * position, which is shadowed on the cache. [Portable]. */
1246     frame = FRAME_OF_MSF(*audio_msf);
1247
1248     if ((io = CDROM_ReadTOC(dev, fd, &toc)) != 0) return io;
1249
1250     for(i=toc.FirstTrack;i<=toc.LastTrack+1;i++)
1251       if (FRAME_OF_TOC(toc,i)>frame) break;
1252     if (i <= toc.FirstTrack || i > toc.LastTrack+1)
1253       return STATUS_INVALID_PARAMETER;
1254     i--;
1255     RtlEnterCriticalSection( &cache_section );
1256     cp = &cdrom_cache[dev].CurrentPosition;
1257     cp->FormatCode = IOCTL_CDROM_CURRENT_POSITION;
1258     cp->Control = toc.TrackData[i-toc.FirstTrack].Control;
1259     cp->ADR = toc.TrackData[i-toc.FirstTrack].Adr;
1260     cp->TrackNumber = toc.TrackData[i-toc.FirstTrack].TrackNumber;
1261     cp->IndexNumber = 0; /* FIXME: where do they keep these? */
1262     cp->AbsoluteAddress[0] = 0;
1263     cp->AbsoluteAddress[1] = toc.TrackData[i-toc.FirstTrack].Address[1];
1264     cp->AbsoluteAddress[2] = toc.TrackData[i-toc.FirstTrack].Address[2];
1265     cp->AbsoluteAddress[3] = toc.TrackData[i-toc.FirstTrack].Address[3];
1266     frame -= FRAME_OF_TOC(toc,i);
1267     cp->TrackRelativeAddress[0] = 0;
1268     MSF_OF_FRAME(cp->TrackRelativeAddress[1], frame);
1269     RtlLeaveCriticalSection( &cache_section );
1270
1271     /* If playing, then issue a seek command, otherwise do nothing */
1272 #ifdef linux
1273     sc.cdsc_format = CDROM_MSF;
1274
1275     io = ioctl(fd, CDROMSUBCHNL, &sc);
1276     if (io == -1)
1277     {
1278         TRACE("opened or no_media (%s)!\n", strerror(errno));
1279         CDROM_ClearCacheEntry(dev);
1280         return CDROM_GetStatusCode(io);
1281     }
1282     if (sc.cdsc_audiostatus==CDROM_AUDIO_PLAY)
1283     {
1284       msf.minute = audio_msf->M;
1285       msf.second = audio_msf->S;
1286       msf.frame  = audio_msf->F;
1287       return CDROM_GetStatusCode(ioctl(fd, CDROMSEEK, &msf));
1288     }
1289     return STATUS_SUCCESS;
1290 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
1291     read_sc.address_format = CD_MSF_FORMAT;
1292     read_sc.track          = 0;
1293     read_sc.data_len       = sizeof(sc);
1294     read_sc.data           = &sc;
1295     read_sc.data_format    = CD_CURRENT_POSITION;
1296
1297     io = ioctl(fd, CDIOCREADSUBCHANNEL, &read_sc);
1298     if (io == -1)
1299     {
1300         TRACE("opened or no_media (%s)!\n", strerror(errno));
1301         CDROM_ClearCacheEntry(dev);
1302         return CDROM_GetStatusCode(io);
1303     }
1304     if (sc.header.audio_status==CD_AS_PLAY_IN_PROGRESS)
1305     {
1306
1307       msf.start_m      = audio_msf->M;
1308       msf.start_s      = audio_msf->S;
1309       msf.start_f      = audio_msf->F;
1310       final_frame = FRAME_OF_TOC(toc,toc.LastTrack+1)-1;
1311       MSF_OF_FRAME(msf.end_m, final_frame);
1312
1313       return CDROM_GetStatusCode(ioctl(fd, CDIOCPLAYMSF, &msf));
1314     }
1315     return STATUS_SUCCESS;
1316 #else
1317     FIXME("not supported on this O/S\n");
1318     return STATUS_NOT_SUPPORTED;
1319 #endif
1320 }
1321
1322 /******************************************************************
1323  *              CDROM_PauseAudio
1324  *
1325  *
1326  */
1327 static NTSTATUS CDROM_PauseAudio(int fd)
1328 {
1329 #if defined(linux)
1330     return CDROM_GetStatusCode(ioctl(fd, CDROMPAUSE));
1331 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
1332     return CDROM_GetStatusCode(ioctl(fd, CDIOCPAUSE, NULL));
1333 #else
1334     FIXME(": not supported on this O/S\n");
1335     return STATUS_NOT_SUPPORTED;
1336 #endif
1337 }
1338
1339 /******************************************************************
1340  *              CDROM_ResumeAudio
1341  *
1342  *
1343  */
1344 static NTSTATUS CDROM_ResumeAudio(int fd)
1345 {
1346 #if defined(linux)
1347     return CDROM_GetStatusCode(ioctl(fd, CDROMRESUME));
1348 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
1349     return CDROM_GetStatusCode(ioctl(fd, CDIOCRESUME, NULL));
1350 #else
1351     FIXME("not supported on this O/S\n");
1352     return STATUS_NOT_SUPPORTED;
1353 #endif
1354 }
1355
1356 /******************************************************************
1357  *              CDROM_StopAudio
1358  *
1359  *
1360  */
1361 static NTSTATUS CDROM_StopAudio(int fd)
1362 {
1363 #if defined(linux)
1364     return CDROM_GetStatusCode(ioctl(fd, CDROMSTOP));
1365 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
1366     return CDROM_GetStatusCode(ioctl(fd, CDIOCSTOP, NULL));
1367 #else
1368     FIXME("not supported on this O/S\n");
1369     return STATUS_NOT_SUPPORTED;
1370 #endif
1371 }
1372
1373 /******************************************************************
1374  *              CDROM_GetVolume
1375  *
1376  *
1377  */
1378 static NTSTATUS CDROM_GetVolume(int fd, VOLUME_CONTROL* vc)
1379 {
1380 #if defined(linux)
1381     struct cdrom_volctrl volc;
1382     int io;
1383
1384     io = ioctl(fd, CDROMVOLREAD, &volc);
1385     if (io != -1)
1386     {
1387         vc->PortVolume[0] = volc.channel0;
1388         vc->PortVolume[1] = volc.channel1;
1389         vc->PortVolume[2] = volc.channel2;
1390         vc->PortVolume[3] = volc.channel3;
1391     }
1392     return CDROM_GetStatusCode(io);
1393 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
1394     struct  ioc_vol     volc;
1395     int io;
1396
1397     io = ioctl(fd, CDIOCGETVOL, &volc);
1398     if (io != -1)
1399     {
1400         vc->PortVolume[0] = volc.vol[0];
1401         vc->PortVolume[1] = volc.vol[1];
1402         vc->PortVolume[2] = volc.vol[2];
1403         vc->PortVolume[3] = volc.vol[3];
1404     }
1405     return CDROM_GetStatusCode(io);
1406 #else
1407     FIXME("not supported on this O/S\n");
1408     return STATUS_NOT_SUPPORTED;
1409 #endif
1410 }
1411
1412 /******************************************************************
1413  *              CDROM_SetVolume
1414  *
1415  *
1416  */
1417 static NTSTATUS CDROM_SetVolume(int fd, const VOLUME_CONTROL* vc)
1418 {
1419 #if defined(linux)
1420     struct cdrom_volctrl volc;
1421
1422     volc.channel0 = vc->PortVolume[0];
1423     volc.channel1 = vc->PortVolume[1];
1424     volc.channel2 = vc->PortVolume[2];
1425     volc.channel3 = vc->PortVolume[3];
1426
1427     return CDROM_GetStatusCode(ioctl(fd, CDROMVOLCTRL, &volc));
1428 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__DragonFly__)
1429     struct  ioc_vol     volc;
1430
1431     volc.vol[0] = vc->PortVolume[0];
1432     volc.vol[1] = vc->PortVolume[1];
1433     volc.vol[2] = vc->PortVolume[2];
1434     volc.vol[3] = vc->PortVolume[3];
1435
1436     return CDROM_GetStatusCode(ioctl(fd, CDIOCSETVOL, &volc));
1437 #else
1438     FIXME(": not supported on this O/S\n");
1439     return STATUS_NOT_SUPPORTED;
1440 #endif
1441 }
1442
1443 /******************************************************************
1444  *              CDROM_RawRead
1445  *
1446  * Some features of this IOCTL are rather poorly documented and
1447  * not really intuitive either:
1448  *
1449  *   1. Although the DiskOffset parameter is meant to be a
1450  *      byte offset into the disk, it is in fact the sector
1451  *      number multiplied by 2048 regardless of the actual
1452  *      sector size.
1453  *
1454  *   2. The least significant 11 bits of DiskOffset are ignored.
1455  *
1456  *   3. The TrackMode parameter has no effect on the sector
1457  *      size. The entire raw sector (i.e. 2352 bytes of data)
1458  *      is always returned. IMO the TrackMode is only used
1459  *      to check the correct sector type.
1460  *
1461  */
1462 static NTSTATUS CDROM_RawRead(int fd, const RAW_READ_INFO* raw, void* buffer, DWORD len, DWORD* sz)
1463 {
1464     int         ret = STATUS_NOT_SUPPORTED;
1465     int         io = -1;
1466 #ifdef __APPLE__
1467     dk_cd_read_t cdrd;
1468 #endif
1469
1470     TRACE("RAW_READ_INFO: DiskOffset=%i,%i SectorCount=%i TrackMode=%i\n buffer=%p len=%i sz=%p\n",
1471           raw->DiskOffset.u.HighPart, raw->DiskOffset.u.LowPart, raw->SectorCount, raw->TrackMode, buffer, len, sz);
1472
1473     if (len < raw->SectorCount * 2352) return STATUS_BUFFER_TOO_SMALL;
1474
1475 #if defined(linux)
1476     if (raw->DiskOffset.u.HighPart & ~2047) {
1477         WARN("DiskOffset points to a sector >= 2**32\n");
1478         return ret;
1479     }
1480
1481     switch (raw->TrackMode)
1482     {
1483     case YellowMode2:
1484     case XAForm2:
1485     {
1486         DWORD lba = raw->DiskOffset.QuadPart >> 11;
1487         struct cdrom_msf*       msf;
1488         PBYTE                   *bp; /* current buffer pointer */
1489         DWORD i;
1490
1491         if ((lba + raw->SectorCount) >
1492             ((1 << 8*sizeof(msf->cdmsf_min0)) * CD_SECS * CD_FRAMES
1493              - CD_MSF_OFFSET)) {
1494             WARN("DiskOffset not accessible with MSF\n");
1495             return ret;
1496         }
1497
1498         /* Linux reads only one sector at a time.
1499          * ioctl CDROMREADRAW takes struct cdrom_msf as an argument
1500          * on the contrary to what header comments state.
1501          */
1502         lba += CD_MSF_OFFSET;
1503         for (i = 0, bp = buffer; i < raw->SectorCount;
1504              i++, lba++, bp += 2352)
1505         {
1506             msf = (struct cdrom_msf*)bp;
1507             msf->cdmsf_min0   = lba / CD_FRAMES / CD_SECS;
1508             msf->cdmsf_sec0   = lba / CD_FRAMES % CD_SECS;
1509             msf->cdmsf_frame0 = lba % CD_FRAMES;
1510             io = ioctl(fd, CDROMREADRAW, msf);
1511             if (io != 0)
1512             {
1513                 *sz = 2352 * i;
1514                 return CDROM_GetStatusCode(io);
1515             }
1516         }
1517         break;
1518     }
1519
1520     case CDDA:
1521     {
1522         struct cdrom_read_audio cdra;
1523
1524         cdra.addr.lba = raw->DiskOffset.QuadPart >> 11;
1525         TRACE("reading at %u\n", cdra.addr.lba);
1526         cdra.addr_format = CDROM_LBA;
1527         cdra.nframes = raw->SectorCount;
1528         cdra.buf = buffer;
1529         io = ioctl(fd, CDROMREADAUDIO, &cdra);
1530         break;
1531     }
1532
1533     default:
1534         FIXME("NIY: %d\n", raw->TrackMode);
1535         return STATUS_INVALID_PARAMETER;
1536     }
1537 #elif defined(__APPLE__)
1538     /* Mac OS lets us read multiple parts of the sector at a time.
1539      * We can read all the sectors in at once, unlike Linux.
1540      */
1541     memset(&cdrd, 0, sizeof(cdrd));
1542     cdrd.offset = (raw->DiskOffset.QuadPart >> 11) * kCDSectorSizeWhole;
1543     cdrd.buffer = buffer;
1544     cdrd.bufferLength = raw->SectorCount * kCDSectorSizeWhole;
1545     switch (raw->TrackMode)
1546     {
1547     case YellowMode2:
1548         cdrd.sectorType = kCDSectorTypeMode2;
1549         cdrd.sectorArea = kCDSectorAreaSync | kCDSectorAreaHeader | kCDSectorAreaUser;
1550         break;
1551
1552     case XAForm2:
1553         cdrd.sectorType = kCDSectorTypeMode2Form2;
1554         cdrd.sectorArea = kCDSectorAreaSync | kCDSectorAreaHeader | kCDSectorAreaSubHeader | kCDSectorAreaUser;
1555         break;
1556
1557     case CDDA:
1558         cdrd.sectorType = kCDSectorTypeCDDA;
1559         cdrd.sectorArea = kCDSectorAreaUser;
1560         break;
1561
1562     default:
1563         FIXME("NIY: %d\n", raw->TrackMode);
1564         return STATUS_INVALID_PARAMETER;
1565     }
1566     io = ioctl(fd, DKIOCCDREAD, &cdrd);
1567     if (io != 0)
1568     {
1569         *sz = cdrd.bufferLength;
1570         return CDROM_GetStatusCode(io);
1571     }
1572 #else
1573     switch (raw->TrackMode)
1574     {
1575     case YellowMode2:
1576         FIXME("YellowMode2: NIY\n");
1577         return ret;
1578     case XAForm2:
1579         FIXME("XAForm2: NIY\n");
1580         return ret;
1581     case CDDA:
1582         FIXME("CDDA: NIY\n");
1583         return ret;
1584     default:
1585         FIXME("NIY: %d\n", raw->TrackMode);
1586         return STATUS_INVALID_PARAMETER;
1587     }
1588 #endif
1589
1590     *sz = 2352 * raw->SectorCount;
1591     ret = CDROM_GetStatusCode(io);
1592     return ret;
1593 }
1594
1595 /******************************************************************
1596  *        CDROM_ScsiPassThroughDirect
1597  *        Implements IOCTL_SCSI_PASS_THROUGH_DIRECT
1598  *
1599  */
1600 static NTSTATUS CDROM_ScsiPassThroughDirect(int fd, PSCSI_PASS_THROUGH_DIRECT pPacket)
1601 {
1602     int ret = STATUS_NOT_SUPPORTED;
1603 #ifdef HAVE_SG_IO_HDR_T_INTERFACE_ID
1604     sg_io_hdr_t cmd;
1605     int io;
1606 #elif defined HAVE_SCSIREQ_T_CMD
1607     scsireq_t cmd;
1608     int io;
1609 #elif defined __APPLE__
1610     dk_scsi_command_t cmd;
1611     int io;
1612 #endif
1613
1614     if (pPacket->Length < sizeof(SCSI_PASS_THROUGH_DIRECT))
1615         return STATUS_BUFFER_TOO_SMALL;
1616
1617     if (pPacket->CdbLength > 16)
1618         return STATUS_INVALID_PARAMETER;
1619
1620 #ifdef SENSEBUFLEN
1621     if (pPacket->SenseInfoLength > SENSEBUFLEN)
1622         return STATUS_INVALID_PARAMETER;
1623 #elif defined HAVE_REQUEST_SENSE
1624     if (pPacket->SenseInfoLength > sizeof(struct request_sense))
1625         return STATUS_INVALID_PARAMETER;
1626 #endif
1627
1628     if (pPacket->DataTransferLength > 0 && !pPacket->DataBuffer)
1629         return STATUS_INVALID_PARAMETER;
1630
1631 #ifdef HAVE_SG_IO_HDR_T_INTERFACE_ID
1632     RtlZeroMemory(&cmd, sizeof(cmd));
1633
1634     cmd.interface_id   = 'S';
1635     cmd.cmd_len        = pPacket->CdbLength;
1636     cmd.mx_sb_len      = pPacket->SenseInfoLength;
1637     cmd.dxfer_len      = pPacket->DataTransferLength;
1638     cmd.dxferp         = pPacket->DataBuffer;
1639     cmd.cmdp           = pPacket->Cdb;
1640     cmd.sbp            = (unsigned char*)pPacket + pPacket->SenseInfoOffset;
1641     cmd.timeout        = pPacket->TimeOutValue*1000;
1642
1643     switch (pPacket->DataIn)
1644     {
1645     case SCSI_IOCTL_DATA_IN:
1646         cmd.dxfer_direction = SG_DXFER_FROM_DEV;
1647         break;
1648     case SCSI_IOCTL_DATA_OUT:
1649         cmd.dxfer_direction = SG_DXFER_TO_DEV;
1650         break;
1651     case SCSI_IOCTL_DATA_UNSPECIFIED:
1652         cmd.dxfer_direction = SG_DXFER_NONE;
1653         break;
1654     default:
1655        return STATUS_INVALID_PARAMETER;
1656     }
1657
1658     io = ioctl(fd, SG_IO, &cmd);
1659
1660     pPacket->ScsiStatus         = cmd.status;
1661     pPacket->DataTransferLength = cmd.resid;
1662     pPacket->SenseInfoLength    = cmd.sb_len_wr;
1663
1664     ret = CDROM_GetStatusCode(io);
1665
1666 #elif defined HAVE_SCSIREQ_T_CMD
1667
1668     memset(&cmd, 0, sizeof(cmd));
1669     memcpy(&(cmd.cmd), &(pPacket->Cdb), pPacket->CdbLength);
1670
1671     cmd.cmdlen         = pPacket->CdbLength;
1672     cmd.databuf        = pPacket->DataBuffer;
1673     cmd.datalen        = pPacket->DataTransferLength;
1674     cmd.senselen       = pPacket->SenseInfoLength;
1675     cmd.timeout        = pPacket->TimeOutValue*1000; /* in milliseconds */
1676
1677     switch (pPacket->DataIn)
1678     {
1679     case SCSI_IOCTL_DATA_OUT:
1680         cmd.flags |= SCCMD_WRITE;
1681         break;
1682     case SCSI_IOCTL_DATA_IN:
1683         cmd.flags |= SCCMD_READ;
1684         break;
1685     case SCSI_IOCTL_DATA_UNSPECIFIED:
1686         cmd.flags = 0;
1687         break;
1688     default:
1689        return STATUS_INVALID_PARAMETER;
1690     }
1691
1692     io = ioctl(fd, SCIOCCOMMAND, &cmd);
1693
1694     switch (cmd.retsts)
1695     {
1696     case SCCMD_OK:         break;
1697     case SCCMD_TIMEOUT:    return STATUS_TIMEOUT;
1698                            break;
1699     case SCCMD_BUSY:       return STATUS_DEVICE_BUSY;
1700                            break;
1701     case SCCMD_SENSE:      break;
1702     case SCCMD_UNKNOWN:    return STATUS_UNSUCCESSFUL;
1703                            break;
1704     }
1705
1706     if (pPacket->SenseInfoLength != 0)
1707     {
1708         memcpy((char*)pPacket + pPacket->SenseInfoOffset,
1709                cmd.sense, pPacket->SenseInfoLength);
1710     }
1711
1712     pPacket->ScsiStatus = cmd.status;
1713
1714     ret = CDROM_GetStatusCode(io);
1715
1716 #elif defined(__APPLE__)
1717
1718     memset(&cmd, 0, sizeof(cmd));
1719     memcpy(cmd.cdb, pPacket->Cdb, pPacket->CdbLength);
1720
1721     cmd.cdbSize        = pPacket->CdbLength;
1722     cmd.buffer         = pPacket->DataBuffer;
1723     cmd.bufferSize     = pPacket->DataTransferLength;
1724     cmd.sense          = (char*)pPacket + pPacket->SenseInfoOffset;
1725     cmd.senseLen       = pPacket->SenseInfoLength;
1726     cmd.timeout        = pPacket->TimeOutValue*1000; /* in milliseconds */
1727
1728     switch (pPacket->DataIn)
1729     {
1730     case SCSI_IOCTL_DATA_OUT:
1731         cmd.direction = kSCSIDataTransfer_FromInitiatorToTarget;
1732         break;
1733     case SCSI_IOCTL_DATA_IN:
1734         cmd.direction = kSCSIDataTransfer_FromTargetToInitiator;
1735         break;
1736     case SCSI_IOCTL_DATA_UNSPECIFIED:
1737         cmd.direction = kSCSIDataTransfer_NoDataTransfer;
1738         break;
1739     default:
1740        return STATUS_INVALID_PARAMETER;
1741     }
1742
1743     io = ioctl(fd, DKIOCSCSICOMMAND, &cmd);
1744
1745     if (cmd.response == kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE)
1746     {
1747         /* Command failed */
1748         switch (cmd.status)
1749         {
1750         case kSCSITaskStatus_TaskTimeoutOccurred:     return STATUS_TIMEOUT;
1751                                                       break;
1752         case kSCSITaskStatus_ProtocolTimeoutOccurred: return STATUS_IO_TIMEOUT;
1753                                                       break;
1754         case kSCSITaskStatus_DeviceNotResponding:     return STATUS_DEVICE_BUSY;
1755                                                       break;
1756         case kSCSITaskStatus_DeviceNotPresent:
1757             return STATUS_NO_SUCH_DEVICE;
1758             break;
1759         case kSCSITaskStatus_DeliveryFailure:
1760             return STATUS_DEVICE_PROTOCOL_ERROR;
1761             break;
1762         case kSCSITaskStatus_No_Status:
1763         default:
1764             return STATUS_UNSUCCESSFUL;
1765             break;
1766         }
1767     }
1768
1769     if (cmd.status != kSCSITaskStatus_No_Status)
1770         pPacket->ScsiStatus = cmd.status;
1771
1772     ret = CDROM_GetStatusCode(io);
1773 #endif
1774     return ret;
1775 }
1776
1777 /******************************************************************
1778  *              CDROM_ScsiPassThrough
1779  *              Implements IOCTL_SCSI_PASS_THROUGH
1780  *
1781  */
1782 static NTSTATUS CDROM_ScsiPassThrough(int fd, PSCSI_PASS_THROUGH pPacket)
1783 {
1784     int ret = STATUS_NOT_SUPPORTED;
1785 #ifdef HAVE_SG_IO_HDR_T_INTERFACE_ID
1786     sg_io_hdr_t cmd;
1787     int io;
1788 #elif defined HAVE_SCSIREQ_T_CMD
1789     scsireq_t cmd;
1790     int io;
1791 #elif defined __APPLE__
1792     dk_scsi_command_t cmd;
1793     int io;
1794 #endif
1795
1796     if (pPacket->Length < sizeof(SCSI_PASS_THROUGH))
1797         return STATUS_BUFFER_TOO_SMALL;
1798
1799     if (pPacket->CdbLength > 16)
1800         return STATUS_INVALID_PARAMETER;
1801
1802 #ifdef SENSEBUFLEN
1803     if (pPacket->SenseInfoLength > SENSEBUFLEN)
1804         return STATUS_INVALID_PARAMETER;
1805 #elif defined HAVE_REQUEST_SENSE
1806     if (pPacket->SenseInfoLength > sizeof(struct request_sense))
1807         return STATUS_INVALID_PARAMETER;
1808 #endif
1809
1810     if (pPacket->DataTransferLength > 0 && pPacket->DataBufferOffset < sizeof(SCSI_PASS_THROUGH))
1811         return STATUS_INVALID_PARAMETER;
1812
1813 #ifdef HAVE_SG_IO_HDR_T_INTERFACE_ID
1814     RtlZeroMemory(&cmd, sizeof(cmd));
1815
1816     cmd.interface_id   = 'S';
1817     cmd.dxfer_len      = pPacket->DataTransferLength;
1818     cmd.dxferp         = (char*)pPacket + pPacket->DataBufferOffset;
1819     cmd.cmd_len        = pPacket->CdbLength;
1820     cmd.cmdp           = pPacket->Cdb;
1821     cmd.mx_sb_len      = pPacket->SenseInfoLength;
1822     cmd.timeout        = pPacket->TimeOutValue*1000;
1823
1824     if(cmd.mx_sb_len > 0)
1825         cmd.sbp = (unsigned char*)pPacket + pPacket->SenseInfoOffset;
1826
1827     switch (pPacket->DataIn)
1828     {
1829     case SCSI_IOCTL_DATA_IN:
1830         cmd.dxfer_direction = SG_DXFER_FROM_DEV;
1831                              break;
1832     case SCSI_IOCTL_DATA_OUT:
1833         cmd.dxfer_direction = SG_DXFER_TO_DEV;
1834                              break;
1835     case SCSI_IOCTL_DATA_UNSPECIFIED:
1836         cmd.dxfer_direction = SG_DXFER_NONE;
1837                              break;
1838     default:
1839        return STATUS_INVALID_PARAMETER;
1840     }
1841
1842     io = ioctl(fd, SG_IO, &cmd);
1843
1844     pPacket->ScsiStatus         = cmd.status;
1845     pPacket->DataTransferLength = cmd.resid;
1846     pPacket->SenseInfoLength    = cmd.sb_len_wr;
1847
1848     ret = CDROM_GetStatusCode(io);
1849
1850 #elif defined HAVE_SCSIREQ_T_CMD
1851
1852     memset(&cmd, 0, sizeof(cmd));
1853     memcpy(&(cmd.cmd), &(pPacket->Cdb), pPacket->CdbLength);
1854
1855     if ( pPacket->DataBufferOffset > 0x1000 )
1856     {
1857         cmd.databuf     = (void*)pPacket->DataBufferOffset;
1858     }
1859     else
1860     {
1861         cmd.databuf     = (char*)pPacket + pPacket->DataBufferOffset;
1862     }
1863
1864     cmd.cmdlen         = pPacket->CdbLength;
1865     cmd.datalen        = pPacket->DataTransferLength;
1866     cmd.senselen       = pPacket->SenseInfoLength;
1867     cmd.timeout        = pPacket->TimeOutValue*1000; /* in milliseconds */
1868
1869     switch (pPacket->DataIn)
1870     {
1871     case SCSI_IOCTL_DATA_OUT:
1872         cmd.flags |= SCCMD_WRITE;
1873         break;
1874     case SCSI_IOCTL_DATA_IN:
1875         cmd.flags |= SCCMD_READ;
1876         break;
1877     case SCSI_IOCTL_DATA_UNSPECIFIED:
1878         cmd.flags = 0;
1879         break;
1880     default:
1881        return STATUS_INVALID_PARAMETER;
1882     }
1883
1884     io = ioctl(fd, SCIOCCOMMAND, &cmd);
1885
1886     switch (cmd.retsts)
1887     {
1888     case SCCMD_OK:         break;
1889     case SCCMD_TIMEOUT:    return STATUS_TIMEOUT;
1890                            break;
1891     case SCCMD_BUSY:       return STATUS_DEVICE_BUSY;
1892                            break;
1893     case SCCMD_SENSE:      break;
1894     case SCCMD_UNKNOWN:    return STATUS_UNSUCCESSFUL;
1895                            break;
1896     }
1897
1898     if (pPacket->SenseInfoLength != 0)
1899     {
1900         memcpy((char*)pPacket + pPacket->SenseInfoOffset,
1901                cmd.sense, pPacket->SenseInfoLength);
1902     }
1903
1904     pPacket->ScsiStatus = cmd.status;
1905
1906     ret = CDROM_GetStatusCode(io);
1907
1908 #elif defined(__APPLE__)
1909
1910     memset(&cmd, 0, sizeof(cmd));
1911     memcpy(cmd.cdb, pPacket->Cdb, pPacket->CdbLength);
1912
1913     cmd.cdbSize        = pPacket->CdbLength;
1914     cmd.buffer         = (char*)pPacket + pPacket->DataBufferOffset;
1915     cmd.bufferSize     = pPacket->DataTransferLength;
1916     cmd.sense          = (char*)pPacket + pPacket->SenseInfoOffset;
1917     cmd.senseLen       = pPacket->SenseInfoLength;
1918     cmd.timeout        = pPacket->TimeOutValue*1000; /* in milliseconds */
1919
1920     switch (pPacket->DataIn)
1921     {
1922     case SCSI_IOCTL_DATA_OUT:
1923         cmd.direction = kSCSIDataTransfer_FromInitiatorToTarget;
1924         break;
1925     case SCSI_IOCTL_DATA_IN:
1926         cmd.direction = kSCSIDataTransfer_FromTargetToInitiator;
1927         break;
1928     case SCSI_IOCTL_DATA_UNSPECIFIED:
1929         cmd.direction = kSCSIDataTransfer_NoDataTransfer;
1930         break;
1931     default:
1932        return STATUS_INVALID_PARAMETER;
1933     }
1934
1935     io = ioctl(fd, DKIOCSCSICOMMAND, &cmd);
1936
1937     if (cmd.response == kSCSIServiceResponse_SERVICE_DELIVERY_OR_TARGET_FAILURE)
1938     {
1939         /* Command failed */
1940         switch (cmd.status)
1941         {
1942         case kSCSITaskStatus_TaskTimeoutOccurred:
1943             return STATUS_TIMEOUT;
1944             break;
1945         case kSCSITaskStatus_ProtocolTimeoutOccurred:
1946             return STATUS_IO_TIMEOUT;
1947             break;
1948         case kSCSITaskStatus_DeviceNotResponding:
1949             return STATUS_DEVICE_BUSY;
1950             break;
1951         case kSCSITaskStatus_DeviceNotPresent:
1952             return STATUS_NO_SUCH_DEVICE;
1953             break;
1954         case kSCSITaskStatus_DeliveryFailure:
1955             return STATUS_DEVICE_PROTOCOL_ERROR;
1956             break;
1957         case kSCSITaskStatus_No_Status:
1958         default:
1959             return STATUS_UNSUCCESSFUL;
1960             break;
1961         }
1962     }
1963
1964     if (cmd.status != kSCSITaskStatus_No_Status)
1965         pPacket->ScsiStatus = cmd.status;
1966
1967     ret = CDROM_GetStatusCode(io);
1968 #endif
1969     return ret;
1970 }
1971
1972 /******************************************************************
1973  *              CDROM_ScsiGetCaps
1974  *
1975  *
1976  */
1977 static NTSTATUS CDROM_ScsiGetCaps(int fd, PIO_SCSI_CAPABILITIES caps)
1978 {
1979     NTSTATUS    ret = STATUS_NOT_IMPLEMENTED;
1980
1981 #ifdef SG_SCATTER_SZ
1982     caps->Length = sizeof(*caps);
1983     caps->MaximumTransferLength = SG_SCATTER_SZ; /* FIXME */
1984     caps->MaximumPhysicalPages = SG_SCATTER_SZ / getpagesize();
1985     caps->SupportedAsynchronousEvents = TRUE;
1986     caps->AlignmentMask = getpagesize();
1987     caps->TaggedQueuing = FALSE; /* we could check that it works and answer TRUE */
1988     caps->AdapterScansDown = FALSE; /* FIXME ? */
1989     caps->AdapterUsesPio = FALSE; /* FIXME ? */
1990     ret = STATUS_SUCCESS;
1991 #elif defined __APPLE__
1992     uint64_t bytesr, bytesw, align;
1993     int io = ioctl(fd, DKIOCGETMAXBYTECOUNTREAD, &bytesr);
1994     if (io != 0) return CDROM_GetStatusCode(io);
1995     io = ioctl(fd, DKIOCGETMAXBYTECOUNTWRITE, &bytesw);
1996     if (io != 0) return CDROM_GetStatusCode(io);
1997     io = ioctl(fd, DKIOCGETMINSEGMENTALIGNMENTBYTECOUNT, &align);
1998     if (io != 0) return CDROM_GetStatusCode(io);
1999     caps->Length = sizeof(*caps);
2000     caps->MaximumTransferLength = bytesr < bytesw ? bytesr : bytesw;
2001     caps->MaximumPhysicalPages = caps->MaximumTransferLength / getpagesize();
2002     caps->SupportedAsynchronousEvents = TRUE;
2003     caps->AlignmentMask = align-1;
2004     caps->TaggedQueuing = FALSE; /* we could check that it works and answer TRUE */
2005     caps->AdapterScansDown = FALSE; /* FIXME ? */
2006     caps->AdapterUsesPio = FALSE; /* FIXME ? */
2007     ret = STATUS_SUCCESS;
2008 #else
2009     FIXME("Unimplemented\n");
2010 #endif
2011     return ret;
2012 }
2013
2014 /******************************************************************
2015  *              CDROM_GetAddress
2016  *
2017  * implements IOCTL_SCSI_GET_ADDRESS
2018  */
2019 static NTSTATUS CDROM_GetAddress(int fd, SCSI_ADDRESS* address)
2020 {
2021     UCHAR portnum, busid, targetid, lun;
2022
2023     address->Length = sizeof(SCSI_ADDRESS);
2024     if ( ! CDROM_GetInterfaceInfo(fd, &portnum, &busid, &targetid, &lun))
2025         return STATUS_NOT_SUPPORTED;
2026
2027     address->PortNumber = portnum; /* primary=0 secondary=1 for ide */
2028     address->PathId = busid;       /* always 0 for ide */
2029     address->TargetId = targetid;  /* master=0 slave=1 for ide */
2030     address->Lun = lun;
2031     return STATUS_SUCCESS;
2032 }
2033
2034 /******************************************************************
2035  *              DVD_StartSession
2036  *
2037  *
2038  */
2039 static NTSTATUS DVD_StartSession(int fd, const DVD_SESSION_ID *sid_in, PDVD_SESSION_ID sid_out)
2040 {
2041 #if defined(linux)
2042     NTSTATUS ret = STATUS_NOT_SUPPORTED;
2043     dvd_authinfo auth_info;
2044
2045     memset( &auth_info, 0, sizeof( auth_info ) );
2046     auth_info.type = DVD_LU_SEND_AGID;
2047     if (sid_in) auth_info.lsa.agid = *(const int*)sid_in; /* ?*/
2048
2049     TRACE("fd 0x%08x\n",fd);
2050     ret =CDROM_GetStatusCode(ioctl(fd, DVD_AUTH, &auth_info));
2051     *sid_out = auth_info.lsa.agid;
2052     return ret;
2053 #elif defined(__APPLE__)
2054     NTSTATUS ret = STATUS_NOT_SUPPORTED;
2055     dk_dvd_report_key_t dvdrk;
2056     DVDAuthenticationGrantIDInfo agid_info;
2057
2058     dvdrk.format = kDVDKeyFormatAGID_CSS;
2059     dvdrk.keyClass = kDVDKeyClassCSS_CPPM_CPRM;
2060     if(sid_in) dvdrk.grantID = *(uint8_t*)sid_in; /* ? */
2061     dvdrk.bufferLength = sizeof(DVDAuthenticationGrantIDInfo);
2062     dvdrk.buffer = &agid_info;
2063
2064     ret = CDROM_GetStatusCode(ioctl(fd, DKIOCDVDREPORTKEY, &dvdrk));
2065     *sid_out = agid_info.grantID;
2066     return ret;
2067 #else
2068     FIXME("not supported on this O/S\n");
2069     return STATUS_NOT_SUPPORTED;
2070 #endif
2071 }
2072
2073 /******************************************************************
2074  *              DVD_EndSession
2075  *
2076  *
2077  */
2078 static NTSTATUS DVD_EndSession(int fd, const DVD_SESSION_ID *sid)
2079 {
2080 #if defined(linux)
2081     dvd_authinfo auth_info;
2082
2083     memset( &auth_info, 0, sizeof( auth_info ) );
2084     auth_info.type = DVD_INVALIDATE_AGID;
2085     auth_info.lsa.agid = *(const int*)sid;
2086
2087     TRACE("\n");
2088     return CDROM_GetStatusCode(ioctl(fd, DVD_AUTH, &auth_info));
2089 #elif defined(__APPLE__)
2090     dk_dvd_send_key_t dvdsk;
2091
2092     dvdsk.format = kDVDKeyFormatAGID_Invalidate;
2093     dvdsk.keyClass = kDVDKeyClassCSS_CPPM_CPRM;
2094     dvdsk.grantID = (uint8_t)*sid;
2095
2096     return CDROM_GetStatusCode(ioctl(fd, DKIOCDVDSENDKEY, &dvdsk));
2097 #else
2098     FIXME("not supported on this O/S\n");
2099     return STATUS_NOT_SUPPORTED;
2100 #endif
2101 }
2102
2103 /******************************************************************
2104  *              DVD_SendKey
2105  *
2106  *
2107  */
2108 static NTSTATUS DVD_SendKey(int fd, const DVD_COPY_PROTECT_KEY *key)
2109 {
2110 #if defined(linux)
2111     NTSTATUS ret = STATUS_NOT_SUPPORTED;
2112     dvd_authinfo auth_info;
2113
2114     memset( &auth_info, 0, sizeof( auth_info ) );
2115     switch (key->KeyType)
2116     {
2117     case DvdChallengeKey:
2118         auth_info.type = DVD_HOST_SEND_CHALLENGE;
2119         auth_info.hsc.agid = (int)key->SessionId;
2120         TRACE("DvdChallengeKey ioc 0x%x\n", DVD_AUTH );
2121         memcpy( auth_info.hsc.chal, key->KeyData, DVD_CHALLENGE_SIZE );
2122         ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
2123         break;
2124     case DvdBusKey2:
2125         auth_info.type = DVD_HOST_SEND_KEY2;
2126         auth_info.hsk.agid = (int)key->SessionId;
2127
2128         memcpy( auth_info.hsk.key, key->KeyData, DVD_KEY_SIZE );
2129
2130         TRACE("DvdBusKey2\n");
2131         ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
2132         break;
2133
2134     default:
2135         FIXME("Unknown Keytype 0x%x\n",key->KeyType);
2136     }
2137     return ret;
2138 #elif defined(__APPLE__)
2139     dk_dvd_send_key_t dvdsk;
2140     union
2141     {
2142         DVDChallengeKeyInfo chal;
2143         DVDKey2Info key2;
2144     } key_desc;
2145
2146     switch(key->KeyType)
2147     {
2148     case DvdChallengeKey:
2149         dvdsk.format = kDVDKeyFormatChallengeKey;
2150         dvdsk.bufferLength = sizeof(key_desc.chal);
2151         dvdsk.buffer = &key_desc.chal;
2152         OSWriteBigInt16(key_desc.chal.dataLength, 0, key->KeyLength);
2153         memcpy(key_desc.chal.challengeKeyValue, key->KeyData, key->KeyLength);
2154         break;
2155     case DvdBusKey2:
2156         dvdsk.format = kDVDKeyFormatKey2;
2157         dvdsk.bufferLength = sizeof(key_desc.key2);
2158         dvdsk.buffer = &key_desc.key2;
2159         OSWriteBigInt16(key_desc.key2.dataLength, 0, key->KeyLength);
2160         memcpy(key_desc.key2.key2Value, key->KeyData, key->KeyLength);
2161         break;
2162     case DvdInvalidateAGID:
2163         dvdsk.format = kDVDKeyFormatAGID_Invalidate;
2164         break;
2165     case DvdBusKey1:
2166     case DvdTitleKey:
2167     case DvdAsf:
2168     case DvdGetRpcKey:
2169     case DvdDiskKey:
2170         ERR("attempted to write read-only key type 0x%x\n", key->KeyType);
2171         return STATUS_NOT_SUPPORTED;
2172     case DvdSetRpcKey:
2173         FIXME("DvdSetRpcKey NIY\n");
2174         return STATUS_NOT_SUPPORTED;
2175     default:
2176         FIXME("got unknown key type 0x%x\n", key->KeyType);
2177         return STATUS_NOT_SUPPORTED;
2178     }
2179     dvdsk.keyClass = kDVDKeyClassCSS_CPPM_CPRM;
2180     dvdsk.grantID = (uint8_t)key->SessionId;
2181
2182     return CDROM_GetStatusCode(ioctl(fd, DKIOCDVDSENDKEY, &dvdsk));
2183 #else
2184     FIXME("not supported on this O/S\n");
2185     return STATUS_NOT_SUPPORTED;
2186 #endif
2187 }
2188
2189 /******************************************************************
2190  *              DVD_ReadKey
2191  *
2192  *
2193  */
2194 static NTSTATUS DVD_ReadKey(int fd, PDVD_COPY_PROTECT_KEY key)
2195 {
2196 #if defined(linux)
2197     NTSTATUS ret = STATUS_NOT_SUPPORTED;
2198     dvd_struct dvd;
2199     dvd_authinfo auth_info;
2200
2201     memset( &dvd, 0, sizeof( dvd_struct ) );
2202     memset( &auth_info, 0, sizeof( auth_info ) );
2203     switch (key->KeyType)
2204     {
2205     case DvdDiskKey:
2206
2207         dvd.type = DVD_STRUCT_DISCKEY;
2208         dvd.disckey.agid = (int)key->SessionId;
2209         memset( dvd.disckey.value, 0, DVD_DISCKEY_SIZE );
2210
2211         TRACE("DvdDiskKey\n");
2212         ret = CDROM_GetStatusCode(ioctl( fd, DVD_READ_STRUCT, &dvd ));
2213         if (ret == STATUS_SUCCESS)
2214             memcpy(key->KeyData,dvd.disckey.value,DVD_DISCKEY_SIZE);
2215         break;
2216     case DvdTitleKey:
2217         auth_info.type = DVD_LU_SEND_TITLE_KEY;
2218         auth_info.lstk.agid = (int)key->SessionId;
2219         auth_info.lstk.lba = (int)(key->Parameters.TitleOffset.QuadPart>>11);
2220         TRACE("DvdTitleKey session %d Quadpart 0x%08lx offset 0x%08x\n",
2221               (int)key->SessionId, (long)key->Parameters.TitleOffset.QuadPart,
2222               auth_info.lstk.lba);
2223         ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
2224         if (ret == STATUS_SUCCESS)
2225             memcpy(key->KeyData, auth_info.lstk.title_key, DVD_KEY_SIZE );
2226         break;
2227     case DvdChallengeKey:
2228
2229         auth_info.type = DVD_LU_SEND_CHALLENGE;
2230         auth_info.lsc.agid = (int)key->SessionId;
2231
2232         TRACE("DvdChallengeKey\n");
2233         ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
2234         if (ret == STATUS_SUCCESS)
2235             memcpy( key->KeyData, auth_info.lsc.chal, DVD_CHALLENGE_SIZE );
2236         break;
2237     case DvdAsf:
2238         auth_info.type = DVD_LU_SEND_ASF;
2239         TRACE("DvdAsf\n");
2240         auth_info.lsasf.asf=((PDVD_ASF)key->KeyData)->SuccessFlag;
2241         ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
2242         ((PDVD_ASF)key->KeyData)->SuccessFlag = auth_info.lsasf.asf;
2243         break;
2244     case DvdBusKey1:
2245         auth_info.type = DVD_LU_SEND_KEY1;
2246         auth_info.lsk.agid = (int)key->SessionId;
2247
2248         TRACE("DvdBusKey1\n");
2249         ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
2250
2251         if (ret == STATUS_SUCCESS)
2252             memcpy( key->KeyData, auth_info.lsk.key, DVD_KEY_SIZE );
2253         break;
2254     case DvdGetRpcKey:
2255         auth_info.type = DVD_LU_SEND_RPC_STATE;
2256
2257         TRACE("DvdGetRpcKey\n");
2258         ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
2259
2260         if (ret == STATUS_SUCCESS)
2261         {
2262             ((PDVD_RPC_KEY)key->KeyData)->TypeCode = auth_info.lrpcs.type;
2263             ((PDVD_RPC_KEY)key->KeyData)->RegionMask = auth_info.lrpcs.region_mask;
2264             ((PDVD_RPC_KEY)key->KeyData)->RpcScheme = auth_info.lrpcs.rpc_scheme;
2265             ((PDVD_RPC_KEY)key->KeyData)->UserResetsAvailable = auth_info.lrpcs.ucca;
2266             ((PDVD_RPC_KEY)key->KeyData)->ManufacturerResetsAvailable = auth_info.lrpcs.vra;
2267         }
2268         break;
2269     default:
2270         FIXME("Unknown keytype 0x%x\n",key->KeyType);
2271     }
2272     return ret;
2273 #elif defined(__APPLE__)
2274     union
2275     {
2276         dk_dvd_report_key_t key;
2277         dk_dvd_read_structure_t disk_key;
2278     } ioc;
2279     union
2280     {
2281         DVDDiscKeyInfo disk_key;
2282         DVDChallengeKeyInfo chal;
2283         DVDKey1Info key1;
2284         DVDTitleKeyInfo title;
2285         DVDAuthenticationSuccessFlagInfo asf;
2286         DVDRegionPlaybackControlInfo rpc;
2287     } desc;
2288     NTSTATUS ret = STATUS_NOT_SUPPORTED;
2289
2290     switch(key->KeyType)
2291     {
2292     case DvdChallengeKey:
2293         ioc.key.format = kDVDKeyFormatChallengeKey;
2294         ioc.key.grantID = (uint8_t)key->SessionId;
2295         ioc.key.keyClass = kDVDKeyClassCSS_CPPM_CPRM;
2296         ioc.key.bufferLength = sizeof(desc.chal);
2297         ioc.key.buffer = &desc.chal;
2298         OSWriteBigInt16(desc.chal.dataLength, 0, key->KeyLength);
2299         break;
2300     case DvdBusKey1:
2301         ioc.key.format = kDVDKeyFormatKey1;
2302         ioc.key.grantID = (uint8_t)key->SessionId;
2303         ioc.key.keyClass = kDVDKeyClassCSS_CPPM_CPRM;
2304         ioc.key.bufferLength = sizeof(desc.key1);
2305         ioc.key.buffer = &desc.key1;
2306         OSWriteBigInt16(desc.key1.dataLength, 0, key->KeyLength);
2307         break;
2308     case DvdTitleKey:
2309         ioc.key.format = kDVDKeyFormatTitleKey;
2310         ioc.key.grantID = (uint8_t)key->SessionId;
2311         ioc.key.keyClass = kDVDKeyClassCSS_CPPM_CPRM;
2312         ioc.key.bufferLength = sizeof(desc.title);
2313         ioc.key.buffer = &desc.title;
2314         ioc.key.address = (uint32_t)(key->Parameters.TitleOffset.QuadPart>>11);
2315         OSWriteBigInt16(desc.title.dataLength, 0, key->KeyLength);
2316         break;
2317     case DvdAsf:
2318         ioc.key.format = kDVDKeyFormatASF;
2319         ioc.key.grantID = (uint8_t)key->SessionId;
2320         ioc.key.keyClass = kDVDKeyClassCSS_CPPM_CPRM;
2321         ioc.key.bufferLength = sizeof(desc.asf);
2322         ioc.key.buffer = &desc.asf;
2323         OSWriteBigInt16(desc.asf.dataLength, 0, key->KeyLength);
2324         break;
2325     case DvdGetRpcKey:
2326         ioc.key.format = kDVDKeyFormatRegionState;
2327         ioc.key.grantID = (uint8_t)key->SessionId;
2328         ioc.key.keyClass = kDVDKeyClassCSS_CPPM_CPRM;
2329         ioc.key.bufferLength = sizeof(desc.rpc);
2330         ioc.key.buffer = &desc.rpc;
2331         OSWriteBigInt16(desc.rpc.dataLength, 0, key->KeyLength);
2332         break;
2333     case DvdDiskKey:
2334         ioc.disk_key.format = kDVDStructureFormatDiscKeyInfo;
2335         ioc.disk_key.grantID = (uint8_t)key->SessionId;
2336         ioc.disk_key.bufferLength = sizeof(desc.disk_key);
2337         ioc.disk_key.buffer = &desc.disk_key;
2338         break;
2339     case DvdInvalidateAGID:
2340         ioc.key.format = kDVDKeyFormatAGID_Invalidate;
2341         ioc.key.grantID = (uint8_t)key->SessionId;
2342         ioc.key.keyClass = kDVDKeyClassCSS_CPPM_CPRM;
2343         break;
2344     case DvdBusKey2:
2345     case DvdSetRpcKey:
2346         ERR("attempted to read write-only key type 0x%x\n", key->KeyType);
2347         return STATUS_NOT_SUPPORTED;
2348     default:
2349         FIXME("got unknown key type 0x%x\n", key->KeyType);
2350         return STATUS_NOT_SUPPORTED;
2351     }
2352
2353     ret = CDROM_GetStatusCode(ioctl(fd, (key->KeyType == DvdDiskKey ? DKIOCDVDREADSTRUCTURE : DKIOCDVDREPORTKEY), &ioc));
2354
2355     if (ret == STATUS_SUCCESS)
2356     {
2357         switch(key->KeyType)
2358         {
2359         case DvdChallengeKey:
2360             key->KeyLength = OSReadBigInt16(desc.chal.dataLength, 0);
2361             memcpy(key->KeyData, desc.chal.challengeKeyValue, key->KeyLength);
2362             break;
2363         case DvdBusKey1:
2364             key->KeyLength = OSReadBigInt16(desc.key1.dataLength, 0);
2365             memcpy(key->KeyData, desc.key1.key1Value, key->KeyLength);
2366             break;
2367         case DvdTitleKey:
2368             key->KeyLength = OSReadBigInt16(desc.title.dataLength, 0);
2369             memcpy(key->KeyData, desc.title.titleKeyValue, key->KeyLength);
2370             key->KeyFlags = 0;
2371             if (desc.title.CPM)
2372             {
2373                 /*key->KeyFlags |= DVD_COPYRIGHTED;*/
2374                 if (desc.title.CP_SEC) key->KeyFlags |= DVD_SECTOR_PROTECTED;
2375                 /*else key->KeyFlags |= DVD_SECTOR_NOT_PROTECTED;*/
2376 #if 0
2377                 switch (desc.title.CGMS)
2378                 {
2379                 case 0:
2380                     key->KeyFlags |= DVD_CGMS_COPY_PERMITTED;
2381                     break;
2382                 case 2:
2383                     key->KeyFlags |= DVD_CGMS_COPY_ONCE;
2384                     break;
2385                 case 3:
2386                     key->KeyFlags |= DVD_CGMS_NO_COPY;
2387                     break;
2388                 }
2389 #endif
2390             } /*else key->KeyFlags |= DVD_NOT_COPYRIGHTED;*/
2391             break;
2392         case DvdAsf:
2393             key->KeyLength = OSReadBigInt16(desc.title.dataLength, 0);
2394             ((PDVD_ASF)key->KeyData)->SuccessFlag = desc.asf.successFlag;
2395             break;
2396         case DvdGetRpcKey:
2397             key->KeyLength = OSReadBigInt16(desc.rpc.dataLength, 0);
2398             ((PDVD_RPC_KEY)key->KeyData)->UserResetsAvailable =
2399                 desc.rpc.numberUserResets;
2400             ((PDVD_RPC_KEY)key->KeyData)->ManufacturerResetsAvailable =
2401                 desc.rpc.numberVendorResets;
2402             ((PDVD_RPC_KEY)key->KeyData)->TypeCode =
2403                 desc.rpc.typeCode;
2404             ((PDVD_RPC_KEY)key->KeyData)->RegionMask =
2405                 desc.rpc.driveRegion;
2406             ((PDVD_RPC_KEY)key->KeyData)->RpcScheme =
2407                 desc.rpc.rpcScheme;
2408         case DvdDiskKey:
2409             key->KeyLength = OSReadBigInt16(desc.disk_key.dataLength, 0);
2410             memcpy(key->KeyData, desc.disk_key.discKeyStructures, key->KeyLength);
2411             break;
2412         case DvdBusKey2:
2413         case DvdSetRpcKey:
2414         case DvdInvalidateAGID:
2415         default:
2416             /* Silence warning */
2417             ;
2418         }
2419     }
2420     return ret;
2421 #else
2422     FIXME("not supported on this O/S\n");
2423     return STATUS_NOT_SUPPORTED;
2424 #endif
2425 }
2426
2427 /******************************************************************
2428  *              DVD_GetRegion
2429  *
2430  * This IOCTL combines information from both IOCTL_DVD_READ_KEY
2431  * with key type DvdGetRpcKey and IOCTL_DVD_READ_STRUCTURE with
2432  * structure type DvdCopyrightInformation into one structure.
2433  */
2434 static NTSTATUS DVD_GetRegion(int fd, PDVD_REGION region)
2435 {
2436 #if defined(linux)
2437     NTSTATUS ret = STATUS_NOT_SUPPORTED;
2438     dvd_struct dvd;
2439     dvd_authinfo auth_info;
2440
2441     dvd.type = DVD_STRUCT_COPYRIGHT;
2442     dvd.copyright.layer_num = 0;
2443     auth_info.type = DVD_LU_SEND_RPC_STATE;
2444
2445     ret = CDROM_GetStatusCode(ioctl( fd, DVD_AUTH, &auth_info ));
2446
2447     if (ret == STATUS_SUCCESS)
2448     {
2449         ret = CDROM_GetStatusCode(ioctl( fd, DVD_READ_STRUCT, &dvd ));
2450
2451         if (ret == STATUS_SUCCESS)
2452         {
2453             region->CopySystem = dvd.copyright.cpst;
2454             region->RegionData = dvd.copyright.rmi;
2455             region->SystemRegion = auth_info.lrpcs.region_mask;
2456             region->ResetCount = auth_info.lrpcs.ucca;
2457         }
2458     }
2459     return ret;
2460 #elif defined(__APPLE__)
2461     dk_dvd_report_key_t key;
2462     dk_dvd_read_structure_t dvd;
2463     DVDRegionPlaybackControlInfo rpc;
2464     DVDCopyrightInfo copy;
2465     NTSTATUS ret = STATUS_NOT_SUPPORTED;
2466
2467     key.format = kDVDKeyFormatRegionState;
2468     key.keyClass = kDVDKeyClassCSS_CPPM_CPRM;
2469     key.bufferLength = sizeof(rpc);
2470     key.buffer = &rpc;
2471     dvd.format = kDVDStructureFormatCopyrightInfo;
2472     dvd.bufferLength = sizeof(copy);
2473     dvd.buffer = &copy;
2474
2475     ret = CDROM_GetStatusCode(ioctl( fd, DKIOCDVDREPORTKEY, &key ));
2476
2477     if (ret == STATUS_SUCCESS)
2478     {
2479         ret = CDROM_GetStatusCode(ioctl( fd, DKIOCDVDREADSTRUCTURE, &dvd ));
2480
2481         if (ret == STATUS_SUCCESS)
2482         {
2483             region->CopySystem = copy.copyrightProtectionSystemType;
2484             region->RegionData = copy.regionMask;
2485             region->SystemRegion = rpc.driveRegion;
2486             region->ResetCount = rpc.numberUserResets;
2487         }
2488     }
2489     return ret;
2490 #else
2491     FIXME("not supported on this O/S\n");
2492     return STATUS_NOT_SUPPORTED;
2493 #endif
2494 }
2495
2496 /******************************************************************
2497  *              DVD_ReadStructure
2498  *
2499  *
2500  */
2501 static NTSTATUS DVD_ReadStructure(int dev, const DVD_READ_STRUCTURE *structure, PDVD_LAYER_DESCRIPTOR layer)
2502 {
2503 #ifdef DVD_READ_STRUCT
2504     /* dvd_struct is not defined consistently across platforms */
2505     union
2506     {
2507         struct dvd_physical     physical;
2508         struct dvd_copyright    copyright;
2509         struct dvd_disckey      disckey;
2510         struct dvd_bca          bca;
2511         struct dvd_manufact     manufact;
2512     } s;
2513
2514     if (structure->BlockByteOffset.u.HighPart || structure->BlockByteOffset.u.LowPart)
2515         FIXME(": BlockByteOffset is not handled\n");
2516
2517     switch (structure->Format)
2518     {
2519     case DvdPhysicalDescriptor:
2520         s.physical.type = DVD_STRUCT_PHYSICAL;
2521         s.physical.layer_num = structure->LayerNumber;
2522         break;
2523
2524     case DvdCopyrightDescriptor:
2525         s.copyright.type = DVD_STRUCT_COPYRIGHT;
2526         s.copyright.layer_num = structure->LayerNumber;
2527         break;
2528
2529     case DvdDiskKeyDescriptor:
2530         s.disckey.type = DVD_STRUCT_DISCKEY;
2531         s.disckey.agid = structure->SessionId;
2532         break;
2533
2534     case DvdBCADescriptor:
2535         s.bca.type = DVD_STRUCT_BCA;
2536         break;
2537
2538     case DvdManufacturerDescriptor:
2539         s.manufact.type = DVD_STRUCT_MANUFACT;
2540         s.manufact.layer_num = structure->LayerNumber;
2541         break;
2542
2543     case DvdMaxDescriptor: /* This is not a real request, no matter what MSDN says! */
2544     default:
2545         return STATUS_INVALID_PARAMETER;
2546     }
2547
2548     if (ioctl(dev, DVD_READ_STRUCT, &s) < 0)
2549        return STATUS_INVALID_PARAMETER;
2550
2551     switch (structure->Format)
2552     {
2553     case DvdPhysicalDescriptor:
2554         {
2555             internal_dvd_layer_descriptor *p = (internal_dvd_layer_descriptor *) layer;
2556             struct dvd_layer *l = &s.physical.layer[s.physical.layer_num];
2557
2558             p->Header.Length = 0x0802;
2559             p->Header.Reserved[0] = 0;
2560             p->Header.Reserved[1] = 0;
2561             p->Descriptor.BookVersion = l->book_version;
2562             p->Descriptor.BookType = l->book_type;
2563             p->Descriptor.MinimumRate = l->min_rate;
2564             p->Descriptor.DiskSize = l->disc_size;
2565             p->Descriptor.LayerType = l->layer_type;
2566             p->Descriptor.TrackPath = l->track_path;
2567             p->Descriptor.NumberOfLayers = l->nlayers;
2568             p->Descriptor.Reserved1 = 0;
2569             p->Descriptor.TrackDensity = l->track_density;
2570             p->Descriptor.LinearDensity = l->linear_density;
2571             p->Descriptor.StartingDataSector = GET_BE_DWORD(l->start_sector);
2572             p->Descriptor.EndDataSector = GET_BE_DWORD(l->end_sector);
2573             p->Descriptor.EndLayerZeroSector = GET_BE_DWORD(l->end_sector_l0);
2574             p->Descriptor.Reserved5 = 0;
2575             p->Descriptor.BCAFlag = l->bca;
2576         }
2577         break;
2578
2579     case DvdCopyrightDescriptor:
2580         {
2581             PDVD_COPYRIGHT_DESCRIPTOR p = (PDVD_COPYRIGHT_DESCRIPTOR) layer;
2582
2583             p->CopyrightProtectionType = s.copyright.cpst;
2584             p->RegionManagementInformation = s.copyright.rmi;
2585             p->Reserved = 0;
2586         }
2587         break;
2588
2589     case DvdDiskKeyDescriptor:
2590         {
2591             PDVD_DISK_KEY_DESCRIPTOR p = (PDVD_DISK_KEY_DESCRIPTOR) layer;
2592
2593             memcpy(p->DiskKeyData, s.disckey.value, 2048);
2594         }
2595         break;
2596
2597     case DvdBCADescriptor:
2598         {
2599             PDVD_BCA_DESCRIPTOR p = (PDVD_BCA_DESCRIPTOR) layer;
2600
2601             memcpy(p->BCAInformation, s.bca.value, s.bca.len);
2602         }
2603         break;
2604
2605     case DvdManufacturerDescriptor:
2606         {
2607             internal_dvd_manufacturer_descriptor *p = (internal_dvd_manufacturer_descriptor*) layer;
2608
2609             p->Header.Length = 0x0802;
2610             p->Header.Reserved[0] = 0;
2611             p->Header.Reserved[1] = 0;
2612             memcpy(p->Descriptor.ManufacturingInformation, s.manufact.value, 2048);
2613         }
2614         break;
2615
2616     case DvdMaxDescriptor: /* Suppress warning */
2617         break;
2618     }
2619 #elif defined(__APPLE__)
2620     NTSTATUS ret = STATUS_NOT_SUPPORTED;
2621     dk_dvd_read_structure_t dvdrs;
2622     union
2623     {
2624         DVDPhysicalFormatInfo phys;
2625         DVDCopyrightInfo copy;
2626         DVDDiscKeyInfo disk_key;
2627         DVDManufacturingInfo manf;
2628     } desc;
2629     union
2630     {
2631         PDVD_LAYER_DESCRIPTOR layer;
2632         internal_dvd_layer_descriptor *xlayer;
2633         PDVD_COPYRIGHT_DESCRIPTOR copy;
2634         PDVD_DISK_KEY_DESCRIPTOR disk_key;
2635         internal_dvd_manufacturer_descriptor *manf;
2636     } nt_desc;
2637
2638     nt_desc.layer = layer;
2639     RtlZeroMemory(&dvdrs, sizeof(dvdrs));
2640     dvdrs.address = (uint32_t)(structure->BlockByteOffset.QuadPart>>11);
2641     dvdrs.grantID = (uint8_t)structure->SessionId;
2642     dvdrs.layer = structure->LayerNumber;
2643     switch(structure->Format)
2644     {
2645     case DvdPhysicalDescriptor:
2646         dvdrs.format = kDVDStructureFormatPhysicalFormatInfo;
2647         dvdrs.bufferLength = sizeof(desc.phys);
2648         dvdrs.buffer = &desc.phys;
2649         break;
2650
2651     case DvdCopyrightDescriptor:
2652         dvdrs.format = kDVDStructureFormatCopyrightInfo;
2653         dvdrs.bufferLength = sizeof(desc.copy);
2654         dvdrs.buffer = &desc.copy;
2655         break;
2656
2657     case DvdDiskKeyDescriptor:
2658         dvdrs.format = kDVDStructureFormatDiscKeyInfo;
2659         dvdrs.bufferLength = sizeof(desc.disk_key);
2660         dvdrs.buffer = &desc.disk_key;
2661         break;
2662
2663     case DvdBCADescriptor:
2664         FIXME("DvdBCADescriptor NIY\n");
2665         return STATUS_NOT_SUPPORTED;
2666
2667     case DvdManufacturerDescriptor:
2668         dvdrs.format = kDVDStructureFormatManufacturingInfo;
2669         dvdrs.bufferLength = sizeof(desc.manf);
2670         dvdrs.buffer = &desc.manf;
2671         break;
2672
2673     case DvdMaxDescriptor:
2674     default:
2675         FIXME("got unknown structure type 0x%x\n", structure->Format);
2676         return STATUS_NOT_SUPPORTED;
2677     }
2678     ret = CDROM_GetStatusCode(ioctl(dev, DKIOCDVDREADSTRUCTURE, &dvdrs));
2679     if(ret == STATUS_SUCCESS)
2680     {
2681         switch(structure->Format)
2682         {
2683         case DvdPhysicalDescriptor:
2684             nt_desc.xlayer->Header.Length = 0x0802;
2685             nt_desc.xlayer->Header.Reserved[0] = 0;
2686             nt_desc.xlayer->Header.Reserved[1] = 0;
2687             nt_desc.xlayer->Descriptor.BookVersion = desc.phys.partVersion;
2688             nt_desc.xlayer->Descriptor.BookType = desc.phys.bookType;
2689             nt_desc.xlayer->Descriptor.MinimumRate = desc.phys.minimumRate;
2690             nt_desc.xlayer->Descriptor.DiskSize = desc.phys.discSize;
2691             nt_desc.xlayer->Descriptor.LayerType = desc.phys.layerType;
2692             nt_desc.xlayer->Descriptor.TrackPath = desc.phys.trackPath;
2693             nt_desc.xlayer->Descriptor.NumberOfLayers = desc.phys.numberOfLayers;
2694             nt_desc.xlayer->Descriptor.Reserved1 = 0;
2695             nt_desc.xlayer->Descriptor.TrackDensity = desc.phys.trackDensity;
2696             nt_desc.xlayer->Descriptor.LinearDensity = desc.phys.linearDensity;
2697             nt_desc.xlayer->Descriptor.StartingDataSector = GET_BE_DWORD(*(DWORD *)&desc.phys.zero1);
2698             nt_desc.xlayer->Descriptor.EndDataSector = GET_BE_DWORD(*(DWORD *)&desc.phys.zero2);
2699             nt_desc.xlayer->Descriptor.EndLayerZeroSector = GET_BE_DWORD(*(DWORD *)&desc.phys.zero3);
2700             nt_desc.xlayer->Descriptor.Reserved5 = 0;
2701             nt_desc.xlayer->Descriptor.BCAFlag = desc.phys.bcaFlag;
2702             break;
2703
2704         case DvdCopyrightDescriptor:
2705             nt_desc.copy->CopyrightProtectionType =
2706                 desc.copy.copyrightProtectionSystemType;
2707             nt_desc.copy->RegionManagementInformation =
2708                 desc.copy.regionMask;
2709             nt_desc.copy->Reserved = 0;
2710             break;
2711
2712         case DvdDiskKeyDescriptor:
2713             memcpy(
2714                 nt_desc.disk_key->DiskKeyData,
2715                 desc.disk_key.discKeyStructures,
2716                 2048);
2717             break;
2718
2719         case DvdManufacturerDescriptor:
2720             nt_desc.manf->Header.Length = 0x0802;
2721             nt_desc.manf->Header.Reserved[0] = 0;
2722             nt_desc.manf->Header.Reserved[1] = 0;
2723             memcpy(
2724                 nt_desc.manf->Descriptor.ManufacturingInformation,
2725                 desc.manf.discManufacturingInfo,
2726                 2048);
2727             break;
2728
2729         case DvdBCADescriptor:
2730         case DvdMaxDescriptor:
2731         default:
2732             /* Silence warning */
2733             break;
2734         }
2735     }
2736     return ret;
2737 #else
2738     FIXME("\n");
2739 #endif
2740     return STATUS_SUCCESS;
2741
2742 }
2743
2744 /******************************************************************
2745  *        GetInquiryData
2746  *        Implements the IOCTL_GET_INQUIRY_DATA ioctl.
2747  *        Returns Inquiry data for all devices on the specified scsi bus
2748  *        Returns STATUS_BUFFER_TOO_SMALL if the output buffer is too small,
2749  *        STATUS_INVALID_DEVICE_REQUEST if the given handle isn't to a SCSI device,
2750  *        or STATUS_NOT_SUPPORTED if the OS driver is too old
2751  */
2752 static NTSTATUS GetInquiryData(int fd, PSCSI_ADAPTER_BUS_INFO BufferOut, DWORD OutBufferSize)
2753 {
2754 #ifdef HAVE_SG_IO_HDR_T_INTERFACE_ID
2755     PSCSI_INQUIRY_DATA pInquiryData = NULL;
2756     UCHAR sense_buffer[32];
2757     int iochk, version;
2758     sg_io_hdr_t iocmd;
2759     UCHAR inquiry[INQ_CMD_LEN] = {INQUIRY, 0, 0, 0, INQ_REPLY_LEN, 0};
2760
2761     /* Check we have a SCSI device and a supported driver */
2762     if(ioctl(fd, SG_GET_VERSION_NUM, &version) != 0)
2763     {
2764         WARN("IOCTL_SCSI_GET_INQUIRY_DATA sg driver is not loaded\n");
2765         return STATUS_INVALID_DEVICE_REQUEST;
2766     }
2767     if(version < 30000 )
2768         return STATUS_NOT_SUPPORTED;
2769
2770     /* FIXME: Enumerate devices on the bus */
2771     BufferOut->NumberOfBuses = 1;
2772     BufferOut->BusData[0].NumberOfLogicalUnits = 1;
2773     BufferOut->BusData[0].InquiryDataOffset = sizeof(SCSI_ADAPTER_BUS_INFO);
2774
2775     pInquiryData = (PSCSI_INQUIRY_DATA)(BufferOut + 1);
2776
2777     RtlZeroMemory(&iocmd, sizeof(iocmd));
2778     iocmd.interface_id = 'S';
2779     iocmd.cmd_len = sizeof(inquiry);
2780     iocmd.mx_sb_len = sizeof(sense_buffer);
2781     iocmd.dxfer_direction = SG_DXFER_FROM_DEV;
2782     iocmd.dxfer_len = INQ_REPLY_LEN;
2783     iocmd.dxferp = pInquiryData->InquiryData;
2784     iocmd.cmdp = inquiry;
2785     iocmd.sbp = sense_buffer;
2786     iocmd.timeout = 1000;
2787
2788     iochk = ioctl(fd, SG_IO, &iocmd);
2789     if(iochk != 0)
2790         WARN("ioctl SG_IO returned %d, error (%s)\n", iochk, strerror(errno));
2791
2792     CDROM_GetInterfaceInfo(fd, &BufferOut->BusData[0].InitiatorBusId, &pInquiryData->PathId, &pInquiryData->TargetId, &pInquiryData->Lun);
2793     pInquiryData->DeviceClaimed = TRUE;
2794     pInquiryData->InquiryDataLength = INQ_REPLY_LEN;
2795     pInquiryData->NextInquiryDataOffset = 0;
2796     return STATUS_SUCCESS;
2797 #else
2798     FIXME("not supported on this O/S\n");
2799     return STATUS_NOT_SUPPORTED;
2800 #endif
2801 }
2802
2803 /******************************************************************
2804  *              CDROM_DeviceIoControl
2805  *
2806  *
2807  */
2808 NTSTATUS CDROM_DeviceIoControl(HANDLE hDevice,
2809                                HANDLE hEvent, PIO_APC_ROUTINE UserApcRoutine,
2810                                PVOID UserApcContext,
2811                                PIO_STATUS_BLOCK piosb,
2812                                ULONG dwIoControlCode,
2813                                LPVOID lpInBuffer, DWORD nInBufferSize,
2814                                LPVOID lpOutBuffer, DWORD nOutBufferSize)
2815 {
2816     DWORD       sz = 0;
2817     NTSTATUS    status = STATUS_SUCCESS;
2818     int fd, needs_close, dev;
2819
2820     TRACE("%p %s %p %d %p %d %p\n",
2821           hDevice, iocodex(dwIoControlCode), lpInBuffer, nInBufferSize,
2822           lpOutBuffer, nOutBufferSize, piosb);
2823
2824     piosb->Information = 0;
2825
2826     if ((status = server_get_unix_fd( hDevice, 0, &fd, &needs_close, NULL, NULL )))
2827     {
2828         if (status == STATUS_BAD_DEVICE_TYPE) return status;  /* no associated fd */
2829         goto error;
2830     }
2831
2832     if ((status = CDROM_Open(fd, &dev)))
2833     {
2834         if (needs_close) close( fd );
2835         goto error;
2836     }
2837
2838 #ifdef __APPLE__
2839     {
2840         char name[100];
2841
2842         /* This is ugly as hell, but Mac OS is unable to do anything from the
2843          * partition fd, it wants an fd for the whole device, and it sometimes
2844          * also requires the device fd to be closed first, so we have to close
2845          * the handle that the caller gave us.
2846          * Also for some reason it wants the fd to be closed before we even
2847          * open the parent if we're trying to eject the disk.
2848          */
2849         if ((status = get_parent_device( fd, name, sizeof(name) ))) goto error;
2850         if (dwIoControlCode == IOCTL_STORAGE_EJECT_MEDIA)
2851             NtClose( hDevice );
2852         if (needs_close) close( fd );
2853         TRACE("opening parent %s\n", name );
2854         if ((fd = open( name, O_RDONLY )) == -1)
2855         {
2856             status = FILE_GetNtStatus();
2857             goto error;
2858         }
2859         needs_close = 1;
2860     }
2861 #endif
2862
2863     switch (dwIoControlCode)
2864     {
2865     case IOCTL_CDROM_CHECK_VERIFY:
2866     case IOCTL_DISK_CHECK_VERIFY:
2867     case IOCTL_STORAGE_CHECK_VERIFY:
2868     case IOCTL_STORAGE_CHECK_VERIFY2:
2869         sz = 0;
2870         CDROM_ClearCacheEntry(dev);
2871         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2872             status = STATUS_INVALID_PARAMETER;
2873         else status = CDROM_Verify(dev, fd);
2874         break;
2875
2876 /* EPP     case IOCTL_STORAGE_CHECK_VERIFY2: */
2877
2878 /* EPP     case IOCTL_STORAGE_FIND_NEW_DEVICES: */
2879 /* EPP     case IOCTL_CDROM_FIND_NEW_DEVICES: */
2880
2881     case IOCTL_STORAGE_LOAD_MEDIA:
2882     case IOCTL_CDROM_LOAD_MEDIA:
2883         sz = 0;
2884         CDROM_ClearCacheEntry(dev);
2885         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2886             status = STATUS_INVALID_PARAMETER;
2887         else status = CDROM_SetTray(fd, FALSE);
2888         break;
2889      case IOCTL_STORAGE_EJECT_MEDIA:
2890         sz = 0;
2891         CDROM_ClearCacheEntry(dev);
2892         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2893             status = STATUS_INVALID_PARAMETER;
2894         else
2895             status = CDROM_SetTray(fd, TRUE);
2896         break;
2897
2898     case IOCTL_CDROM_MEDIA_REMOVAL:
2899     case IOCTL_DISK_MEDIA_REMOVAL:
2900     case IOCTL_STORAGE_MEDIA_REMOVAL:
2901     case IOCTL_STORAGE_EJECTION_CONTROL:
2902         /* FIXME the last ioctl:s is not the same as the two others...
2903          * lockcount/owner should be handled */
2904         sz = 0;
2905         CDROM_ClearCacheEntry(dev);
2906         if (lpOutBuffer != NULL || nOutBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2907         else if (nInBufferSize < sizeof(PREVENT_MEDIA_REMOVAL)) status = STATUS_BUFFER_TOO_SMALL;
2908         else status = CDROM_ControlEjection(fd, lpInBuffer);
2909         break;
2910
2911     case IOCTL_DISK_GET_MEDIA_TYPES:
2912     case IOCTL_STORAGE_GET_MEDIA_TYPES:
2913     case IOCTL_STORAGE_GET_MEDIA_TYPES_EX:
2914         sz = sizeof(GET_MEDIA_TYPES);
2915         if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2916         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2917         else status = CDROM_GetMediaType(dev, lpOutBuffer);
2918         break;
2919
2920     case IOCTL_STORAGE_GET_DEVICE_NUMBER:
2921         sz = sizeof(STORAGE_DEVICE_NUMBER);
2922         if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2923         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2924         else status = CDROM_GetDeviceNumber(dev, lpOutBuffer);
2925         break;
2926
2927     case IOCTL_STORAGE_RESET_DEVICE:
2928         sz = 0;
2929         CDROM_ClearCacheEntry(dev);
2930         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2931             status = STATUS_INVALID_PARAMETER;
2932         else status = CDROM_ResetAudio(fd);
2933         break;
2934
2935     case IOCTL_CDROM_GET_CONTROL:
2936         sz = sizeof(CDROM_AUDIO_CONTROL);
2937         if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2938         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2939         else status = CDROM_GetControl(dev, fd, lpOutBuffer);
2940         break;
2941
2942     case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
2943         sz = sizeof(DISK_GEOMETRY);
2944         if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2945         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2946         else status = CDROM_GetDriveGeometry(dev, fd, lpOutBuffer);
2947         break;
2948
2949     case IOCTL_CDROM_DISK_TYPE:
2950         sz = sizeof(CDROM_DISK_DATA);
2951         /* CDROM_ClearCacheEntry(dev); */
2952         if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2953         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2954         else status = CDROM_GetDiskData(dev, fd, lpOutBuffer);
2955         break;
2956
2957 /* EPP     case IOCTL_CDROM_GET_LAST_SESSION: */
2958
2959     case IOCTL_CDROM_READ_Q_CHANNEL:
2960         sz = sizeof(SUB_Q_CHANNEL_DATA);
2961         if (lpInBuffer == NULL || nInBufferSize < sizeof(CDROM_SUB_Q_DATA_FORMAT))
2962             status = STATUS_INVALID_PARAMETER;
2963         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2964         else status = CDROM_ReadQChannel(dev, fd, lpInBuffer, lpOutBuffer);
2965         break;
2966
2967     case IOCTL_CDROM_READ_TOC:
2968         sz = sizeof(CDROM_TOC);
2969         if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2970         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
2971         else status = CDROM_ReadTOC(dev, fd, lpOutBuffer);
2972         break;
2973
2974 /* EPP     case IOCTL_CDROM_READ_TOC_EX: */
2975
2976     case IOCTL_CDROM_PAUSE_AUDIO:
2977         sz = 0;
2978         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2979             status = STATUS_INVALID_PARAMETER;
2980         else status = CDROM_PauseAudio(fd);
2981         break;
2982     case IOCTL_CDROM_PLAY_AUDIO_MSF:
2983         sz = 0;
2984         if (lpOutBuffer != NULL || nOutBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2985         else if (nInBufferSize < sizeof(CDROM_PLAY_AUDIO_MSF)) status = STATUS_BUFFER_TOO_SMALL;
2986         else status = CDROM_PlayAudioMSF(fd, lpInBuffer);
2987         break;
2988     case IOCTL_CDROM_RESUME_AUDIO:
2989         sz = 0;
2990         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
2991             status = STATUS_INVALID_PARAMETER;
2992         else status = CDROM_ResumeAudio(fd);
2993         break;
2994     case IOCTL_CDROM_SEEK_AUDIO_MSF:
2995         sz = 0;
2996         if (lpOutBuffer != NULL || nOutBufferSize != 0) status = STATUS_INVALID_PARAMETER;
2997         else if (nInBufferSize < sizeof(CDROM_SEEK_AUDIO_MSF)) status = STATUS_BUFFER_TOO_SMALL;
2998         else status = CDROM_SeekAudioMSF(dev, fd, lpInBuffer);
2999         break;
3000     case IOCTL_CDROM_STOP_AUDIO:
3001         sz = 0;
3002         CDROM_ClearCacheEntry(dev); /* Maybe intention is to change media */
3003         if (lpInBuffer != NULL || nInBufferSize != 0 || lpOutBuffer != NULL || nOutBufferSize != 0)
3004             status = STATUS_INVALID_PARAMETER;
3005         else status = CDROM_StopAudio(fd);
3006         break;
3007     case IOCTL_CDROM_GET_VOLUME:
3008         sz = sizeof(VOLUME_CONTROL);
3009         if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
3010         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
3011         else status = CDROM_GetVolume(fd, lpOutBuffer);
3012         break;
3013     case IOCTL_CDROM_SET_VOLUME:
3014         sz = 0;
3015         CDROM_ClearCacheEntry(dev);
3016         if (lpInBuffer == NULL || nInBufferSize < sizeof(VOLUME_CONTROL) || lpOutBuffer != NULL)
3017             status = STATUS_INVALID_PARAMETER;
3018         else status = CDROM_SetVolume(fd, lpInBuffer);
3019         break;
3020     case IOCTL_CDROM_RAW_READ:
3021         sz = 0;
3022         if (nInBufferSize < sizeof(RAW_READ_INFO)) status = STATUS_INVALID_PARAMETER;
3023         else if (lpOutBuffer == NULL) status = STATUS_BUFFER_TOO_SMALL;
3024         else status = CDROM_RawRead(fd, lpInBuffer, lpOutBuffer,
3025                                     nOutBufferSize, &sz);
3026         break;
3027     case IOCTL_SCSI_GET_ADDRESS:
3028         sz = sizeof(SCSI_ADDRESS);
3029         if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
3030         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
3031         else status = CDROM_GetAddress(fd, lpOutBuffer);
3032         break;
3033     case IOCTL_SCSI_PASS_THROUGH_DIRECT:
3034         sz = sizeof(SCSI_PASS_THROUGH_DIRECT);
3035         if (lpOutBuffer == NULL) status = STATUS_INVALID_PARAMETER;
3036         else if (nOutBufferSize < sizeof(SCSI_PASS_THROUGH_DIRECT)) status = STATUS_BUFFER_TOO_SMALL;
3037         else status = CDROM_ScsiPassThroughDirect(fd, lpOutBuffer);
3038         break;
3039     case IOCTL_SCSI_PASS_THROUGH:
3040         sz = sizeof(SCSI_PASS_THROUGH);
3041         if (lpOutBuffer == NULL) status = STATUS_INVALID_PARAMETER;
3042         else if (nOutBufferSize < sizeof(SCSI_PASS_THROUGH)) status = STATUS_BUFFER_TOO_SMALL;
3043         else status = CDROM_ScsiPassThrough(fd, lpOutBuffer);
3044         break;
3045     case IOCTL_SCSI_GET_CAPABILITIES:
3046         sz = sizeof(IO_SCSI_CAPABILITIES);
3047         if (lpOutBuffer == NULL) status = STATUS_INVALID_PARAMETER;
3048         else if (nOutBufferSize < sizeof(IO_SCSI_CAPABILITIES)) status = STATUS_BUFFER_TOO_SMALL;
3049         else status = CDROM_ScsiGetCaps(fd, lpOutBuffer);
3050         break;
3051     case IOCTL_DVD_START_SESSION:
3052         sz = sizeof(DVD_SESSION_ID);
3053         if (lpOutBuffer == NULL) status = STATUS_INVALID_PARAMETER;
3054         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
3055         else
3056         {
3057             TRACE("before in 0x%08x out 0x%08x\n",(lpInBuffer)?*(PDVD_SESSION_ID)lpInBuffer:0,
3058                   *(PDVD_SESSION_ID)lpOutBuffer);
3059             status = DVD_StartSession(fd, lpInBuffer, lpOutBuffer);
3060             TRACE("before in 0x%08x out 0x%08x\n",(lpInBuffer)?*(PDVD_SESSION_ID)lpInBuffer:0,
3061                   *(PDVD_SESSION_ID)lpOutBuffer);
3062         }
3063         break;
3064     case IOCTL_DVD_END_SESSION:
3065         sz = sizeof(DVD_SESSION_ID);
3066         if ((lpInBuffer == NULL) ||  (nInBufferSize < sz))status = STATUS_INVALID_PARAMETER;
3067         else status = DVD_EndSession(fd, lpInBuffer);
3068         break;
3069     case IOCTL_DVD_SEND_KEY:
3070         sz = 0;
3071         if (!lpInBuffer ||
3072             (((PDVD_COPY_PROTECT_KEY)lpInBuffer)->KeyLength != nInBufferSize))
3073             status = STATUS_INVALID_PARAMETER;
3074         else
3075         {
3076             TRACE("doing DVD_SendKey\n");
3077             status = DVD_SendKey(fd, lpInBuffer);
3078         }
3079         break;
3080     case IOCTL_DVD_READ_KEY:
3081         if (!lpInBuffer ||
3082             (((PDVD_COPY_PROTECT_KEY)lpInBuffer)->KeyLength != nInBufferSize))
3083             status = STATUS_INVALID_PARAMETER;
3084         else if (lpInBuffer !=lpOutBuffer) status = STATUS_BUFFER_TOO_SMALL;
3085         else
3086         {
3087             TRACE("doing DVD_READ_KEY\n");
3088             sz = ((PDVD_COPY_PROTECT_KEY)lpInBuffer)->KeyLength;
3089             status = DVD_ReadKey(fd, lpInBuffer);
3090         }
3091         break;
3092     case IOCTL_DVD_GET_REGION:
3093         sz = sizeof(DVD_REGION);
3094         if (lpInBuffer != NULL || nInBufferSize != 0) status = STATUS_INVALID_PARAMETER;
3095         else if (nOutBufferSize < sz) status = STATUS_BUFFER_TOO_SMALL;
3096         TRACE("doing DVD_Get_REGION\n");
3097         status = DVD_GetRegion(fd, lpOutBuffer);
3098         break;
3099     case IOCTL_DVD_READ_STRUCTURE:
3100         sz = sizeof(DVD_LAYER_DESCRIPTOR);
3101         if (lpInBuffer == NULL || nInBufferSize != sizeof(DVD_READ_STRUCTURE)) status = STATUS_INVALID_PARAMETER;
3102         else if (nOutBufferSize < sz || !lpOutBuffer) status = STATUS_BUFFER_TOO_SMALL;
3103         else
3104         {
3105             TRACE("doing DVD_READ_STRUCTURE\n");
3106             status = DVD_ReadStructure(fd, lpInBuffer, lpOutBuffer);
3107         }
3108         break;
3109
3110     case IOCTL_SCSI_GET_INQUIRY_DATA:
3111         sz = INQ_REPLY_LEN;
3112         status = GetInquiryData(fd, lpOutBuffer, nOutBufferSize);
3113         break;
3114
3115     default:
3116         if (needs_close) close( fd );
3117         return STATUS_NOT_SUPPORTED;
3118     }
3119     if (needs_close) close( fd );
3120  error:
3121     piosb->u.Status = status;
3122     piosb->Information = sz;
3123     if (hEvent) NtSetEvent(hEvent, NULL);
3124     return status;
3125 }