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