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