1 /*****************************************************************************
2 * ioctl.c: DVD ioctl replacement function
3 *****************************************************************************
4 * Copyright (C) 1999-2001 VideoLAN
7 * Authors: Markus Kuespert <ltlBeBoy@beosmail.com>
8 * Samuel Hocevar <sam@zoy.org>
9 * Jon Lech Johansen <jon-vl@nanocrew.net>
10 * Håkan Hjort <d95hjort@dtek.chalmers.se>
11 * Eugenio Jarosiewicz <ej0@cise.ufl.edu>
12 * David Siebörger <drs-videolan@rucus.ru.ac.za>
13 * Alex Strelnikov <lelik@os2.ru>
14 * Gildas Bazin <gbazin@netcourrier.com>
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
29 *****************************************************************************/
31 /*****************************************************************************
33 *****************************************************************************/
38 #include <string.h> /* memcpy(), memset() */
39 #include <sys/types.h>
43 # include <winioctl.h>
44 #elif defined ( SYS_OS2 )
45 # define INCL_DOSFILEMGR
46 # define INCL_DOSDEVICES
47 # define INCL_DOSDEVIOCTL
48 # define INCL_DOSERRORS
50 # include <sys/ioctl.h>
52 # include <netinet/in.h>
53 # include <sys/ioctl.h>
56 #ifdef DVD_STRUCT_IN_SYS_CDIO_H
57 # include <sys/cdio.h>
59 #ifdef DVD_STRUCT_IN_SYS_DVDIO_H
60 # include <sys/dvdio.h>
62 #ifdef DVD_STRUCT_IN_LINUX_CDROM_H
63 # include <linux/cdrom.h>
65 #ifdef DVD_STRUCT_IN_DVD_H
68 #ifdef DVD_STRUCT_IN_BSDI_DVDIOCTL_DVD_H
69 # include "bsdi_dvd.h"
76 # include <sys/scsi.h>
82 # include <sys/scsi/scsi_types.h>
83 # include <sys/scsi/impl/uscsi.h>
85 #ifdef DARWIN_DVD_IOCTL
86 # include <IOKit/storage/IODVDMediaBSDClient.h>
89 # include <sys/mman.h>
90 # include <sys/dcmd_cam.h>
97 /*****************************************************************************
98 * Local prototypes, BeOS specific
99 *****************************************************************************/
100 #if defined( SYS_BEOS )
101 static void BeInitRDC ( raw_device_command
*, int );
104 /*****************************************************************************
105 * Local prototypes, HP-UX specific
106 *****************************************************************************/
107 #if defined( HPUX_SCTL_IO )
108 static void HPUXInitSCTL ( struct sctl_io
*sctl_io
, int i_type
);
111 /*****************************************************************************
112 * Local prototypes, Solaris specific
113 *****************************************************************************/
114 #if defined( SOLARIS_USCSI )
115 static void SolarisInitUSCSI( struct uscsi_cmd
*p_sc
, int i_type
);
116 static int SolarisSendUSCSI( int fd
, struct uscsi_cmd
*p_sc
);
119 /*****************************************************************************
120 * Local prototypes, win32 (aspi) specific
121 *****************************************************************************/
123 static void WinInitSPTD ( SCSI_PASS_THROUGH_DIRECT
*, int );
124 static void WinInitSSC ( struct SRB_ExecSCSICmd
*, int );
125 static int WinSendSSC ( int, struct SRB_ExecSCSICmd
* );
128 /*****************************************************************************
129 * Local prototypes, QNX specific
130 *****************************************************************************/
131 #if defined( __QNXNTO__ )
132 static void QNXInitCPT ( CAM_PASS_THRU
*, int );
135 /*****************************************************************************
136 * Local prototypes, OS2 specific
137 *****************************************************************************/
138 #if defined( SYS_OS2 )
139 static void OS2InitSDC( struct OS2_ExecSCSICmd
*, int );
142 /*****************************************************************************
143 * ioctl_ReadCopyright: check whether the disc is encrypted or not
144 *****************************************************************************/
145 int ioctl_ReadCopyright( int i_fd
, int i_layer
, int *pi_copyright
)
149 #if defined( HAVE_LINUX_DVD_STRUCT )
152 memset( &dvd
, 0, sizeof( dvd
) );
153 dvd
.type
= DVD_STRUCT_COPYRIGHT
;
154 dvd
.copyright
.layer_num
= i_layer
;
156 i_ret
= ioctl( i_fd
, DVD_READ_STRUCT
, &dvd
);
158 *pi_copyright
= dvd
.copyright
.cpst
;
160 #elif defined( HAVE_BSD_DVD_STRUCT )
161 struct dvd_struct dvd
;
163 memset( &dvd
, 0, sizeof( dvd
) );
164 dvd
.format
= DVD_STRUCT_COPYRIGHT
;
165 dvd
.layer_num
= i_layer
;
167 i_ret
= ioctl( i_fd
, DVDIOCREADSTRUCTURE
, &dvd
);
169 *pi_copyright
= dvd
.cpst
;
171 #elif defined( SYS_BEOS )
172 INIT_RDC( GPCMD_READ_DVD_STRUCTURE
, 8 );
174 rdc
.command
[ 6 ] = i_layer
;
175 rdc
.command
[ 7 ] = DVD_STRUCT_COPYRIGHT
;
177 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
179 *pi_copyright
= p_buffer
[ 4 ];
181 #elif defined( HPUX_SCTL_IO )
182 INIT_SCTL_IO( GPCMD_READ_DVD_STRUCTURE
, 8 );
184 sctl_io
.cdb
[ 6 ] = i_layer
;
185 sctl_io
.cdb
[ 7 ] = DVD_STRUCT_COPYRIGHT
;
187 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
189 *pi_copyright
= p_buffer
[ 4 ];
191 #elif defined( SOLARIS_USCSI )
192 INIT_USCSI( GPCMD_READ_DVD_STRUCTURE
, 8 );
194 rs_cdb
.cdb_opaque
[ 6 ] = i_layer
;
195 rs_cdb
.cdb_opaque
[ 7 ] = DVD_STRUCT_COPYRIGHT
;
197 i_ret
= SolarisSendUSCSI(i_fd
, &sc
);
199 if( i_ret
< 0 || sc
.uscsi_status
) {
203 *pi_copyright
= p_buffer
[ 4 ];
204 /* s->copyright.rmi = p_buffer[ 5 ]; */
206 #elif defined( DARWIN_DVD_IOCTL )
207 INIT_DVDIOCTL( dk_dvd_read_structure_t
, DVDCopyrightInfo
,
208 kDVDStructureFormatCopyrightInfo
);
212 i_ret
= ioctl( i_fd
, DKIOCDVDREADSTRUCTURE
, &dvd
);
214 *pi_copyright
= dvdbs
.copyrightProtectionSystemType
;
216 #elif defined( WIN32 )
217 if( WIN2K
) /* NT/2k/XP */
219 INIT_SPTD( GPCMD_READ_DVD_STRUCTURE
, 8 );
221 /* When using IOCTL_DVD_READ_STRUCTURE and
222 DVD_COPYRIGHT_DESCRIPTOR, CopyrightProtectionType
223 seems to be always 6 ???
224 To work around this MS bug we try to send a raw scsi command
225 instead (if we've got enough privileges to do so). */
227 sptd
.Cdb
[ 6 ] = i_layer
;
228 sptd
.Cdb
[ 7 ] = DVD_STRUCT_COPYRIGHT
;
230 i_ret
= SEND_SPTD( i_fd
, &sptd
, &tmp
);
234 *pi_copyright
= p_buffer
[ 4 ];
239 INIT_SSC( GPCMD_READ_DVD_STRUCTURE
, 8 );
241 ssc
.CDBByte
[ 6 ] = i_layer
;
242 ssc
.CDBByte
[ 7 ] = DVD_STRUCT_COPYRIGHT
;
244 i_ret
= WinSendSSC( i_fd
, &ssc
);
246 *pi_copyright
= p_buffer
[ 4 ];
249 #elif defined( __QNXNTO__ )
251 INIT_CPT( GPCMD_READ_DVD_STRUCTURE
, 8 );
253 p_cpt
->cam_cdb
[ 6 ] = i_layer
;
254 p_cpt
->cam_cdb
[ 7 ] = DVD_STRUCT_COPYRIGHT
;
256 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
258 *pi_copyright
= p_buffer
[4];
260 #elif defined( SYS_OS2 )
261 INIT_SSC( GPCMD_READ_DVD_STRUCTURE
, 8 );
263 sdc
.command
[ 6 ] = i_layer
;
264 sdc
.command
[ 7 ] = DVD_STRUCT_COPYRIGHT
;
266 i_ret
= DosDevIOCtl(i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
267 &sdc
, sizeof(sdc
), &ulParamLen
,
268 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
270 *pi_copyright
= p_buffer
[ 4 ];
273 # error "DVD ioctls are unavailable on this system"
279 /*****************************************************************************
280 * ioctl_ReadDiscKey: get the disc key
281 *****************************************************************************/
282 int ioctl_ReadDiscKey( int i_fd
, int *pi_agid
, uint8_t *p_key
)
286 #if defined( HAVE_LINUX_DVD_STRUCT )
289 memset( &dvd
, 0, sizeof( dvd
) );
290 dvd
.type
= DVD_STRUCT_DISCKEY
;
291 dvd
.disckey
.agid
= *pi_agid
;
292 memset( dvd
.disckey
.value
, 0, DVD_DISCKEY_SIZE
);
294 i_ret
= ioctl( i_fd
, DVD_READ_STRUCT
, &dvd
);
301 memcpy( p_key
, dvd
.disckey
.value
, DVD_DISCKEY_SIZE
);
303 #elif defined( HAVE_BSD_DVD_STRUCT )
304 struct dvd_struct dvd
;
306 memset( &dvd
, 0, sizeof( dvd
) );
307 dvd
.format
= DVD_STRUCT_DISCKEY
;
309 memset( dvd
.data
, 0, DVD_DISCKEY_SIZE
);
311 i_ret
= ioctl( i_fd
, DVDIOCREADSTRUCTURE
, &dvd
);
318 memcpy( p_key
, dvd
.data
, DVD_DISCKEY_SIZE
);
320 #elif defined( SYS_BEOS )
321 INIT_RDC( GPCMD_READ_DVD_STRUCTURE
, DVD_DISCKEY_SIZE
+ 4 );
323 rdc
.command
[ 7 ] = DVD_STRUCT_DISCKEY
;
324 rdc
.command
[ 10 ] = *pi_agid
<< 6;
326 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
333 memcpy( p_key
, p_buffer
+ 4, DVD_DISCKEY_SIZE
);
335 #elif defined( HPUX_SCTL_IO )
336 INIT_SCTL_IO( GPCMD_READ_DVD_STRUCTURE
, DVD_DISCKEY_SIZE
+ 4 );
338 sctl_io
.cdb
[ 7 ] = DVD_STRUCT_DISCKEY
;
339 sctl_io
.cdb
[ 10 ] = *pi_agid
<< 6;
341 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
348 memcpy( p_key
, p_buffer
+ 4, DVD_DISCKEY_SIZE
);
350 #elif defined( SOLARIS_USCSI )
351 INIT_USCSI( GPCMD_READ_DVD_STRUCTURE
, DVD_DISCKEY_SIZE
+ 4 );
353 rs_cdb
.cdb_opaque
[ 7 ] = DVD_STRUCT_DISCKEY
;
354 rs_cdb
.cdb_opaque
[ 10 ] = *pi_agid
<< 6;
356 i_ret
= SolarisSendUSCSI( i_fd
, &sc
);
358 if( i_ret
< 0 || sc
.uscsi_status
)
364 memcpy( p_key
, p_buffer
+ 4, DVD_DISCKEY_SIZE
);
366 #elif defined( DARWIN_DVD_IOCTL )
367 INIT_DVDIOCTL( dk_dvd_read_structure_t
, DVDDiscKeyInfo
,
368 kDVDStructureFormatDiscKeyInfo
);
370 dvd
.grantID
= *pi_agid
;
372 i_ret
= ioctl( i_fd
, DKIOCDVDREADSTRUCTURE
, &dvd
);
374 memcpy( p_key
, dvdbs
.discKeyStructures
, DVD_DISCKEY_SIZE
);
376 #elif defined( WIN32 )
377 if( WIN2K
) /* NT/2k/XP */
380 uint8_t buffer
[DVD_DISK_KEY_LENGTH
];
381 PDVD_COPY_PROTECT_KEY key
= (PDVD_COPY_PROTECT_KEY
) &buffer
;
383 memset( &buffer
, 0, sizeof( buffer
) );
385 key
->KeyLength
= DVD_DISK_KEY_LENGTH
;
386 key
->SessionId
= *pi_agid
;
387 key
->KeyType
= DvdDiskKey
;
390 i_ret
= DeviceIoControl( (HANDLE
) i_fd
, IOCTL_DVD_READ_KEY
, key
,
391 key
->KeyLength
, key
, key
->KeyLength
, &tmp
, NULL
) ? 0 : -1;
398 memcpy( p_key
, key
->KeyData
, DVD_DISCKEY_SIZE
);
402 INIT_SSC( GPCMD_READ_DVD_STRUCTURE
, DVD_DISCKEY_SIZE
+ 4 );
404 ssc
.CDBByte
[ 7 ] = DVD_STRUCT_DISCKEY
;
405 ssc
.CDBByte
[ 10 ] = *pi_agid
<< 6;
407 i_ret
= WinSendSSC( i_fd
, &ssc
);
414 memcpy( p_key
, p_buffer
+ 4, DVD_DISCKEY_SIZE
);
417 #elif defined( __QNXNTO__ )
419 INIT_CPT( GPCMD_READ_DVD_STRUCTURE
, DVD_DISCKEY_SIZE
+ 4 );
421 p_cpt
->cam_cdb
[ 7 ] = DVD_STRUCT_DISCKEY
;
422 p_cpt
->cam_cdb
[ 10 ] = *pi_agid
<< 6;
424 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
426 memcpy( p_key
, p_buffer
+ 4, DVD_DISCKEY_SIZE
);
428 #elif defined ( SYS_OS2 )
429 INIT_SSC( GPCMD_READ_DVD_STRUCTURE
, DVD_DISCKEY_SIZE
+ 4 );
431 sdc
.command
[ 7 ] = DVD_STRUCT_DISCKEY
;
432 sdc
.command
[ 10 ] = *pi_agid
<< 6;
434 i_ret
= DosDevIOCtl(i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
435 &sdc
, sizeof(sdc
), &ulParamLen
,
436 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
443 memcpy( p_key
, p_buffer
+ 4, DVD_DISCKEY_SIZE
);
446 # error "DVD ioctls are unavailable on this system"
452 /*****************************************************************************
453 * ioctl_ReadTitleKey: get the title key
454 *****************************************************************************/
455 int ioctl_ReadTitleKey( int i_fd
, int *pi_agid
, int i_pos
, uint8_t *p_key
)
459 #if defined( HAVE_LINUX_DVD_STRUCT )
460 dvd_authinfo auth_info
;
462 memset( &auth_info
, 0, sizeof( auth_info
) );
463 auth_info
.type
= DVD_LU_SEND_TITLE_KEY
;
464 auth_info
.lstk
.agid
= *pi_agid
;
465 auth_info
.lstk
.lba
= i_pos
;
467 i_ret
= ioctl( i_fd
, DVD_AUTH
, &auth_info
);
469 memcpy( p_key
, auth_info
.lstk
.title_key
, DVD_KEY_SIZE
);
471 #elif defined( HAVE_BSD_DVD_STRUCT )
472 struct dvd_authinfo auth_info
;
474 memset( &auth_info
, 0, sizeof( auth_info
) );
475 auth_info
.format
= DVD_REPORT_TITLE_KEY
;
476 auth_info
.agid
= *pi_agid
;
477 auth_info
.lba
= i_pos
;
479 i_ret
= ioctl( i_fd
, DVDIOCREPORTKEY
, &auth_info
);
481 memcpy( p_key
, auth_info
.keychal
, DVD_KEY_SIZE
);
483 #elif defined( SYS_BEOS )
484 INIT_RDC( GPCMD_REPORT_KEY
, 12 );
486 rdc
.command
[ 2 ] = ( i_pos
>> 24 ) & 0xff;
487 rdc
.command
[ 3 ] = ( i_pos
>> 16 ) & 0xff;
488 rdc
.command
[ 4 ] = ( i_pos
>> 8 ) & 0xff;
489 rdc
.command
[ 5 ] = ( i_pos
) & 0xff;
490 rdc
.command
[ 10 ] = DVD_REPORT_TITLE_KEY
| (*pi_agid
<< 6);
492 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
494 memcpy( p_key
, p_buffer
+ 5, DVD_KEY_SIZE
);
496 #elif defined( HPUX_SCTL_IO )
497 INIT_SCTL_IO( GPCMD_REPORT_KEY
, 12 );
499 sctl_io
.cdb
[ 2 ] = ( i_pos
>> 24 ) & 0xff;
500 sctl_io
.cdb
[ 3 ] = ( i_pos
>> 16 ) & 0xff;
501 sctl_io
.cdb
[ 4 ] = ( i_pos
>> 8 ) & 0xff;
502 sctl_io
.cdb
[ 5 ] = ( i_pos
) & 0xff;
503 sctl_io
.cdb
[ 10 ] = DVD_REPORT_TITLE_KEY
| (*pi_agid
<< 6);
505 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
507 memcpy( p_key
, p_buffer
+ 5, DVD_KEY_SIZE
);
509 #elif defined( SOLARIS_USCSI )
510 INIT_USCSI( GPCMD_REPORT_KEY
, 12 );
512 rs_cdb
.cdb_opaque
[ 2 ] = ( i_pos
>> 24 ) & 0xff;
513 rs_cdb
.cdb_opaque
[ 3 ] = ( i_pos
>> 16 ) & 0xff;
514 rs_cdb
.cdb_opaque
[ 4 ] = ( i_pos
>> 8 ) & 0xff;
515 rs_cdb
.cdb_opaque
[ 5 ] = ( i_pos
) & 0xff;
516 rs_cdb
.cdb_opaque
[ 10 ] = DVD_REPORT_TITLE_KEY
| (*pi_agid
<< 6);
518 i_ret
= SolarisSendUSCSI( i_fd
, &sc
);
520 if( i_ret
< 0 || sc
.uscsi_status
)
525 /* Do we want to return the cp_sec flag perhaps? */
526 /* a->lstk.cpm = (buf[ 4 ] >> 7) & 1; */
527 /* a->lstk.cp_sec = (buf[ 4 ] >> 6) & 1; */
528 /* a->lstk.cgms = (buf[ 4 ] >> 4) & 3; */
530 memcpy( p_key
, p_buffer
+ 5, DVD_KEY_SIZE
);
532 #elif defined( DARWIN_DVD_IOCTL )
533 INIT_DVDIOCTL( dk_dvd_report_key_t
, DVDTitleKeyInfo
,
534 kDVDKeyFormatTitleKey
);
537 dvd
.grantID
= *pi_agid
;
538 dvd
.keyClass
= kDVDKeyClassCSS_CPPM_CPRM
;
540 i_ret
= ioctl( i_fd
, DKIOCDVDREPORTKEY
, &dvd
);
542 memcpy( p_key
, dvdbs
.titleKeyValue
, DVD_KEY_SIZE
);
544 #elif defined( WIN32 )
545 if( WIN2K
) /* NT/2k/XP */
548 uint8_t buffer
[DVD_TITLE_KEY_LENGTH
];
549 PDVD_COPY_PROTECT_KEY key
= (PDVD_COPY_PROTECT_KEY
) &buffer
;
551 memset( &buffer
, 0, sizeof( buffer
) );
553 key
->KeyLength
= DVD_TITLE_KEY_LENGTH
;
554 key
->SessionId
= *pi_agid
;
555 key
->KeyType
= DvdTitleKey
;
557 key
->Parameters
.TitleOffset
.QuadPart
= (LONGLONG
) i_pos
*
558 2048 /*DVDCSS_BLOCK_SIZE*/;
560 i_ret
= DeviceIoControl( (HANDLE
) i_fd
, IOCTL_DVD_READ_KEY
, key
,
561 key
->KeyLength
, key
, key
->KeyLength
, &tmp
, NULL
) ? 0 : -1;
563 memcpy( p_key
, key
->KeyData
, DVD_KEY_SIZE
);
567 INIT_SSC( GPCMD_REPORT_KEY
, 12 );
569 ssc
.CDBByte
[ 2 ] = ( i_pos
>> 24 ) & 0xff;
570 ssc
.CDBByte
[ 3 ] = ( i_pos
>> 16 ) & 0xff;
571 ssc
.CDBByte
[ 4 ] = ( i_pos
>> 8 ) & 0xff;
572 ssc
.CDBByte
[ 5 ] = ( i_pos
) & 0xff;
573 ssc
.CDBByte
[ 10 ] = DVD_REPORT_TITLE_KEY
| (*pi_agid
<< 6);
575 i_ret
= WinSendSSC( i_fd
, &ssc
);
577 memcpy( p_key
, p_buffer
+ 5, DVD_KEY_SIZE
);
580 #elif defined( __QNXNTO__ )
582 INIT_CPT( GPCMD_REPORT_KEY
, 12 );
584 p_cpt
->cam_cdb
[ 2 ] = ( i_pos
>> 24 ) & 0xff;
585 p_cpt
->cam_cdb
[ 3 ] = ( i_pos
>> 16 ) & 0xff;
586 p_cpt
->cam_cdb
[ 4 ] = ( i_pos
>> 8 ) & 0xff;
587 p_cpt
->cam_cdb
[ 5 ] = ( i_pos
) & 0xff;
588 p_cpt
->cam_cdb
[ 10 ] = DVD_REPORT_TITLE_KEY
| (*pi_agid
<< 6);
590 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
592 memcpy( p_key
, p_buffer
+ 5, DVD_KEY_SIZE
);
594 #elif defined( SYS_OS2 )
595 INIT_SSC( GPCMD_REPORT_KEY
, 12 );
597 sdc
.command
[ 2 ] = ( i_pos
>> 24 ) & 0xff;
598 sdc
.command
[ 3 ] = ( i_pos
>> 16 ) & 0xff;
599 sdc
.command
[ 4 ] = ( i_pos
>> 8 ) & 0xff;
600 sdc
.command
[ 5 ] = ( i_pos
) & 0xff;
601 sdc
.command
[ 10 ] = DVD_REPORT_TITLE_KEY
| (*pi_agid
<< 6);
603 i_ret
= DosDevIOCtl(i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
604 &sdc
, sizeof(sdc
), &ulParamLen
,
605 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
607 memcpy( p_key
, p_buffer
+ 5, DVD_KEY_SIZE
);
610 # error "DVD ioctls are unavailable on this system"
618 /*****************************************************************************
619 * ioctl_ReportAgid: get AGID from the drive
620 *****************************************************************************/
621 int ioctl_ReportAgid( int i_fd
, int *pi_agid
)
625 #if defined( HAVE_LINUX_DVD_STRUCT )
626 dvd_authinfo auth_info
;
628 memset( &auth_info
, 0, sizeof( auth_info
) );
629 auth_info
.type
= DVD_LU_SEND_AGID
;
630 auth_info
.lsa
.agid
= *pi_agid
;
632 i_ret
= ioctl( i_fd
, DVD_AUTH
, &auth_info
);
634 *pi_agid
= auth_info
.lsa
.agid
;
636 #elif defined( HAVE_BSD_DVD_STRUCT )
637 struct dvd_authinfo auth_info
;
639 memset( &auth_info
, 0, sizeof( auth_info
) );
640 auth_info
.format
= DVD_REPORT_AGID
;
641 auth_info
.agid
= *pi_agid
;
643 i_ret
= ioctl( i_fd
, DVDIOCREPORTKEY
, &auth_info
);
645 *pi_agid
= auth_info
.agid
;
647 #elif defined( SYS_BEOS )
648 INIT_RDC( GPCMD_REPORT_KEY
, 8 );
650 rdc
.command
[ 10 ] = DVD_REPORT_AGID
| (*pi_agid
<< 6);
652 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
654 *pi_agid
= p_buffer
[ 7 ] >> 6;
656 #elif defined( HPUX_SCTL_IO )
657 INIT_SCTL_IO( GPCMD_REPORT_KEY
, 8 );
659 sctl_io
.cdb
[ 10 ] = DVD_REPORT_AGID
| (*pi_agid
<< 6);
661 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
663 *pi_agid
= p_buffer
[ 7 ] >> 6;
665 #elif defined( SOLARIS_USCSI )
666 INIT_USCSI( GPCMD_REPORT_KEY
, 8 );
668 rs_cdb
.cdb_opaque
[ 10 ] = DVD_REPORT_AGID
| (*pi_agid
<< 6);
670 i_ret
= SolarisSendUSCSI( i_fd
, &sc
);
672 if( i_ret
< 0 || sc
.uscsi_status
)
677 *pi_agid
= p_buffer
[ 7 ] >> 6;
679 #elif defined( DARWIN_DVD_IOCTL )
680 INIT_DVDIOCTL( dk_dvd_report_key_t
, DVDAuthenticationGrantIDInfo
,
681 kDVDKeyFormatAGID_CSS
);
683 dvd
.grantID
= *pi_agid
;
684 dvd
.keyClass
= kDVDKeyClassCSS_CPPM_CPRM
;
686 i_ret
= ioctl( i_fd
, DKIOCDVDREPORTKEY
, &dvd
);
688 *pi_agid
= dvdbs
.grantID
;
690 #elif defined( WIN32 )
691 if( WIN2K
) /* NT/2k/XP */
696 i_ret
= DeviceIoControl( (HANDLE
) i_fd
, IOCTL_DVD_START_SESSION
,
697 &tmp
, 4, &id
, sizeof( id
), &tmp
, NULL
) ? 0 : -1;
703 INIT_SSC( GPCMD_REPORT_KEY
, 8 );
705 ssc
.CDBByte
[ 10 ] = DVD_REPORT_AGID
| (*pi_agid
<< 6);
707 i_ret
= WinSendSSC( i_fd
, &ssc
);
709 *pi_agid
= p_buffer
[ 7 ] >> 6;
712 #elif defined( __QNXNTO__ )
714 INIT_CPT( GPCMD_REPORT_KEY
, 8 );
716 p_cpt
->cam_cdb
[ 10 ] = DVD_REPORT_AGID
| (*pi_agid
<< 6);
718 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
720 *pi_agid
= p_buffer
[ 7 ] >> 6;
722 #elif defined( SYS_OS2 )
723 INIT_SSC( GPCMD_REPORT_KEY
, 8 );
725 sdc
.command
[ 10 ] = DVD_REPORT_AGID
| (*pi_agid
<< 6);
727 i_ret
= DosDevIOCtl(i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
728 &sdc
, sizeof(sdc
), &ulParamLen
,
729 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
731 *pi_agid
= p_buffer
[ 7 ] >> 6;
734 # error "DVD ioctls are unavailable on this system"
740 /*****************************************************************************
741 * ioctl_ReportChallenge: get challenge from the drive
742 *****************************************************************************/
743 int ioctl_ReportChallenge( int i_fd
, int *pi_agid
, uint8_t *p_challenge
)
747 #if defined( HAVE_LINUX_DVD_STRUCT )
748 dvd_authinfo auth_info
;
750 memset( &auth_info
, 0, sizeof( auth_info
) );
751 auth_info
.type
= DVD_LU_SEND_CHALLENGE
;
752 auth_info
.lsc
.agid
= *pi_agid
;
754 i_ret
= ioctl( i_fd
, DVD_AUTH
, &auth_info
);
756 memcpy( p_challenge
, auth_info
.lsc
.chal
, DVD_CHALLENGE_SIZE
);
758 #elif defined( HAVE_BSD_DVD_STRUCT )
759 struct dvd_authinfo auth_info
;
761 memset( &auth_info
, 0, sizeof( auth_info
) );
762 auth_info
.format
= DVD_REPORT_CHALLENGE
;
763 auth_info
.agid
= *pi_agid
;
765 i_ret
= ioctl( i_fd
, DVDIOCREPORTKEY
, &auth_info
);
767 memcpy( p_challenge
, auth_info
.keychal
, DVD_CHALLENGE_SIZE
);
769 #elif defined( SYS_BEOS )
770 INIT_RDC( GPCMD_REPORT_KEY
, 16 );
772 rdc
.command
[ 10 ] = DVD_REPORT_CHALLENGE
| (*pi_agid
<< 6);
774 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
776 memcpy( p_challenge
, p_buffer
+ 4, DVD_CHALLENGE_SIZE
);
778 #elif defined( HPUX_SCTL_IO )
779 INIT_SCTL_IO( GPCMD_REPORT_KEY
, 16 );
781 sctl_io
.cdb
[ 10 ] = DVD_REPORT_CHALLENGE
| (*pi_agid
<< 6);
783 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
785 memcpy( p_challenge
, p_buffer
+ 4, DVD_CHALLENGE_SIZE
);
787 #elif defined( SOLARIS_USCSI )
788 INIT_USCSI( GPCMD_REPORT_KEY
, 16 );
790 rs_cdb
.cdb_opaque
[ 10 ] = DVD_REPORT_CHALLENGE
| (*pi_agid
<< 6);
792 i_ret
= SolarisSendUSCSI( i_fd
, &sc
);
794 if( i_ret
< 0 || sc
.uscsi_status
)
799 memcpy( p_challenge
, p_buffer
+ 4, DVD_CHALLENGE_SIZE
);
801 #elif defined( DARWIN_DVD_IOCTL )
802 INIT_DVDIOCTL( dk_dvd_report_key_t
, DVDChallengeKeyInfo
,
803 kDVDKeyFormatChallengeKey
);
805 dvd
.grantID
= *pi_agid
;
807 i_ret
= ioctl( i_fd
, DKIOCDVDREPORTKEY
, &dvd
);
809 memcpy( p_challenge
, dvdbs
.challengeKeyValue
, DVD_CHALLENGE_SIZE
);
811 #elif defined( WIN32 )
812 if( WIN2K
) /* NT/2k/XP */
815 uint8_t buffer
[DVD_CHALLENGE_KEY_LENGTH
];
816 PDVD_COPY_PROTECT_KEY key
= (PDVD_COPY_PROTECT_KEY
) &buffer
;
818 memset( &buffer
, 0, sizeof( buffer
) );
820 key
->KeyLength
= DVD_CHALLENGE_KEY_LENGTH
;
821 key
->SessionId
= *pi_agid
;
822 key
->KeyType
= DvdChallengeKey
;
825 i_ret
= DeviceIoControl( (HANDLE
) i_fd
, IOCTL_DVD_READ_KEY
, key
,
826 key
->KeyLength
, key
, key
->KeyLength
, &tmp
, NULL
) ? 0 : -1;
833 memcpy( p_challenge
, key
->KeyData
, DVD_CHALLENGE_SIZE
);
837 INIT_SSC( GPCMD_REPORT_KEY
, 16 );
839 ssc
.CDBByte
[ 10 ] = DVD_REPORT_CHALLENGE
| (*pi_agid
<< 6);
841 i_ret
= WinSendSSC( i_fd
, &ssc
);
843 memcpy( p_challenge
, p_buffer
+ 4, DVD_CHALLENGE_SIZE
);
846 #elif defined( __QNXNTO__ )
848 INIT_CPT( GPCMD_REPORT_KEY
, 16 );
850 p_cpt
->cam_cdb
[ 10 ] = DVD_REPORT_CHALLENGE
| (*pi_agid
<< 6);
852 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
854 memcpy( p_challenge
, p_buffer
+ 4, DVD_CHALLENGE_SIZE
);
856 #elif defined( SYS_OS2 )
857 INIT_SSC( GPCMD_REPORT_KEY
, 16 );
859 sdc
.command
[ 10 ] = DVD_REPORT_CHALLENGE
| (*pi_agid
<< 6);
861 i_ret
= DosDevIOCtl(i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
862 &sdc
, sizeof(sdc
), &ulParamLen
,
863 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
865 memcpy( p_challenge
, p_buffer
+ 4, DVD_CHALLENGE_SIZE
);
868 # error "DVD ioctls are unavailable on this system"
874 /*****************************************************************************
875 * ioctl_ReportASF: get ASF from the drive
876 *****************************************************************************/
877 int ioctl_ReportASF( int i_fd
, int *pi_remove_me
, int *pi_asf
)
881 #if defined( HAVE_LINUX_DVD_STRUCT )
882 dvd_authinfo auth_info
;
884 memset( &auth_info
, 0, sizeof( auth_info
) );
885 auth_info
.type
= DVD_LU_SEND_ASF
;
886 auth_info
.lsasf
.asf
= *pi_asf
;
888 i_ret
= ioctl( i_fd
, DVD_AUTH
, &auth_info
);
890 *pi_asf
= auth_info
.lsasf
.asf
;
892 #elif defined( HAVE_BSD_DVD_STRUCT )
893 struct dvd_authinfo auth_info
;
895 memset( &auth_info
, 0, sizeof( auth_info
) );
896 auth_info
.format
= DVD_REPORT_ASF
;
897 auth_info
.asf
= *pi_asf
;
899 i_ret
= ioctl( i_fd
, DVDIOCREPORTKEY
, &auth_info
);
901 *pi_asf
= auth_info
.asf
;
903 #elif defined( SYS_BEOS )
904 INIT_RDC( GPCMD_REPORT_KEY
, 8 );
906 rdc
.command
[ 10 ] = DVD_REPORT_ASF
;
908 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
910 *pi_asf
= p_buffer
[ 7 ] & 1;
912 #elif defined( HPUX_SCTL_IO )
913 INIT_SCTL_IO( GPCMD_REPORT_KEY
, 8 );
915 sctl_io
.cdb
[ 10 ] = DVD_REPORT_ASF
;
917 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
919 *pi_asf
= p_buffer
[ 7 ] & 1;
921 #elif defined( SOLARIS_USCSI )
922 INIT_USCSI( GPCMD_REPORT_KEY
, 8 );
924 rs_cdb
.cdb_opaque
[ 10 ] = DVD_REPORT_ASF
;
926 i_ret
= SolarisSendUSCSI( i_fd
, &sc
);
928 if( i_ret
< 0 || sc
.uscsi_status
)
933 *pi_asf
= p_buffer
[ 7 ] & 1;
935 #elif defined( DARWIN_DVD_IOCTL )
936 INIT_DVDIOCTL( dk_dvd_report_key_t
, DVDAuthenticationSuccessFlagInfo
,
939 i_ret
= ioctl( i_fd
, DKIOCDVDREPORTKEY
, &dvd
);
941 *pi_asf
= dvdbs
.successFlag
;
943 #elif defined( WIN32 )
944 if( WIN2K
) /* NT/2k/XP */
947 uint8_t buffer
[DVD_ASF_LENGTH
];
948 PDVD_COPY_PROTECT_KEY key
= (PDVD_COPY_PROTECT_KEY
) &buffer
;
950 memset( &buffer
, 0, sizeof( buffer
) );
952 key
->KeyLength
= DVD_ASF_LENGTH
;
953 key
->KeyType
= DvdAsf
;
956 ((PDVD_ASF
)key
->KeyData
)->SuccessFlag
= *pi_asf
;
958 i_ret
= DeviceIoControl( (HANDLE
) i_fd
, IOCTL_DVD_READ_KEY
, key
,
959 key
->KeyLength
, key
, key
->KeyLength
, &tmp
, NULL
) ? 0 : -1;
966 *pi_asf
= ((PDVD_ASF
)key
->KeyData
)->SuccessFlag
;
970 INIT_SSC( GPCMD_REPORT_KEY
, 8 );
972 ssc
.CDBByte
[ 10 ] = DVD_REPORT_ASF
;
974 i_ret
= WinSendSSC( i_fd
, &ssc
);
976 *pi_asf
= p_buffer
[ 7 ] & 1;
979 #elif defined( __QNXNTO__ )
981 INIT_CPT( GPCMD_REPORT_KEY
, 8 );
983 p_cpt
->cam_cdb
[ 10 ] = DVD_REPORT_ASF
;
985 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
987 *pi_asf
= p_buffer
[ 7 ] & 1;
989 #elif defined( SYS_OS2 )
990 INIT_SSC( GPCMD_REPORT_KEY
, 8 );
992 sdc
.command
[ 10 ] = DVD_REPORT_ASF
;
994 i_ret
= DosDevIOCtl(i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
995 &sdc
, sizeof(sdc
), &ulParamLen
,
996 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
998 *pi_asf
= p_buffer
[ 7 ] & 1;
1001 # error "DVD ioctls are unavailable on this system"
1007 /*****************************************************************************
1008 * ioctl_ReportKey1: get the first key from the drive
1009 *****************************************************************************/
1010 int ioctl_ReportKey1( int i_fd
, int *pi_agid
, uint8_t *p_key
)
1014 #if defined( HAVE_LINUX_DVD_STRUCT )
1015 dvd_authinfo auth_info
;
1017 memset( &auth_info
, 0, sizeof( auth_info
) );
1018 auth_info
.type
= DVD_LU_SEND_KEY1
;
1019 auth_info
.lsk
.agid
= *pi_agid
;
1021 i_ret
= ioctl( i_fd
, DVD_AUTH
, &auth_info
);
1023 memcpy( p_key
, auth_info
.lsk
.key
, DVD_KEY_SIZE
);
1025 #elif defined( HAVE_BSD_DVD_STRUCT )
1026 struct dvd_authinfo auth_info
;
1028 memset( &auth_info
, 0, sizeof( auth_info
) );
1029 auth_info
.format
= DVD_REPORT_KEY1
;
1030 auth_info
.agid
= *pi_agid
;
1032 i_ret
= ioctl( i_fd
, DVDIOCREPORTKEY
, &auth_info
);
1034 memcpy( p_key
, auth_info
.keychal
, DVD_KEY_SIZE
);
1036 #elif defined( SYS_BEOS )
1037 INIT_RDC( GPCMD_REPORT_KEY
, 12 );
1039 rdc
.command
[ 10 ] = DVD_REPORT_KEY1
| (*pi_agid
<< 6);
1041 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
1043 memcpy( p_key
, p_buffer
+ 4, DVD_KEY_SIZE
);
1045 #elif defined( HPUX_SCTL_IO )
1046 INIT_SCTL_IO( GPCMD_REPORT_KEY
, 12 );
1048 sctl_io
.cdb
[ 10 ] = DVD_REPORT_KEY1
| (*pi_agid
<< 6);
1050 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
1052 memcpy( p_key
, p_buffer
+ 4, DVD_KEY_SIZE
);
1054 #elif defined( SOLARIS_USCSI )
1055 INIT_USCSI( GPCMD_REPORT_KEY
, 12 );
1057 rs_cdb
.cdb_opaque
[ 10 ] = DVD_REPORT_KEY1
| (*pi_agid
<< 6);
1059 i_ret
= SolarisSendUSCSI( i_fd
, &sc
);
1061 if( i_ret
< 0 || sc
.uscsi_status
)
1066 memcpy( p_key
, p_buffer
+ 4, DVD_KEY_SIZE
);
1068 #elif defined( DARWIN_DVD_IOCTL )
1069 INIT_DVDIOCTL( dk_dvd_report_key_t
, DVDKey1Info
,
1070 kDVDKeyFormatKey1
);
1072 dvd
.grantID
= *pi_agid
;
1074 i_ret
= ioctl( i_fd
, DKIOCDVDREPORTKEY
, &dvd
);
1076 memcpy( p_key
, dvdbs
.key1Value
, DVD_KEY_SIZE
);
1078 #elif defined( WIN32 )
1079 if( WIN2K
) /* NT/2k/XP */
1082 uint8_t buffer
[DVD_BUS_KEY_LENGTH
];
1083 PDVD_COPY_PROTECT_KEY key
= (PDVD_COPY_PROTECT_KEY
) &buffer
;
1085 memset( &buffer
, 0, sizeof( buffer
) );
1087 key
->KeyLength
= DVD_BUS_KEY_LENGTH
;
1088 key
->SessionId
= *pi_agid
;
1089 key
->KeyType
= DvdBusKey1
;
1092 i_ret
= DeviceIoControl( (HANDLE
) i_fd
, IOCTL_DVD_READ_KEY
, key
,
1093 key
->KeyLength
, key
, key
->KeyLength
, &tmp
, NULL
) ? 0 : -1;
1095 memcpy( p_key
, key
->KeyData
, DVD_KEY_SIZE
);
1099 INIT_SSC( GPCMD_REPORT_KEY
, 12 );
1101 ssc
.CDBByte
[ 10 ] = DVD_REPORT_KEY1
| (*pi_agid
<< 6);
1103 i_ret
= WinSendSSC( i_fd
, &ssc
);
1105 memcpy( p_key
, p_buffer
+ 4, DVD_KEY_SIZE
);
1108 #elif defined( __QNXNTO__ )
1110 INIT_CPT( GPCMD_REPORT_KEY
, 12 );
1112 p_cpt
->cam_cdb
[ 10 ] = DVD_REPORT_KEY1
| (*pi_agid
<< 6);
1114 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
1116 memcpy( p_key
, p_buffer
+ 4, DVD_KEY_SIZE
);
1118 #elif defined( SYS_OS2 )
1119 INIT_SSC( GPCMD_REPORT_KEY
, 12 );
1121 sdc
.command
[ 10 ] = DVD_REPORT_KEY1
| (*pi_agid
<< 6);
1123 i_ret
= DosDevIOCtl(i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
1124 &sdc
, sizeof(sdc
), &ulParamLen
,
1125 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
1127 memcpy( p_key
, p_buffer
+ 4, DVD_KEY_SIZE
);
1130 # error "DVD ioctls are unavailable on this system"
1136 /*****************************************************************************
1137 * ioctl_InvalidateAgid: invalidate the current AGID
1138 *****************************************************************************/
1139 int ioctl_InvalidateAgid( int i_fd
, int *pi_agid
)
1143 #if defined( HAVE_LINUX_DVD_STRUCT )
1144 dvd_authinfo auth_info
;
1146 memset( &auth_info
, 0, sizeof( auth_info
) );
1147 auth_info
.type
= DVD_INVALIDATE_AGID
;
1148 auth_info
.lsa
.agid
= *pi_agid
;
1150 i_ret
= ioctl( i_fd
, DVD_AUTH
, &auth_info
);
1152 #elif defined( HAVE_BSD_DVD_STRUCT )
1153 struct dvd_authinfo auth_info
;
1155 memset( &auth_info
, 0, sizeof( auth_info
) );
1156 auth_info
.format
= DVD_INVALIDATE_AGID
;
1157 auth_info
.agid
= *pi_agid
;
1159 i_ret
= ioctl( i_fd
, DVDIOCREPORTKEY
, &auth_info
);
1161 #elif defined( SYS_BEOS )
1162 INIT_RDC( GPCMD_REPORT_KEY
, 0 );
1164 rdc
.command
[ 10 ] = DVD_INVALIDATE_AGID
| (*pi_agid
<< 6);
1166 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
1168 #elif defined( HPUX_SCTL_IO )
1169 INIT_SCTL_IO( GPCMD_REPORT_KEY
, 0 );
1171 sctl_io
.cdb
[ 10 ] = DVD_INVALIDATE_AGID
| (*pi_agid
<< 6);
1173 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
1175 #elif defined( SOLARIS_USCSI )
1176 INIT_USCSI( GPCMD_REPORT_KEY
, 0 );
1178 rs_cdb
.cdb_opaque
[ 10 ] = DVD_INVALIDATE_AGID
| (*pi_agid
<< 6);
1180 i_ret
= SolarisSendUSCSI( i_fd
, &sc
);
1182 if( i_ret
< 0 || sc
.uscsi_status
)
1187 #elif defined( DARWIN_DVD_IOCTL )
1188 INIT_DVDIOCTL( dk_dvd_send_key_t
, DVDAuthenticationGrantIDInfo
,
1189 kDVDKeyFormatAGID_Invalidate
);
1191 dvd
.grantID
= *pi_agid
;
1193 i_ret
= ioctl( i_fd
, DKIOCDVDSENDKEY
, &dvd
);
1195 #elif defined( WIN32 )
1196 if( WIN2K
) /* NT/2k/XP */
1200 i_ret
= DeviceIoControl( (HANDLE
) i_fd
, IOCTL_DVD_END_SESSION
,
1201 pi_agid
, sizeof( *pi_agid
), NULL
, 0, &tmp
, NULL
) ? 0 : -1;
1205 #if defined( __MINGW32__ )
1206 INIT_SSC( GPCMD_REPORT_KEY
, 0 );
1208 INIT_SSC( GPCMD_REPORT_KEY
, 1 );
1211 ssc
.CDBByte
[ 8 ] = 0;
1212 ssc
.CDBByte
[ 9 ] = 0;
1215 ssc
.CDBByte
[ 10 ] = DVD_INVALIDATE_AGID
| (*pi_agid
<< 6);
1217 i_ret
= WinSendSSC( i_fd
, &ssc
);
1220 #elif defined( __QNXNTO__ )
1222 INIT_CPT( GPCMD_REPORT_KEY
, 0 );
1224 p_cpt
->cam_cdb
[ 10 ] = DVD_INVALIDATE_AGID
| (*pi_agid
<< 6);
1226 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
1228 #elif defined( SYS_OS2 )
1229 INIT_SSC( GPCMD_REPORT_KEY
, 1 );
1231 sdc
.data_length
= 0;
1232 sdc
.command
[ 8 ] = 0;
1233 sdc
.command
[ 9 ] = 0;
1235 sdc
.command
[ 10 ] = DVD_INVALIDATE_AGID
| (*pi_agid
<< 6);
1237 i_ret
= DosDevIOCtl(i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
1238 &sdc
, sizeof(sdc
), &ulParamLen
,
1239 NULL
, 0, &ulDataLen
);
1241 # error "DVD ioctls are unavailable on this system"
1247 /*****************************************************************************
1248 * ioctl_SendChallenge: send challenge to the drive
1249 *****************************************************************************/
1250 int ioctl_SendChallenge( int i_fd
, int *pi_agid
, uint8_t *p_challenge
)
1254 #if defined( HAVE_LINUX_DVD_STRUCT )
1255 dvd_authinfo auth_info
;
1257 memset( &auth_info
, 0, sizeof( auth_info
) );
1258 auth_info
.type
= DVD_HOST_SEND_CHALLENGE
;
1259 auth_info
.hsc
.agid
= *pi_agid
;
1261 memcpy( auth_info
.hsc
.chal
, p_challenge
, DVD_CHALLENGE_SIZE
);
1263 i_ret
= ioctl( i_fd
, DVD_AUTH
, &auth_info
);
1265 #elif defined( HAVE_BSD_DVD_STRUCT )
1266 struct dvd_authinfo auth_info
;
1268 memset( &auth_info
, 0, sizeof( auth_info
) );
1269 auth_info
.format
= DVD_SEND_CHALLENGE
;
1270 auth_info
.agid
= *pi_agid
;
1272 memcpy( auth_info
.keychal
, p_challenge
, DVD_CHALLENGE_SIZE
);
1274 i_ret
= ioctl( i_fd
, DVDIOCSENDKEY
, &auth_info
);
1276 #elif defined( SYS_BEOS )
1277 INIT_RDC( GPCMD_SEND_KEY
, 16 );
1279 rdc
.command
[ 10 ] = DVD_SEND_CHALLENGE
| (*pi_agid
<< 6);
1281 p_buffer
[ 1 ] = 0xe;
1282 memcpy( p_buffer
+ 4, p_challenge
, DVD_CHALLENGE_SIZE
);
1284 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
1286 #elif defined( HPUX_SCTL_IO )
1287 INIT_SCTL_IO( GPCMD_SEND_KEY
, 16 );
1289 sctl_io
.cdb
[ 10 ] = DVD_SEND_CHALLENGE
| (*pi_agid
<< 6);
1291 p_buffer
[ 1 ] = 0xe;
1292 memcpy( p_buffer
+ 4, p_challenge
, DVD_CHALLENGE_SIZE
);
1294 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
1296 #elif defined( SOLARIS_USCSI )
1297 INIT_USCSI( GPCMD_SEND_KEY
, 16 );
1299 rs_cdb
.cdb_opaque
[ 10 ] = DVD_SEND_CHALLENGE
| (*pi_agid
<< 6);
1301 p_buffer
[ 1 ] = 0xe;
1302 memcpy( p_buffer
+ 4, p_challenge
, DVD_CHALLENGE_SIZE
);
1304 if( SolarisSendUSCSI( i_fd
, &sc
) < 0 || sc
.uscsi_status
)
1311 #elif defined( DARWIN_DVD_IOCTL )
1312 INIT_DVDIOCTL( dk_dvd_send_key_t
, DVDChallengeKeyInfo
,
1313 kDVDKeyFormatChallengeKey
);
1315 dvd
.grantID
= *pi_agid
;
1316 dvd
.keyClass
= kDVDKeyClassCSS_CPPM_CPRM
;
1318 dvdbs
.dataLength
[ 1 ] = 0xe;
1319 memcpy( dvdbs
.challengeKeyValue
, p_challenge
, DVD_CHALLENGE_SIZE
);
1321 i_ret
= ioctl( i_fd
, DKIOCDVDSENDKEY
, &dvd
);
1323 #elif defined( WIN32 )
1324 if( WIN2K
) /* NT/2k/XP */
1327 uint8_t buffer
[DVD_CHALLENGE_KEY_LENGTH
];
1328 PDVD_COPY_PROTECT_KEY key
= (PDVD_COPY_PROTECT_KEY
) &buffer
;
1330 memset( &buffer
, 0, sizeof( buffer
) );
1332 key
->KeyLength
= DVD_CHALLENGE_KEY_LENGTH
;
1333 key
->SessionId
= *pi_agid
;
1334 key
->KeyType
= DvdChallengeKey
;
1337 memcpy( key
->KeyData
, p_challenge
, DVD_CHALLENGE_SIZE
);
1339 i_ret
= DeviceIoControl( (HANDLE
) i_fd
, IOCTL_DVD_SEND_KEY
, key
,
1340 key
->KeyLength
, key
, key
->KeyLength
, &tmp
, NULL
) ? 0 : -1;
1344 INIT_SSC( GPCMD_SEND_KEY
, 16 );
1346 ssc
.CDBByte
[ 10 ] = DVD_SEND_CHALLENGE
| (*pi_agid
<< 6);
1348 p_buffer
[ 1 ] = 0xe;
1349 memcpy( p_buffer
+ 4, p_challenge
, DVD_CHALLENGE_SIZE
);
1351 i_ret
= WinSendSSC( i_fd
, &ssc
);
1354 #elif defined( __QNXNTO__ )
1356 INIT_CPT( GPCMD_SEND_KEY
, 16 );
1358 p_cpt
->cam_cdb
[ 10 ] = DVD_SEND_CHALLENGE
| (*pi_agid
<< 6);
1360 p_buffer
[ 1 ] = 0xe;
1361 memcpy( p_buffer
+ 4, p_challenge
, DVD_CHALLENGE_SIZE
);
1363 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
1365 #elif defined( SYS_OS2 )
1366 INIT_SSC( GPCMD_SEND_KEY
, 16 );
1368 sdc
.command
[ 10 ] = DVD_SEND_CHALLENGE
| (*pi_agid
<< 6);
1370 p_buffer
[ 1 ] = 0xe;
1371 memcpy( p_buffer
+ 4, p_challenge
, DVD_CHALLENGE_SIZE
);
1373 i_ret
= DosDevIOCtl( i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
1374 &sdc
, sizeof(sdc
), &ulParamLen
,
1375 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
1378 # error "DVD ioctls are unavailable on this system"
1384 /*****************************************************************************
1385 * ioctl_SendKey2: send the second key to the drive
1386 *****************************************************************************/
1387 int ioctl_SendKey2( int i_fd
, int *pi_agid
, uint8_t *p_key
)
1391 #if defined( HAVE_LINUX_DVD_STRUCT )
1392 dvd_authinfo auth_info
;
1394 memset( &auth_info
, 0, sizeof( auth_info
) );
1395 auth_info
.type
= DVD_HOST_SEND_KEY2
;
1396 auth_info
.hsk
.agid
= *pi_agid
;
1398 memcpy( auth_info
.hsk
.key
, p_key
, DVD_KEY_SIZE
);
1400 i_ret
= ioctl( i_fd
, DVD_AUTH
, &auth_info
);
1402 #elif defined( HAVE_BSD_DVD_STRUCT )
1403 struct dvd_authinfo auth_info
;
1405 memset( &auth_info
, 0, sizeof( auth_info
) );
1406 auth_info
.format
= DVD_SEND_KEY2
;
1407 auth_info
.agid
= *pi_agid
;
1409 memcpy( auth_info
.keychal
, p_key
, DVD_KEY_SIZE
);
1411 i_ret
= ioctl( i_fd
, DVDIOCSENDKEY
, &auth_info
);
1413 #elif defined( SYS_BEOS )
1414 INIT_RDC( GPCMD_SEND_KEY
, 12 );
1416 rdc
.command
[ 10 ] = DVD_SEND_KEY2
| (*pi_agid
<< 6);
1418 p_buffer
[ 1 ] = 0xa;
1419 memcpy( p_buffer
+ 4, p_key
, DVD_KEY_SIZE
);
1421 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
1423 #elif defined( HPUX_SCTL_IO )
1424 INIT_SCTL_IO( GPCMD_SEND_KEY
, 12 );
1426 sctl_io
.cdb
[ 10 ] = DVD_SEND_KEY2
| (*pi_agid
<< 6);
1428 p_buffer
[ 1 ] = 0xa;
1429 memcpy( p_buffer
+ 4, p_key
, DVD_KEY_SIZE
);
1431 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
1433 #elif defined( SOLARIS_USCSI )
1434 INIT_USCSI( GPCMD_SEND_KEY
, 12 );
1436 rs_cdb
.cdb_opaque
[ 10 ] = DVD_SEND_KEY2
| (*pi_agid
<< 6);
1438 p_buffer
[ 1 ] = 0xa;
1439 memcpy( p_buffer
+ 4, p_key
, DVD_KEY_SIZE
);
1441 if( SolarisSendUSCSI( i_fd
, &sc
) < 0 || sc
.uscsi_status
)
1448 #elif defined( DARWIN_DVD_IOCTL )
1449 INIT_DVDIOCTL( dk_dvd_send_key_t
, DVDKey2Info
,
1450 kDVDKeyFormatKey2
);
1452 dvd
.grantID
= *pi_agid
;
1453 dvd
.keyClass
= kDVDKeyClassCSS_CPPM_CPRM
;
1455 dvdbs
.dataLength
[ 1 ] = 0xa;
1456 memcpy( dvdbs
.key2Value
, p_key
, DVD_KEY_SIZE
);
1458 i_ret
= ioctl( i_fd
, DKIOCDVDSENDKEY
, &dvd
);
1460 #elif defined( WIN32 )
1461 if( WIN2K
) /* NT/2k/XP */
1464 uint8_t buffer
[DVD_BUS_KEY_LENGTH
];
1465 PDVD_COPY_PROTECT_KEY key
= (PDVD_COPY_PROTECT_KEY
) &buffer
;
1467 memset( &buffer
, 0, sizeof( buffer
) );
1469 key
->KeyLength
= DVD_BUS_KEY_LENGTH
;
1470 key
->SessionId
= *pi_agid
;
1471 key
->KeyType
= DvdBusKey2
;
1474 memcpy( key
->KeyData
, p_key
, DVD_KEY_SIZE
);
1476 i_ret
= DeviceIoControl( (HANDLE
) i_fd
, IOCTL_DVD_SEND_KEY
, key
,
1477 key
->KeyLength
, key
, key
->KeyLength
, &tmp
, NULL
) ? 0 : -1;
1481 INIT_SSC( GPCMD_SEND_KEY
, 12 );
1483 ssc
.CDBByte
[ 10 ] = DVD_SEND_KEY2
| (*pi_agid
<< 6);
1485 p_buffer
[ 1 ] = 0xa;
1486 memcpy( p_buffer
+ 4, p_key
, DVD_KEY_SIZE
);
1488 i_ret
= WinSendSSC( i_fd
, &ssc
);
1491 #elif defined( __QNXNTO__ )
1493 INIT_CPT( GPCMD_SEND_KEY
, 12 );
1495 p_cpt
->cam_cdb
[ 10 ] = DVD_SEND_KEY2
| (*pi_agid
<< 6);
1497 p_buffer
[ 1 ] = 0xa;
1498 memcpy( p_buffer
+ 4, p_key
, DVD_KEY_SIZE
);
1500 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
1502 #elif defined( SYS_OS2 )
1503 INIT_SSC( GPCMD_SEND_KEY
, 12 );
1505 sdc
.command
[ 10 ] = DVD_SEND_KEY2
| (*pi_agid
<< 6);
1507 p_buffer
[ 1 ] = 0xa;
1508 memcpy( p_buffer
+ 4, p_key
, DVD_KEY_SIZE
);
1510 i_ret
= DosDevIOCtl( i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
1511 &sdc
, sizeof(sdc
), &ulParamLen
,
1512 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
1515 # error "DVD ioctls are unavailable on this system"
1521 /*****************************************************************************
1522 * ioctl_ReportRPC: get RPC status for the drive
1523 *****************************************************************************/
1524 int ioctl_ReportRPC( int i_fd
, int *p_type
, int *p_mask
, int *p_scheme
)
1528 #if defined( HAVE_LINUX_DVD_STRUCT ) && defined( DVD_LU_SEND_RPC_STATE )
1529 dvd_authinfo auth_info
;
1531 memset( &auth_info
, 0, sizeof( auth_info
) );
1532 auth_info
.type
= DVD_LU_SEND_RPC_STATE
;
1534 i_ret
= ioctl( i_fd
, DVD_AUTH
, &auth_info
);
1536 *p_type
= auth_info
.lrpcs
.type
;
1537 *p_mask
= auth_info
.lrpcs
.region_mask
;
1538 *p_scheme
= auth_info
.lrpcs
.rpc_scheme
;
1540 #elif defined( HAVE_LINUX_DVD_STRUCT )
1541 /* FIXME: OpenBSD doesn't know this */
1544 #elif defined( HAVE_BSD_DVD_STRUCT )
1545 struct dvd_authinfo auth_info
;
1547 memset( &auth_info
, 0, sizeof( auth_info
) );
1548 auth_info
.format
= DVD_REPORT_RPC
;
1550 i_ret
= ioctl( i_fd
, DVDIOCREPORTKEY
, &auth_info
);
1552 *p_type
= auth_info
.reg_type
;
1553 *p_mask
= auth_info
.region
; // ??
1554 *p_scheme
= auth_info
.rpc_scheme
;
1556 #elif defined( SYS_BEOS )
1557 INIT_RDC( GPCMD_REPORT_KEY
, 8 );
1559 rdc
.command
[ 10 ] = DVD_REPORT_RPC
;
1561 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
1563 *p_type
= p_buffer
[ 4 ] >> 6;
1564 *p_mask
= p_buffer
[ 5 ];
1565 *p_scheme
= p_buffer
[ 6 ];
1567 #elif defined( HPUX_SCTL_IO )
1568 INIT_SCTL_IO( GPCMD_REPORT_KEY
, 8 );
1570 sctl_io
.cdb
[ 10 ] = DVD_REPORT_RPC
;
1572 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
1574 *p_type
= p_buffer
[ 4 ] >> 6;
1575 *p_mask
= p_buffer
[ 5 ];
1576 *p_scheme
= p_buffer
[ 6 ];
1578 #elif defined( SOLARIS_USCSI )
1579 INIT_USCSI( GPCMD_REPORT_KEY
, 8 );
1581 rs_cdb
.cdb_opaque
[ 10 ] = DVD_REPORT_RPC
;
1583 i_ret
= SolarisSendUSCSI( i_fd
, &sc
);
1585 if( i_ret
< 0 || sc
.uscsi_status
)
1590 *p_type
= p_buffer
[ 4 ] >> 6;
1591 *p_mask
= p_buffer
[ 5 ];
1592 *p_scheme
= p_buffer
[ 6 ];
1594 #elif defined( DARWIN_DVD_IOCTL )
1595 INIT_DVDIOCTL( dk_dvd_report_key_t
, DVDRegionPlaybackControlInfo
,
1596 kDVDKeyFormatRegionState
);
1598 dvd
.keyClass
= kDVDKeyClassCSS_CPPM_CPRM
;
1600 i_ret
= ioctl( i_fd
, DKIOCDVDREPORTKEY
, &dvd
);
1602 *p_type
= dvdbs
.typeCode
;
1603 *p_mask
= dvdbs
.driveRegion
;
1604 *p_scheme
= dvdbs
.rpcScheme
;
1606 #elif defined( WIN32 )
1607 if( WIN2K
) /* NT/2k/XP */
1610 uint8_t buffer
[DVD_RPC_KEY_LENGTH
];
1611 PDVD_COPY_PROTECT_KEY key
= (PDVD_COPY_PROTECT_KEY
) &buffer
;
1613 memset( &buffer
, 0, sizeof( buffer
) );
1615 key
->KeyLength
= DVD_RPC_KEY_LENGTH
;
1616 key
->KeyType
= DvdGetRpcKey
;
1619 i_ret
= DeviceIoControl( (HANDLE
) i_fd
, IOCTL_DVD_READ_KEY
, key
,
1620 key
->KeyLength
, key
, key
->KeyLength
, &tmp
, NULL
) ? 0 : -1;
1627 *p_type
= ((PDVD_RPC_KEY
)key
->KeyData
)->TypeCode
;
1628 *p_mask
= ((PDVD_RPC_KEY
)key
->KeyData
)->RegionMask
;
1629 *p_scheme
= ((PDVD_RPC_KEY
)key
->KeyData
)->RpcScheme
;
1633 INIT_SSC( GPCMD_REPORT_KEY
, 8 );
1635 ssc
.CDBByte
[ 10 ] = DVD_REPORT_RPC
;
1637 i_ret
= WinSendSSC( i_fd
, &ssc
);
1639 *p_type
= p_buffer
[ 4 ] >> 6;
1640 *p_mask
= p_buffer
[ 5 ];
1641 *p_scheme
= p_buffer
[ 6 ];
1644 #elif defined( __QNXNTO__ )
1646 INIT_CPT( GPCMD_REPORT_KEY
, 8 );
1648 p_cpt
->cam_cdb
[ 10 ] = DVD_REPORT_RPC
;
1650 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
1652 *p_type
= p_buffer
[ 4 ] >> 6;
1653 *p_mask
= p_buffer
[ 5 ];
1654 *p_scheme
= p_buffer
[ 6 ];
1656 #elif defined( SYS_OS2 )
1657 INIT_SSC( GPCMD_REPORT_KEY
, 8 );
1659 sdc
.command
[ 10 ] = DVD_REPORT_RPC
;
1661 i_ret
= DosDevIOCtl(i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
1662 &sdc
, sizeof(sdc
), &ulParamLen
,
1663 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
1665 *p_type
= p_buffer
[ 4 ] >> 6;
1666 *p_mask
= p_buffer
[ 5 ];
1667 *p_scheme
= p_buffer
[ 6 ];
1670 # error "DVD ioctls are unavailable on this system"
1676 /*****************************************************************************
1677 * ioctl_SendRPC: set RPC status for the drive
1678 *****************************************************************************/
1679 int ioctl_SendRPC( int i_fd
, int i_pdrc
)
1683 #if defined( HAVE_LINUX_DVD_STRUCT ) && defined( DVD_HOST_SEND_RPC_STATE )
1684 dvd_authinfo auth_info
;
1686 memset( &auth_info
, 0, sizeof( auth_info
) );
1687 auth_info
.type
= DVD_HOST_SEND_RPC_STATE
;
1688 auth_info
.hrpcs
.pdrc
= i_pdrc
;
1690 i_ret
= ioctl( i_fd
, DVD_AUTH
, &auth_info
);
1692 #elif defined( HAVE_LINUX_DVD_STRUCT )
1693 /* FIXME: OpenBSD doesn't know this */
1696 #elif defined( HAVE_BSD_DVD_STRUCT )
1697 struct dvd_authinfo auth_info
;
1699 memset( &auth_info
, 0, sizeof( auth_info
) );
1700 auth_info
.format
= DVD_SEND_RPC
;
1701 auth_info
.region
= i_pdrc
;
1703 i_ret
= ioctl( i_fd
, DVDIOCSENDKEY
, &auth_info
);
1705 #elif defined( SYS_BEOS )
1706 INIT_RDC( GPCMD_SEND_KEY
, 8 );
1708 rdc
.command
[ 10 ] = DVD_SEND_RPC
;
1711 p_buffer
[ 4 ] = i_pdrc
;
1713 i_ret
= ioctl( i_fd
, B_RAW_DEVICE_COMMAND
, &rdc
, sizeof(rdc
) );
1715 #elif defined( HPUX_SCTL_IO )
1716 INIT_SCTL_IO( GPCMD_SEND_KEY
, 8 );
1718 sctl_io
.cdb
[ 10 ] = DVD_SEND_RPC
;
1721 p_buffer
[ 4 ] = i_pdrc
;
1723 i_ret
= ioctl( i_fd
, SIOC_IO
, &sctl_io
);
1725 #elif defined( SOLARIS_USCSI )
1726 INIT_USCSI( GPCMD_SEND_KEY
, 8 );
1728 rs_cdb
.cdb_opaque
[ 10 ] = DVD_SEND_RPC
;
1731 p_buffer
[ 4 ] = i_pdrc
;
1733 i_ret
= SolarisSendUSCSI( i_fd
, &sc
);
1735 if( i_ret
< 0 || sc
.uscsi_status
)
1740 #elif defined( DARWIN_DVD_IOCTL )
1741 INIT_DVDIOCTL( dk_dvd_send_key_t
, DVDRegionPlaybackControlInfo
,
1742 kDVDKeyFormatSetRegion
);
1744 dvd
.keyClass
= kDVDKeyClassCSS_CPPM_CPRM
;
1745 dvdbs
.driveRegion
= i_pdrc
;
1747 i_ret
= ioctl( i_fd
, DKIOCDVDSENDKEY
, &dvd
);
1749 #elif defined( WIN32 )
1750 if( WIN2K
) /* NT/2k/XP */
1752 INIT_SPTD( GPCMD_SEND_KEY
, 8 );
1754 sptd
.Cdb
[ 10 ] = DVD_SEND_RPC
;
1757 p_buffer
[ 4 ] = i_pdrc
;
1759 i_ret
= SEND_SPTD( i_fd
, &sptd
, &tmp
);
1763 INIT_SSC( GPCMD_SEND_KEY
, 8 );
1765 ssc
.CDBByte
[ 10 ] = DVD_SEND_RPC
;
1768 p_buffer
[ 4 ] = i_pdrc
;
1770 i_ret
= WinSendSSC( i_fd
, &ssc
);
1773 #elif defined( __QNXNTO__ )
1775 INIT_CPT( GPCMD_SEND_KEY
, 8 );
1777 p_cpt
->cam_cdb
[ 10 ] = DVD_SEND_RPC
;
1780 p_buffer
[ 4 ] = i_pdrc
;
1782 i_ret
= devctl(i_fd
, DCMD_CAM_PASS_THRU
, p_cpt
, structSize
, NULL
);
1784 #elif defined( SYS_OS2 )
1785 INIT_SSC( GPCMD_SEND_KEY
, 8 );
1787 sdc
.command
[ 10 ] = DVD_SEND_RPC
;
1790 p_buffer
[ 4 ] = i_pdrc
;
1792 i_ret
= DosDevIOCtl( i_fd
, IOCTL_CDROMDISK
, CDROMDISK_EXECMD
,
1793 &sdc
, sizeof(sdc
), &ulParamLen
,
1794 p_buffer
, sizeof(p_buffer
), &ulDataLen
);
1797 # error "DVD ioctls are unavailable on this system"
1803 /* Local prototypes */
1805 #if defined( SYS_BEOS )
1806 /*****************************************************************************
1807 * BeInitRDC: initialize a RDC structure for the BeOS kernel
1808 *****************************************************************************
1809 * This function initializes a BeOS raw device command structure for future
1810 * use, either a read command or a write command.
1811 *****************************************************************************/
1812 static void BeInitRDC( raw_device_command
*p_rdc
, int i_type
)
1814 memset( p_rdc
->data
, 0, p_rdc
->data_length
);
1818 case GPCMD_SEND_KEY
:
1819 /* leave the flags to 0 */
1822 case GPCMD_READ_DVD_STRUCTURE
: case GPCMD_REPORT_KEY
:
1823 p_rdc
->flags
= B_RAW_DEVICE_DATA_IN
; break; }
1825 p_rdc
->command
[ 0 ] = i_type
;
1827 p_rdc
->command
[ 8 ] = (p_rdc
->data_length
>> 8) & 0xff;
1828 p_rdc
->command
[ 9 ] = p_rdc
->data_length
& 0xff;
1829 p_rdc
->command_length
= 12;
1831 p_rdc
->sense_data
= NULL
;
1832 p_rdc
->sense_data_length
= 0;
1834 p_rdc
->timeout
= 1000000;
1838 #if defined( HPUX_SCTL_IO )
1839 /*****************************************************************************
1840 * HPUXInitSCTL: initialize a sctl_io structure for the HP-UX kernel
1841 *****************************************************************************
1842 * This function initializes a HP-UX command structure for future
1843 * use, either a read command or a write command.
1844 *****************************************************************************/
1845 static void HPUXInitSCTL( struct sctl_io
*sctl_io
, int i_type
)
1847 memset( sctl_io
->data
, 0, sctl_io
->data_length
);
1851 case GPCMD_SEND_KEY
:
1852 /* leave the flags to 0 */
1855 case GPCMD_READ_DVD_STRUCTURE
:
1856 case GPCMD_REPORT_KEY
:
1857 sctl_io
->flags
= SCTL_READ
;
1861 sctl_io
->cdb
[ 0 ] = i_type
;
1863 sctl_io
->cdb
[ 8 ] = (sctl_io
->data_length
>> 8) & 0xff;
1864 sctl_io
->cdb
[ 9 ] = sctl_io
->data_length
& 0xff;
1865 sctl_io
->cdb_length
= 12;
1867 sctl_io
->max_msecs
= 1000000;
1871 #if defined( SOLARIS_USCSI )
1872 /*****************************************************************************
1873 * SolarisInitUSCSI: initialize a USCSICMD structure for the Solaris kernel
1874 *****************************************************************************
1875 * This function initializes a Solaris userspace scsi command structure for
1876 * future use, either a read command or a write command.
1877 *****************************************************************************/
1878 static void SolarisInitUSCSI( struct uscsi_cmd
*p_sc
, int i_type
)
1880 union scsi_cdb
*rs_cdb
;
1881 memset( p_sc
->uscsi_cdb
, 0, sizeof( union scsi_cdb
) );
1882 memset( p_sc
->uscsi_bufaddr
, 0, p_sc
->uscsi_buflen
);
1886 case GPCMD_SEND_KEY
:
1887 p_sc
->uscsi_flags
= USCSI_ISOLATE
| USCSI_WRITE
;
1890 case GPCMD_READ_DVD_STRUCTURE
:
1891 case GPCMD_REPORT_KEY
:
1892 p_sc
->uscsi_flags
= USCSI_ISOLATE
| USCSI_READ
;
1896 rs_cdb
= (union scsi_cdb
*)p_sc
->uscsi_cdb
;
1898 rs_cdb
->scc_cmd
= i_type
;
1900 rs_cdb
->cdb_opaque
[ 8 ] = (p_sc
->uscsi_buflen
>> 8) & 0xff;
1901 rs_cdb
->cdb_opaque
[ 9 ] = p_sc
->uscsi_buflen
& 0xff;
1902 p_sc
->uscsi_cdblen
= 12;
1904 USCSI_TIMEOUT( p_sc
, 15 );
1907 /*****************************************************************************
1908 * SolarisSendUSCSI: send a USCSICMD structure to the Solaris kernel
1910 *****************************************************************************
1911 * When available, this function uses the function smedia_uscsi_cmd()
1912 * from Solaris' libsmedia library (Solaris 9 or newer) to execute the
1913 * USCSI command. smedia_uscsi_cmd() allows USCSI commands for
1914 * non-root users on removable media devices on Solaris 9; sending the
1915 * USCSI command directly to the device using the USCSICMD ioctl fails
1916 * with an EPERM error on Solaris 9.
1918 * The code will fall back to the USCSICMD ioctl method, when
1919 * libsmedia.so is not available or does not export the
1920 * smedia_uscsi_cmd() function (on Solaris releases upto and including
1921 * Solaris 8). Fortunatelly, on these old releases non-root users are
1922 * allowed to perform USCSICMD ioctls on removable media devices.
1923 *****************************************************************************/
1924 static int SolarisSendUSCSI( int i_fd
, struct uscsi_cmd
*p_sc
)
1928 /* We use static variables to keep track of the libsmedia symbols, which
1929 * is harmless even in a multithreaded program because the library and
1930 * its symbols will always be mapped at the same address. */
1931 static int b_tried
= 0;
1932 static int b_have_sm
= 0;
1933 static void * (*p_get_handle
) ( int32_t );
1934 static int (*p_uscsi_cmd
) ( void *, struct uscsi_cmd
* );
1935 static int (*p_release_handle
) ( void * );
1941 p_lib
= dlopen( "libsmedia.so", RTLD_NOW
);
1944 p_get_handle
= dlsym( p_lib
, "smedia_get_handle" );
1945 p_uscsi_cmd
= dlsym( p_lib
, "smedia_uscsi_cmd" );
1946 p_release_handle
= dlsym( p_lib
, "smedia_release_handle" );
1948 if( p_get_handle
&& p_uscsi_cmd
&& p_release_handle
)
1961 if( b_have_sm
&& (p_handle
= p_get_handle(i_fd
)) )
1963 int i_ret
= p_uscsi_cmd( p_handle
, p_sc
);
1964 p_release_handle( p_handle
);
1968 return ioctl( i_fd
, USCSICMD
, p_sc
);
1972 #if defined( WIN32 )
1973 /*****************************************************************************
1974 * WinInitSPTD: initialize a sptd structure
1975 *****************************************************************************
1976 * This function initializes a SCSI pass through command structure for future
1977 * use, either a read command or a write command.
1978 *****************************************************************************/
1979 static void WinInitSPTD( SCSI_PASS_THROUGH_DIRECT
*p_sptd
, int i_type
)
1981 memset( p_sptd
->DataBuffer
, 0, p_sptd
->DataTransferLength
);
1985 case GPCMD_SEND_KEY
:
1986 p_sptd
->DataIn
= SCSI_IOCTL_DATA_OUT
;
1989 case GPCMD_READ_DVD_STRUCTURE
:
1990 case GPCMD_REPORT_KEY
:
1991 p_sptd
->DataIn
= SCSI_IOCTL_DATA_IN
;
1995 p_sptd
->Cdb
[ 0 ] = i_type
;
1996 p_sptd
->Cdb
[ 8 ] = (uint8_t)(p_sptd
->DataTransferLength
>> 8) & 0xff;
1997 p_sptd
->Cdb
[ 9 ] = (uint8_t) p_sptd
->DataTransferLength
& 0xff;
1998 p_sptd
->CdbLength
= 12;
2000 p_sptd
->TimeOutValue
= 2;
2003 /*****************************************************************************
2004 * WinInitSSC: initialize a ssc structure for the win32 aspi layer
2005 *****************************************************************************
2006 * This function initializes a ssc raw device command structure for future
2007 * use, either a read command or a write command.
2008 *****************************************************************************/
2009 static void WinInitSSC( struct SRB_ExecSCSICmd
*p_ssc
, int i_type
)
2011 memset( p_ssc
->SRB_BufPointer
, 0, p_ssc
->SRB_BufLen
);
2015 case GPCMD_SEND_KEY
:
2016 p_ssc
->SRB_Flags
= SRB_DIR_OUT
;
2019 case GPCMD_READ_DVD_STRUCTURE
:
2020 case GPCMD_REPORT_KEY
:
2021 p_ssc
->SRB_Flags
= SRB_DIR_IN
;
2025 p_ssc
->SRB_Cmd
= SC_EXEC_SCSI_CMD
;
2026 p_ssc
->SRB_Flags
|= SRB_EVENT_NOTIFY
;
2028 p_ssc
->CDBByte
[ 0 ] = i_type
;
2030 p_ssc
->CDBByte
[ 8 ] = (uint8_t)(p_ssc
->SRB_BufLen
>> 8) & 0xff;
2031 p_ssc
->CDBByte
[ 9 ] = (uint8_t) p_ssc
->SRB_BufLen
& 0xff;
2032 p_ssc
->SRB_CDBLen
= 12;
2034 p_ssc
->SRB_SenseLen
= SENSE_LEN
;
2037 /*****************************************************************************
2038 * WinSendSSC: send a ssc structure to the aspi layer
2039 *****************************************************************************/
2040 static int WinSendSSC( int i_fd
, struct SRB_ExecSCSICmd
*p_ssc
)
2042 HANDLE hEvent
= NULL
;
2043 struct w32_aspidev
*fd
= (struct w32_aspidev
*) i_fd
;
2045 hEvent
= CreateEvent( NULL
, TRUE
, FALSE
, NULL
);
2046 if( hEvent
== NULL
)
2051 p_ssc
->SRB_PostProc
= hEvent
;
2052 p_ssc
->SRB_HaId
= LOBYTE( fd
->i_sid
);
2053 p_ssc
->SRB_Target
= HIBYTE( fd
->i_sid
);
2055 ResetEvent( hEvent
);
2056 if( fd
->lpSendCommand( (void*) p_ssc
) == SS_PENDING
)
2057 WaitForSingleObject( hEvent
, INFINITE
);
2059 CloseHandle( hEvent
);
2061 return p_ssc
->SRB_Status
== SS_COMP
? 0 : -1;
2065 #if defined( __QNXNTO__ )
2066 /*****************************************************************************
2067 * QNXInitCPT: initialize a CPT structure for QNX Neutrino
2068 *****************************************************************************
2069 * This function initializes a cpt command structure for future use,
2070 * either a read command or a write command.
2071 *****************************************************************************/
2072 static void QNXInitCPT( CAM_PASS_THRU
* p_cpt
, int i_type
)
2076 case GPCMD_SEND_KEY
:
2077 p_cpt
->cam_flags
= CAM_DIR_OUT
;
2080 case GPCMD_READ_DVD_STRUCTURE
:
2081 case GPCMD_REPORT_KEY
:
2082 p_cpt
->cam_flags
= CAM_DIR_IN
;
2086 p_cpt
->cam_cdb
[0] = i_type
;
2088 p_cpt
->cam_cdb
[ 8 ] = (p_cpt
->cam_dxfer_len
>> 8) & 0xff;
2089 p_cpt
->cam_cdb
[ 9 ] = p_cpt
->cam_dxfer_len
& 0xff;
2090 p_cpt
->cam_cdb_len
= 12;
2092 p_cpt
->cam_timeout
= CAM_TIME_DEFAULT
;
2096 #if defined( SYS_OS2 )
2097 /*****************************************************************************
2098 * OS2InitSDC: initialize a SDC structure for the Execute SCSI-command
2099 *****************************************************************************
2100 * This function initializes a OS2 'execute SCSI command' structure for
2101 * future use, either a read command or a write command.
2102 *****************************************************************************/
2103 static void OS2InitSDC( struct OS2_ExecSCSICmd
*p_sdc
, int i_type
)
2107 case GPCMD_SEND_KEY
:
2111 case GPCMD_READ_DVD_STRUCTURE
:
2112 case GPCMD_REPORT_KEY
:
2113 p_sdc
->flags
= EX_DIRECTION_IN
;
2117 p_sdc
->command
[ 0 ] = i_type
;
2118 p_sdc
->command
[ 8 ] = (p_sdc
->data_length
>> 8) & 0xff;
2119 p_sdc
->command
[ 9 ] = p_sdc
->data_length
& 0xff;
2120 p_sdc
->id_code
= 0x31304443; // 'CD01'
2121 p_sdc
->cmd_length
= 12;