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