Mercurial > mplayer.hg
comparison libmpdvdkit2/ioctl.c @ 9333:f0f0f176d298
sync with libdvdcss 1.2.5 (including u8->uint8_t and whitespace cosmetics...)
patch by Andreas Hess <jaska@gmx.net>
author | arpi |
---|---|
date | Sat, 08 Feb 2003 00:22:39 +0000 |
parents | c932c17042bf |
children | 7b0bc557987b |
comparison
equal
deleted
inserted
replaced
9332:a604236b0dd6 | 9333:f0f0f176d298 |
---|---|
119 | 119 |
120 /***************************************************************************** | 120 /***************************************************************************** |
121 * Local prototypes, win32 (aspi) specific | 121 * Local prototypes, win32 (aspi) specific |
122 *****************************************************************************/ | 122 *****************************************************************************/ |
123 #if defined( WIN32 ) | 123 #if defined( WIN32 ) |
124 static void WinInitSSC ( struct SRB_ExecSCSICmd *, int ); | 124 static void WinInitSPTD ( SCSI_PASS_THROUGH_DIRECT *, int ); |
125 static int WinSendSSC ( int, struct SRB_ExecSCSICmd * ); | 125 static void WinInitSSC ( struct SRB_ExecSCSICmd *, int ); |
126 static int WinSendSSC ( int, struct SRB_ExecSCSICmd * ); | |
126 #endif | 127 #endif |
127 | 128 |
128 /***************************************************************************** | 129 /***************************************************************************** |
129 * Local prototypes, QNX specific | 130 * Local prototypes, QNX specific |
130 *****************************************************************************/ | 131 *****************************************************************************/ |
188 | 189 |
189 *pi_copyright = p_buffer[ 4 ]; | 190 *pi_copyright = p_buffer[ 4 ]; |
190 | 191 |
191 #elif defined( SOLARIS_USCSI ) | 192 #elif defined( SOLARIS_USCSI ) |
192 INIT_USCSI( GPCMD_READ_DVD_STRUCTURE, 8 ); | 193 INIT_USCSI( GPCMD_READ_DVD_STRUCTURE, 8 ); |
193 | 194 |
194 rs_cdb.cdb_opaque[ 6 ] = i_layer; | 195 rs_cdb.cdb_opaque[ 6 ] = i_layer; |
195 rs_cdb.cdb_opaque[ 7 ] = DVD_STRUCT_COPYRIGHT; | 196 rs_cdb.cdb_opaque[ 7 ] = DVD_STRUCT_COPYRIGHT; |
196 | 197 |
197 i_ret = SolarisSendUSCSI(i_fd, &sc); | 198 i_ret = SolarisSendUSCSI(i_fd, &sc); |
198 | 199 |
199 if( i_ret < 0 || sc.uscsi_status ) { | 200 if( i_ret < 0 || sc.uscsi_status ) { |
200 i_ret = -1; | 201 i_ret = -1; |
201 } | 202 } |
202 | 203 |
203 *pi_copyright = p_buffer[ 4 ]; | 204 *pi_copyright = p_buffer[ 4 ]; |
204 /* s->copyright.rmi = p_buffer[ 5 ]; */ | 205 /* s->copyright.rmi = p_buffer[ 5 ]; */ |
205 | 206 |
206 #elif defined( DARWIN_DVD_IOCTL ) | 207 #elif defined( DARWIN_DVD_IOCTL ) |
207 INIT_DVDIOCTL( dk_dvd_read_structure_t, DVDCopyrightInfo, | 208 INIT_DVDIOCTL( dk_dvd_read_structure_t, DVDCopyrightInfo, |
214 *pi_copyright = dvdbs.copyrightProtectionSystemType; | 215 *pi_copyright = dvdbs.copyrightProtectionSystemType; |
215 | 216 |
216 #elif defined( WIN32 ) | 217 #elif defined( WIN32 ) |
217 if( WIN2K ) /* NT/2k/XP */ | 218 if( WIN2K ) /* NT/2k/XP */ |
218 { | 219 { |
219 DWORD tmp; | 220 INIT_SPTD( GPCMD_READ_DVD_STRUCTURE, 8 ); |
220 u8 p_buffer[ 8 ]; | 221 |
221 SCSI_PASS_THROUGH_DIRECT sptd; | 222 /* When using IOCTL_DVD_READ_STRUCTURE and |
222 | |
223 /* When using IOCTL_DVD_READ_STRUCTURE and | |
224 DVD_COPYRIGHT_DESCRIPTOR, CopyrightProtectionType | 223 DVD_COPYRIGHT_DESCRIPTOR, CopyrightProtectionType |
225 seems to be always 6 ??? | 224 seems to be always 6 ??? |
226 To work around this M$ bug we try to send a raw scsi command | 225 To work around this MS bug we try to send a raw scsi command |
227 instead (if we've got enough privileges to do so). */ | 226 instead (if we've got enough privileges to do so). */ |
228 | 227 |
229 memset( &sptd, 0, sizeof( sptd ) ); | 228 sptd.Cdb[ 6 ] = i_layer; |
230 memset( &p_buffer, 0, sizeof( p_buffer ) ); | 229 sptd.Cdb[ 7 ] = DVD_STRUCT_COPYRIGHT; |
231 | 230 |
232 sptd.Length = sizeof( SCSI_PASS_THROUGH_DIRECT ); | 231 i_ret = SEND_SPTD( i_fd, &sptd, &tmp ); |
233 sptd.CdbLength = 12; | |
234 sptd.DataIn = SCSI_IOCTL_DATA_IN; | |
235 sptd.DataTransferLength = 8; | |
236 sptd.TimeOutValue = 2; | |
237 sptd.DataBuffer = p_buffer; | |
238 sptd.Cdb[ 0 ] = GPCMD_READ_DVD_STRUCTURE; | |
239 sptd.Cdb[ 6 ] = i_layer; | |
240 sptd.Cdb[ 7 ] = DVD_STRUCT_COPYRIGHT; | |
241 sptd.Cdb[ 8 ] = (8 >> 8) & 0xff; | |
242 sptd.Cdb[ 9 ] = 8 & 0xff; | |
243 | |
244 i_ret = DeviceIoControl( (HANDLE) i_fd, | |
245 IOCTL_SCSI_PASS_THROUGH_DIRECT, | |
246 &sptd, sizeof( SCSI_PASS_THROUGH_DIRECT ), | |
247 &sptd, sizeof( SCSI_PASS_THROUGH_DIRECT ), | |
248 &tmp, NULL ) ? 0 : -1; | |
249 | 232 |
250 if( i_ret == 0 ) | 233 if( i_ret == 0 ) |
251 { | 234 { |
252 *pi_copyright = p_buffer[ 4 ]; | 235 *pi_copyright = p_buffer[ 4 ]; |
253 } | 236 } |
254 } | 237 } |
255 else | 238 else |
256 { | 239 { |
257 INIT_SSC( GPCMD_READ_DVD_STRUCTURE, 8 ); | 240 INIT_SSC( GPCMD_READ_DVD_STRUCTURE, 8 ); |
258 | 241 |
295 } | 278 } |
296 | 279 |
297 /***************************************************************************** | 280 /***************************************************************************** |
298 * ioctl_ReadDiscKey: get the disc key | 281 * ioctl_ReadDiscKey: get the disc key |
299 *****************************************************************************/ | 282 *****************************************************************************/ |
300 int ioctl_ReadDiscKey( int i_fd, int *pi_agid, u8 *p_key ) | 283 int ioctl_ReadDiscKey( int i_fd, int *pi_agid, uint8_t *p_key ) |
301 { | 284 { |
302 int i_ret; | 285 int i_ret; |
303 | 286 |
304 #if defined( HAVE_LINUX_DVD_STRUCT ) | 287 #if defined( HAVE_LINUX_DVD_STRUCT ) |
305 dvd_struct dvd; | 288 dvd_struct dvd; |
338 #elif defined( SYS_BEOS ) | 321 #elif defined( SYS_BEOS ) |
339 INIT_RDC( GPCMD_READ_DVD_STRUCTURE, DVD_DISCKEY_SIZE + 4 ); | 322 INIT_RDC( GPCMD_READ_DVD_STRUCTURE, DVD_DISCKEY_SIZE + 4 ); |
340 | 323 |
341 rdc.command[ 7 ] = DVD_STRUCT_DISCKEY; | 324 rdc.command[ 7 ] = DVD_STRUCT_DISCKEY; |
342 rdc.command[ 10 ] = *pi_agid << 6; | 325 rdc.command[ 10 ] = *pi_agid << 6; |
343 | 326 |
344 i_ret = ioctl( i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); | 327 i_ret = ioctl( i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); |
345 | 328 |
346 if( i_ret < 0 ) | 329 if( i_ret < 0 ) |
347 { | 330 { |
348 return i_ret; | 331 return i_ret; |
353 #elif defined( HPUX_SCTL_IO ) | 336 #elif defined( HPUX_SCTL_IO ) |
354 INIT_SCTL_IO( GPCMD_READ_DVD_STRUCTURE, DVD_DISCKEY_SIZE + 4 ); | 337 INIT_SCTL_IO( GPCMD_READ_DVD_STRUCTURE, DVD_DISCKEY_SIZE + 4 ); |
355 | 338 |
356 sctl_io.cdb[ 7 ] = DVD_STRUCT_DISCKEY; | 339 sctl_io.cdb[ 7 ] = DVD_STRUCT_DISCKEY; |
357 sctl_io.cdb[ 10 ] = *pi_agid << 6; | 340 sctl_io.cdb[ 10 ] = *pi_agid << 6; |
358 | 341 |
359 i_ret = ioctl( i_fd, SIOC_IO, &sctl_io ); | 342 i_ret = ioctl( i_fd, SIOC_IO, &sctl_io ); |
360 | 343 |
361 if( i_ret < 0 ) | 344 if( i_ret < 0 ) |
362 { | 345 { |
363 return i_ret; | 346 return i_ret; |
365 | 348 |
366 memcpy( p_key, p_buffer + 4, DVD_DISCKEY_SIZE ); | 349 memcpy( p_key, p_buffer + 4, DVD_DISCKEY_SIZE ); |
367 | 350 |
368 #elif defined( SOLARIS_USCSI ) | 351 #elif defined( SOLARIS_USCSI ) |
369 INIT_USCSI( GPCMD_READ_DVD_STRUCTURE, DVD_DISCKEY_SIZE + 4 ); | 352 INIT_USCSI( GPCMD_READ_DVD_STRUCTURE, DVD_DISCKEY_SIZE + 4 ); |
370 | 353 |
371 rs_cdb.cdb_opaque[ 7 ] = DVD_STRUCT_DISCKEY; | 354 rs_cdb.cdb_opaque[ 7 ] = DVD_STRUCT_DISCKEY; |
372 rs_cdb.cdb_opaque[ 10 ] = *pi_agid << 6; | 355 rs_cdb.cdb_opaque[ 10 ] = *pi_agid << 6; |
373 | 356 |
374 i_ret = SolarisSendUSCSI( i_fd, &sc ); | 357 i_ret = SolarisSendUSCSI( i_fd, &sc ); |
375 | 358 |
376 if( i_ret < 0 || sc.uscsi_status ) | 359 if( i_ret < 0 || sc.uscsi_status ) |
377 { | 360 { |
378 i_ret = -1; | 361 i_ret = -1; |
379 return i_ret; | 362 return i_ret; |
380 } | 363 } |
382 memcpy( p_key, p_buffer + 4, DVD_DISCKEY_SIZE ); | 365 memcpy( p_key, p_buffer + 4, DVD_DISCKEY_SIZE ); |
383 | 366 |
384 #elif defined( DARWIN_DVD_IOCTL ) | 367 #elif defined( DARWIN_DVD_IOCTL ) |
385 INIT_DVDIOCTL( dk_dvd_read_structure_t, DVDDiscKeyInfo, | 368 INIT_DVDIOCTL( dk_dvd_read_structure_t, DVDDiscKeyInfo, |
386 kDVDStructureFormatDiscKeyInfo ); | 369 kDVDStructureFormatDiscKeyInfo ); |
387 | 370 |
388 dvd.grantID = *pi_agid; | 371 dvd.grantID = *pi_agid; |
389 | 372 |
390 i_ret = ioctl( i_fd, DKIOCDVDREADSTRUCTURE, &dvd ); | 373 i_ret = ioctl( i_fd, DKIOCDVDREADSTRUCTURE, &dvd ); |
391 | 374 |
392 memcpy( p_key, dvdbs.discKeyStructures, DVD_DISCKEY_SIZE ); | 375 memcpy( p_key, dvdbs.discKeyStructures, DVD_DISCKEY_SIZE ); |
393 | 376 |
394 #elif defined( WIN32 ) | 377 #elif defined( WIN32 ) |
395 if( WIN2K ) /* NT/2k/XP */ | 378 if( WIN2K ) /* NT/2k/XP */ |
396 { | 379 { |
397 DWORD tmp; | 380 DWORD tmp; |
398 u8 buffer[DVD_DISK_KEY_LENGTH]; | 381 uint8_t buffer[DVD_DISK_KEY_LENGTH]; |
399 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; | 382 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; |
400 | 383 |
401 memset( &buffer, 0, sizeof( buffer ) ); | 384 memset( &buffer, 0, sizeof( buffer ) ); |
402 | 385 |
403 key->KeyLength = DVD_DISK_KEY_LENGTH; | 386 key->KeyLength = DVD_DISK_KEY_LENGTH; |
404 key->SessionId = *pi_agid; | 387 key->SessionId = *pi_agid; |
405 key->KeyType = DvdDiskKey; | 388 key->KeyType = DvdDiskKey; |
406 key->KeyFlags = 0; | 389 key->KeyFlags = 0; |
407 | 390 |
408 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, | 391 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, |
409 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; | 392 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; |
410 | |
411 if( i_ret < 0 ) | |
412 { | |
413 return i_ret; | |
414 } | |
415 | |
416 memcpy( p_key, key->KeyData, DVD_DISCKEY_SIZE ); | |
417 } | |
418 else | |
419 { | |
420 INIT_SSC( GPCMD_READ_DVD_STRUCTURE, DVD_DISCKEY_SIZE + 4 ); | |
421 | |
422 ssc.CDBByte[ 7 ] = DVD_STRUCT_DISCKEY; | |
423 ssc.CDBByte[ 10 ] = *pi_agid << 6; | |
424 | |
425 i_ret = WinSendSSC( i_fd, &ssc ); | |
426 | 393 |
427 if( i_ret < 0 ) | 394 if( i_ret < 0 ) |
428 { | 395 { |
429 return i_ret; | 396 return i_ret; |
430 } | 397 } |
431 | 398 |
399 memcpy( p_key, key->KeyData, DVD_DISCKEY_SIZE ); | |
400 } | |
401 else | |
402 { | |
403 INIT_SSC( GPCMD_READ_DVD_STRUCTURE, DVD_DISCKEY_SIZE + 4 ); | |
404 | |
405 ssc.CDBByte[ 7 ] = DVD_STRUCT_DISCKEY; | |
406 ssc.CDBByte[ 10 ] = *pi_agid << 6; | |
407 | |
408 i_ret = WinSendSSC( i_fd, &ssc ); | |
409 | |
410 if( i_ret < 0 ) | |
411 { | |
412 return i_ret; | |
413 } | |
414 | |
432 memcpy( p_key, p_buffer + 4, DVD_DISCKEY_SIZE ); | 415 memcpy( p_key, p_buffer + 4, DVD_DISCKEY_SIZE ); |
433 } | 416 } |
434 | 417 |
435 #elif defined( __QNXNTO__ ) | 418 #elif defined( __QNXNTO__ ) |
436 | 419 |
446 #elif defined ( SYS_OS2 ) | 429 #elif defined ( SYS_OS2 ) |
447 INIT_SSC( GPCMD_READ_DVD_STRUCTURE, DVD_DISCKEY_SIZE + 4 ); | 430 INIT_SSC( GPCMD_READ_DVD_STRUCTURE, DVD_DISCKEY_SIZE + 4 ); |
448 | 431 |
449 sdc.command[ 7 ] = DVD_STRUCT_DISCKEY; | 432 sdc.command[ 7 ] = DVD_STRUCT_DISCKEY; |
450 sdc.command[ 10 ] = *pi_agid << 6; | 433 sdc.command[ 10 ] = *pi_agid << 6; |
451 | 434 |
452 i_ret = DosDevIOCtl(i_fd, IOCTL_CDROMDISK, CDROMDISK_EXECMD, | 435 i_ret = DosDevIOCtl(i_fd, IOCTL_CDROMDISK, CDROMDISK_EXECMD, |
453 &sdc, sizeof(sdc), &ulParamLen, | 436 &sdc, sizeof(sdc), &ulParamLen, |
454 p_buffer, sizeof(p_buffer), &ulDataLen); | 437 p_buffer, sizeof(p_buffer), &ulDataLen); |
455 | 438 |
456 if( i_ret < 0 ) | 439 if( i_ret < 0 ) |
468 } | 451 } |
469 | 452 |
470 /***************************************************************************** | 453 /***************************************************************************** |
471 * ioctl_ReadTitleKey: get the title key | 454 * ioctl_ReadTitleKey: get the title key |
472 *****************************************************************************/ | 455 *****************************************************************************/ |
473 int ioctl_ReadTitleKey( int i_fd, int *pi_agid, int i_pos, u8 *p_key ) | 456 int ioctl_ReadTitleKey( int i_fd, int *pi_agid, int i_pos, uint8_t *p_key ) |
474 { | 457 { |
475 int i_ret; | 458 int i_ret; |
476 | 459 |
477 #if defined( HAVE_LINUX_DVD_STRUCT ) | 460 #if defined( HAVE_LINUX_DVD_STRUCT ) |
478 dvd_authinfo auth_info; | 461 dvd_authinfo auth_info; |
524 | 507 |
525 memcpy( p_key, p_buffer + 5, DVD_KEY_SIZE ); | 508 memcpy( p_key, p_buffer + 5, DVD_KEY_SIZE ); |
526 | 509 |
527 #elif defined( SOLARIS_USCSI ) | 510 #elif defined( SOLARIS_USCSI ) |
528 INIT_USCSI( GPCMD_REPORT_KEY, 12 ); | 511 INIT_USCSI( GPCMD_REPORT_KEY, 12 ); |
529 | 512 |
530 rs_cdb.cdb_opaque[ 2 ] = ( i_pos >> 24 ) & 0xff; | 513 rs_cdb.cdb_opaque[ 2 ] = ( i_pos >> 24 ) & 0xff; |
531 rs_cdb.cdb_opaque[ 3 ] = ( i_pos >> 16 ) & 0xff; | 514 rs_cdb.cdb_opaque[ 3 ] = ( i_pos >> 16 ) & 0xff; |
532 rs_cdb.cdb_opaque[ 4 ] = ( i_pos >> 8 ) & 0xff; | 515 rs_cdb.cdb_opaque[ 4 ] = ( i_pos >> 8 ) & 0xff; |
533 rs_cdb.cdb_opaque[ 5 ] = ( i_pos ) & 0xff; | 516 rs_cdb.cdb_opaque[ 5 ] = ( i_pos ) & 0xff; |
534 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_TITLE_KEY | (*pi_agid << 6); | 517 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_TITLE_KEY | (*pi_agid << 6); |
535 | 518 |
536 i_ret = SolarisSendUSCSI( i_fd, &sc ); | 519 i_ret = SolarisSendUSCSI( i_fd, &sc ); |
537 | 520 |
538 if( i_ret < 0 || sc.uscsi_status ) | 521 if( i_ret < 0 || sc.uscsi_status ) |
539 { | 522 { |
540 i_ret = -1; | 523 i_ret = -1; |
541 } | 524 } |
542 | 525 |
543 /* Do we want to return the cp_sec flag perhaps? */ | 526 /* Do we want to return the cp_sec flag perhaps? */ |
544 /* a->lstk.cpm = (buf[ 4 ] >> 7) & 1; */ | 527 /* a->lstk.cpm = (buf[ 4 ] >> 7) & 1; */ |
545 /* a->lstk.cp_sec = (buf[ 4 ] >> 6) & 1; */ | 528 /* a->lstk.cp_sec = (buf[ 4 ] >> 6) & 1; */ |
546 /* a->lstk.cgms = (buf[ 4 ] >> 4) & 3; */ | 529 /* a->lstk.cgms = (buf[ 4 ] >> 4) & 3; */ |
547 | 530 |
548 memcpy( p_key, p_buffer + 5, DVD_KEY_SIZE ); | 531 memcpy( p_key, p_buffer + 5, DVD_KEY_SIZE ); |
549 | 532 |
550 #elif defined( DARWIN_DVD_IOCTL ) | 533 #elif defined( DARWIN_DVD_IOCTL ) |
551 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDTitleKeyInfo, | 534 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDTitleKeyInfo, |
552 kDVDKeyFormatTitleKey ); | 535 kDVDKeyFormatTitleKey ); |
553 | 536 |
554 dvd.address = i_pos; | 537 dvd.address = i_pos; |
561 | 544 |
562 #elif defined( WIN32 ) | 545 #elif defined( WIN32 ) |
563 if( WIN2K ) /* NT/2k/XP */ | 546 if( WIN2K ) /* NT/2k/XP */ |
564 { | 547 { |
565 DWORD tmp; | 548 DWORD tmp; |
566 u8 buffer[DVD_BUS_KEY_LENGTH]; | 549 uint8_t buffer[DVD_TITLE_KEY_LENGTH]; |
567 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; | 550 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; |
568 | 551 |
569 memset( &buffer, 0, sizeof( buffer ) ); | 552 memset( &buffer, 0, sizeof( buffer ) ); |
570 | 553 |
571 key->KeyLength = DVD_TITLE_KEY_LENGTH; | 554 key->KeyLength = DVD_TITLE_KEY_LENGTH; |
573 key->KeyType = DvdTitleKey; | 556 key->KeyType = DvdTitleKey; |
574 key->KeyFlags = 0; | 557 key->KeyFlags = 0; |
575 key->Parameters.TitleOffset.QuadPart = (LONGLONG) i_pos * | 558 key->Parameters.TitleOffset.QuadPart = (LONGLONG) i_pos * |
576 2048 /*DVDCSS_BLOCK_SIZE*/; | 559 2048 /*DVDCSS_BLOCK_SIZE*/; |
577 | 560 |
578 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, | 561 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, |
579 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; | 562 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; |
580 | 563 |
581 memcpy( p_key, key->KeyData, DVD_KEY_SIZE ); | 564 memcpy( p_key, key->KeyData, DVD_KEY_SIZE ); |
582 } | 565 } |
583 else | 566 else |
680 | 663 |
681 *pi_agid = p_buffer[ 7 ] >> 6; | 664 *pi_agid = p_buffer[ 7 ] >> 6; |
682 | 665 |
683 #elif defined( SOLARIS_USCSI ) | 666 #elif defined( SOLARIS_USCSI ) |
684 INIT_USCSI( GPCMD_REPORT_KEY, 8 ); | 667 INIT_USCSI( GPCMD_REPORT_KEY, 8 ); |
685 | 668 |
686 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_AGID | (*pi_agid << 6); | 669 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_AGID | (*pi_agid << 6); |
687 | 670 |
688 i_ret = SolarisSendUSCSI( i_fd, &sc ); | 671 i_ret = SolarisSendUSCSI( i_fd, &sc ); |
689 | 672 |
690 if( i_ret < 0 || sc.uscsi_status ) | 673 if( i_ret < 0 || sc.uscsi_status ) |
691 { | 674 { |
692 i_ret = -1; | 675 i_ret = -1; |
693 } | 676 } |
694 | 677 |
695 *pi_agid = p_buffer[ 7 ] >> 6; | 678 *pi_agid = p_buffer[ 7 ] >> 6; |
696 | 679 |
697 #elif defined( DARWIN_DVD_IOCTL ) | 680 #elif defined( DARWIN_DVD_IOCTL ) |
698 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDAuthenticationGrantIDInfo, | 681 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDAuthenticationGrantIDInfo, |
699 kDVDKeyFormatAGID_CSS ); | 682 kDVDKeyFormatAGID_CSS ); |
700 | 683 |
701 dvd.grantID = *pi_agid; | 684 dvd.grantID = *pi_agid; |
702 dvd.keyClass = kDVDKeyClassCSS_CPPM_CPRM; | 685 dvd.keyClass = kDVDKeyClassCSS_CPPM_CPRM; |
703 | 686 |
704 i_ret = ioctl( i_fd, DKIOCDVDREPORTKEY, &dvd ); | 687 i_ret = ioctl( i_fd, DKIOCDVDREPORTKEY, &dvd ); |
705 | 688 |
709 if( WIN2K ) /* NT/2k/XP */ | 692 if( WIN2K ) /* NT/2k/XP */ |
710 { | 693 { |
711 ULONG id; | 694 ULONG id; |
712 DWORD tmp; | 695 DWORD tmp; |
713 | 696 |
714 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_START_SESSION, | 697 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_START_SESSION, |
715 &tmp, 4, &id, sizeof( id ), &tmp, NULL ) ? 0 : -1; | 698 &tmp, 4, &id, sizeof( id ), &tmp, NULL ) ? 0 : -1; |
716 | 699 |
717 *pi_agid = id; | 700 *pi_agid = id; |
718 } | 701 } |
719 else | 702 else |
756 } | 739 } |
757 | 740 |
758 /***************************************************************************** | 741 /***************************************************************************** |
759 * ioctl_ReportChallenge: get challenge from the drive | 742 * ioctl_ReportChallenge: get challenge from the drive |
760 *****************************************************************************/ | 743 *****************************************************************************/ |
761 int ioctl_ReportChallenge( int i_fd, int *pi_agid, u8 *p_challenge ) | 744 int ioctl_ReportChallenge( int i_fd, int *pi_agid, uint8_t *p_challenge ) |
762 { | 745 { |
763 int i_ret; | 746 int i_ret; |
764 | 747 |
765 #if defined( HAVE_LINUX_DVD_STRUCT ) | 748 #if defined( HAVE_LINUX_DVD_STRUCT ) |
766 dvd_authinfo auth_info; | 749 dvd_authinfo auth_info; |
802 | 785 |
803 memcpy( p_challenge, p_buffer + 4, DVD_CHALLENGE_SIZE ); | 786 memcpy( p_challenge, p_buffer + 4, DVD_CHALLENGE_SIZE ); |
804 | 787 |
805 #elif defined( SOLARIS_USCSI ) | 788 #elif defined( SOLARIS_USCSI ) |
806 INIT_USCSI( GPCMD_REPORT_KEY, 16 ); | 789 INIT_USCSI( GPCMD_REPORT_KEY, 16 ); |
807 | 790 |
808 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_CHALLENGE | (*pi_agid << 6); | 791 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_CHALLENGE | (*pi_agid << 6); |
809 | 792 |
810 i_ret = SolarisSendUSCSI( i_fd, &sc ); | 793 i_ret = SolarisSendUSCSI( i_fd, &sc ); |
811 | 794 |
812 if( i_ret < 0 || sc.uscsi_status ) | 795 if( i_ret < 0 || sc.uscsi_status ) |
813 { | 796 { |
814 i_ret = -1; | 797 i_ret = -1; |
815 } | 798 } |
816 | 799 |
817 memcpy( p_challenge, p_buffer + 4, DVD_CHALLENGE_SIZE ); | 800 memcpy( p_challenge, p_buffer + 4, DVD_CHALLENGE_SIZE ); |
818 | 801 |
819 #elif defined( DARWIN_DVD_IOCTL ) | 802 #elif defined( DARWIN_DVD_IOCTL ) |
820 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDChallengeKeyInfo, | 803 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDChallengeKeyInfo, |
821 kDVDKeyFormatChallengeKey ); | 804 kDVDKeyFormatChallengeKey ); |
822 | 805 |
823 dvd.grantID = *pi_agid; | 806 dvd.grantID = *pi_agid; |
824 | 807 |
825 i_ret = ioctl( i_fd, DKIOCDVDREPORTKEY, &dvd ); | 808 i_ret = ioctl( i_fd, DKIOCDVDREPORTKEY, &dvd ); |
826 | 809 |
827 memcpy( p_challenge, dvdbs.challengeKeyValue, DVD_CHALLENGE_SIZE ); | 810 memcpy( p_challenge, dvdbs.challengeKeyValue, DVD_CHALLENGE_SIZE ); |
828 | 811 |
829 #elif defined( WIN32 ) | 812 #elif defined( WIN32 ) |
830 if( WIN2K ) /* NT/2k/XP */ | 813 if( WIN2K ) /* NT/2k/XP */ |
831 { | 814 { |
832 DWORD tmp; | 815 DWORD tmp; |
833 u8 buffer[DVD_CHALLENGE_KEY_LENGTH]; | 816 uint8_t buffer[DVD_CHALLENGE_KEY_LENGTH]; |
834 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; | 817 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; |
835 | 818 |
836 memset( &buffer, 0, sizeof( buffer ) ); | 819 memset( &buffer, 0, sizeof( buffer ) ); |
837 | 820 |
838 key->KeyLength = DVD_CHALLENGE_KEY_LENGTH; | 821 key->KeyLength = DVD_CHALLENGE_KEY_LENGTH; |
839 key->SessionId = *pi_agid; | 822 key->SessionId = *pi_agid; |
840 key->KeyType = DvdChallengeKey; | 823 key->KeyType = DvdChallengeKey; |
841 key->KeyFlags = 0; | 824 key->KeyFlags = 0; |
842 | 825 |
843 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, | 826 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, |
844 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; | 827 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; |
845 | 828 |
846 if( i_ret < 0 ) | 829 if( i_ret < 0 ) |
847 { | 830 { |
848 return i_ret; | 831 return i_ret; |
936 | 919 |
937 *pi_asf = p_buffer[ 7 ] & 1; | 920 *pi_asf = p_buffer[ 7 ] & 1; |
938 | 921 |
939 #elif defined( SOLARIS_USCSI ) | 922 #elif defined( SOLARIS_USCSI ) |
940 INIT_USCSI( GPCMD_REPORT_KEY, 8 ); | 923 INIT_USCSI( GPCMD_REPORT_KEY, 8 ); |
941 | 924 |
942 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_ASF; | 925 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_ASF; |
943 | 926 |
944 i_ret = SolarisSendUSCSI( i_fd, &sc ); | 927 i_ret = SolarisSendUSCSI( i_fd, &sc ); |
945 | 928 |
946 if( i_ret < 0 || sc.uscsi_status ) | 929 if( i_ret < 0 || sc.uscsi_status ) |
947 { | 930 { |
948 i_ret = -1; | 931 i_ret = -1; |
949 } | 932 } |
950 | 933 |
951 *pi_asf = p_buffer[ 7 ] & 1; | 934 *pi_asf = p_buffer[ 7 ] & 1; |
952 | 935 |
953 #elif defined( DARWIN_DVD_IOCTL ) | 936 #elif defined( DARWIN_DVD_IOCTL ) |
954 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDAuthenticationSuccessFlagInfo, | 937 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDAuthenticationSuccessFlagInfo, |
955 kDVDKeyFormatASF ); | 938 kDVDKeyFormatASF ); |
956 | 939 |
957 i_ret = ioctl( i_fd, DKIOCDVDREPORTKEY, &dvd ); | 940 i_ret = ioctl( i_fd, DKIOCDVDREPORTKEY, &dvd ); |
958 | 941 |
959 *pi_asf = dvdbs.successFlag; | 942 *pi_asf = dvdbs.successFlag; |
960 | 943 |
961 #elif defined( WIN32 ) | 944 #elif defined( WIN32 ) |
962 if( WIN2K ) /* NT/2k/XP */ | 945 if( WIN2K ) /* NT/2k/XP */ |
963 { | 946 { |
964 DWORD tmp; | 947 DWORD tmp; |
965 u8 buffer[DVD_ASF_LENGTH]; | 948 uint8_t buffer[DVD_ASF_LENGTH]; |
966 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; | 949 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; |
967 | 950 |
968 memset( &buffer, 0, sizeof( buffer ) ); | 951 memset( &buffer, 0, sizeof( buffer ) ); |
969 | 952 |
970 key->KeyLength = DVD_ASF_LENGTH; | 953 key->KeyLength = DVD_ASF_LENGTH; |
971 key->KeyType = DvdAsf; | 954 key->KeyType = DvdAsf; |
972 key->KeyFlags = 0; | 955 key->KeyFlags = 0; |
973 | 956 |
974 ((PDVD_ASF)key->KeyData)->SuccessFlag = *pi_asf; | 957 ((PDVD_ASF)key->KeyData)->SuccessFlag = *pi_asf; |
975 | 958 |
976 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, | 959 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, |
977 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; | 960 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; |
978 | 961 |
979 if( i_ret < 0 ) | 962 if( i_ret < 0 ) |
980 { | 963 { |
981 return i_ret; | 964 return i_ret; |
1023 } | 1006 } |
1024 | 1007 |
1025 /***************************************************************************** | 1008 /***************************************************************************** |
1026 * ioctl_ReportKey1: get the first key from the drive | 1009 * ioctl_ReportKey1: get the first key from the drive |
1027 *****************************************************************************/ | 1010 *****************************************************************************/ |
1028 int ioctl_ReportKey1( int i_fd, int *pi_agid, u8 *p_key ) | 1011 int ioctl_ReportKey1( int i_fd, int *pi_agid, uint8_t *p_key ) |
1029 { | 1012 { |
1030 int i_ret; | 1013 int i_ret; |
1031 | 1014 |
1032 #if defined( HAVE_LINUX_DVD_STRUCT ) | 1015 #if defined( HAVE_LINUX_DVD_STRUCT ) |
1033 dvd_authinfo auth_info; | 1016 dvd_authinfo auth_info; |
1069 | 1052 |
1070 memcpy( p_key, p_buffer + 4, DVD_KEY_SIZE ); | 1053 memcpy( p_key, p_buffer + 4, DVD_KEY_SIZE ); |
1071 | 1054 |
1072 #elif defined( SOLARIS_USCSI ) | 1055 #elif defined( SOLARIS_USCSI ) |
1073 INIT_USCSI( GPCMD_REPORT_KEY, 12 ); | 1056 INIT_USCSI( GPCMD_REPORT_KEY, 12 ); |
1074 | 1057 |
1075 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_KEY1 | (*pi_agid << 6); | 1058 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_KEY1 | (*pi_agid << 6); |
1076 | 1059 |
1077 i_ret = SolarisSendUSCSI( i_fd, &sc ); | 1060 i_ret = SolarisSendUSCSI( i_fd, &sc ); |
1078 | 1061 |
1079 if( i_ret < 0 || sc.uscsi_status ) | 1062 if( i_ret < 0 || sc.uscsi_status ) |
1080 { | 1063 { |
1081 i_ret = -1; | 1064 i_ret = -1; |
1082 } | 1065 } |
1083 | 1066 |
1084 memcpy( p_key, p_buffer + 4, DVD_KEY_SIZE ); | 1067 memcpy( p_key, p_buffer + 4, DVD_KEY_SIZE ); |
1085 | 1068 |
1086 #elif defined( DARWIN_DVD_IOCTL ) | 1069 #elif defined( DARWIN_DVD_IOCTL ) |
1087 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDKey1Info, | 1070 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDKey1Info, |
1088 kDVDKeyFormatKey1 ); | 1071 kDVDKeyFormatKey1 ); |
1089 | 1072 |
1090 dvd.grantID = *pi_agid; | 1073 dvd.grantID = *pi_agid; |
1091 | 1074 |
1092 i_ret = ioctl( i_fd, DKIOCDVDREPORTKEY, &dvd ); | 1075 i_ret = ioctl( i_fd, DKIOCDVDREPORTKEY, &dvd ); |
1093 | 1076 |
1094 memcpy( p_key, dvdbs.key1Value, DVD_KEY_SIZE ); | 1077 memcpy( p_key, dvdbs.key1Value, DVD_KEY_SIZE ); |
1095 | 1078 |
1096 #elif defined( WIN32 ) | 1079 #elif defined( WIN32 ) |
1097 if( WIN2K ) /* NT/2k/XP */ | 1080 if( WIN2K ) /* NT/2k/XP */ |
1098 { | 1081 { |
1099 DWORD tmp; | 1082 DWORD tmp; |
1100 u8 buffer[DVD_BUS_KEY_LENGTH]; | 1083 uint8_t buffer[DVD_BUS_KEY_LENGTH]; |
1101 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; | 1084 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; |
1102 | 1085 |
1103 memset( &buffer, 0, sizeof( buffer ) ); | 1086 memset( &buffer, 0, sizeof( buffer ) ); |
1104 | 1087 |
1105 key->KeyLength = DVD_BUS_KEY_LENGTH; | 1088 key->KeyLength = DVD_BUS_KEY_LENGTH; |
1106 key->SessionId = *pi_agid; | 1089 key->SessionId = *pi_agid; |
1107 key->KeyType = DvdBusKey1; | 1090 key->KeyType = DvdBusKey1; |
1108 key->KeyFlags = 0; | 1091 key->KeyFlags = 0; |
1109 | 1092 |
1110 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, | 1093 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, |
1111 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; | 1094 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; |
1112 | 1095 |
1113 memcpy( p_key, key->KeyData, DVD_KEY_SIZE ); | 1096 memcpy( p_key, key->KeyData, DVD_KEY_SIZE ); |
1114 } | 1097 } |
1115 else | 1098 else |
1190 | 1173 |
1191 i_ret = ioctl( i_fd, SIOC_IO, &sctl_io ); | 1174 i_ret = ioctl( i_fd, SIOC_IO, &sctl_io ); |
1192 | 1175 |
1193 #elif defined( SOLARIS_USCSI ) | 1176 #elif defined( SOLARIS_USCSI ) |
1194 INIT_USCSI( GPCMD_REPORT_KEY, 0 ); | 1177 INIT_USCSI( GPCMD_REPORT_KEY, 0 ); |
1195 | 1178 |
1196 rs_cdb.cdb_opaque[ 10 ] = DVD_INVALIDATE_AGID | (*pi_agid << 6); | 1179 rs_cdb.cdb_opaque[ 10 ] = DVD_INVALIDATE_AGID | (*pi_agid << 6); |
1197 | 1180 |
1198 i_ret = SolarisSendUSCSI( i_fd, &sc ); | 1181 i_ret = SolarisSendUSCSI( i_fd, &sc ); |
1199 | 1182 |
1200 if( i_ret < 0 || sc.uscsi_status ) | 1183 if( i_ret < 0 || sc.uscsi_status ) |
1201 { | 1184 { |
1202 i_ret = -1; | 1185 i_ret = -1; |
1203 } | 1186 } |
1204 | 1187 |
1205 #elif defined( DARWIN_DVD_IOCTL ) | 1188 #elif defined( DARWIN_DVD_IOCTL ) |
1206 INIT_DVDIOCTL( dk_dvd_send_key_t, DVDAuthenticationGrantIDInfo, | 1189 INIT_DVDIOCTL( dk_dvd_send_key_t, DVDAuthenticationGrantIDInfo, |
1207 kDVDKeyFormatAGID_Invalidate ); | 1190 kDVDKeyFormatAGID_Invalidate ); |
1208 | 1191 |
1209 dvd.grantID = *pi_agid; | 1192 dvd.grantID = *pi_agid; |
1210 | 1193 |
1211 i_ret = ioctl( i_fd, DKIOCDVDSENDKEY, &dvd ); | 1194 i_ret = ioctl( i_fd, DKIOCDVDSENDKEY, &dvd ); |
1212 | 1195 |
1213 #elif defined( WIN32 ) | 1196 #elif defined( WIN32 ) |
1214 if( WIN2K ) /* NT/2k/XP */ | 1197 if( WIN2K ) /* NT/2k/XP */ |
1215 { | 1198 { |
1216 DWORD tmp; | 1199 DWORD tmp; |
1217 | 1200 |
1218 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_END_SESSION, | 1201 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_END_SESSION, |
1219 pi_agid, sizeof( *pi_agid ), NULL, 0, &tmp, NULL ) ? 0 : -1; | 1202 pi_agid, sizeof( *pi_agid ), NULL, 0, &tmp, NULL ) ? 0 : -1; |
1220 } | 1203 } |
1221 else | 1204 else |
1222 { | 1205 { |
1223 #if defined( __MINGW32__ ) | 1206 #if defined( __MINGW32__ ) |
1263 } | 1246 } |
1264 | 1247 |
1265 /***************************************************************************** | 1248 /***************************************************************************** |
1266 * ioctl_SendChallenge: send challenge to the drive | 1249 * ioctl_SendChallenge: send challenge to the drive |
1267 *****************************************************************************/ | 1250 *****************************************************************************/ |
1268 int ioctl_SendChallenge( int i_fd, int *pi_agid, u8 *p_challenge ) | 1251 int ioctl_SendChallenge( int i_fd, int *pi_agid, uint8_t *p_challenge ) |
1269 { | 1252 { |
1270 int i_ret; | 1253 int i_ret; |
1271 | 1254 |
1272 #if defined( HAVE_LINUX_DVD_STRUCT ) | 1255 #if defined( HAVE_LINUX_DVD_STRUCT ) |
1273 dvd_authinfo auth_info; | 1256 dvd_authinfo auth_info; |
1276 auth_info.type = DVD_HOST_SEND_CHALLENGE; | 1259 auth_info.type = DVD_HOST_SEND_CHALLENGE; |
1277 auth_info.hsc.agid = *pi_agid; | 1260 auth_info.hsc.agid = *pi_agid; |
1278 | 1261 |
1279 memcpy( auth_info.hsc.chal, p_challenge, DVD_CHALLENGE_SIZE ); | 1262 memcpy( auth_info.hsc.chal, p_challenge, DVD_CHALLENGE_SIZE ); |
1280 | 1263 |
1281 return ioctl( i_fd, DVD_AUTH, &auth_info ); | 1264 i_ret = ioctl( i_fd, DVD_AUTH, &auth_info ); |
1282 | 1265 |
1283 #elif defined( HAVE_BSD_DVD_STRUCT ) | 1266 #elif defined( HAVE_BSD_DVD_STRUCT ) |
1284 struct dvd_authinfo auth_info; | 1267 struct dvd_authinfo auth_info; |
1285 | 1268 |
1286 memset( &auth_info, 0, sizeof( auth_info ) ); | 1269 memset( &auth_info, 0, sizeof( auth_info ) ); |
1287 auth_info.format = DVD_SEND_CHALLENGE; | 1270 auth_info.format = DVD_SEND_CHALLENGE; |
1288 auth_info.agid = *pi_agid; | 1271 auth_info.agid = *pi_agid; |
1289 | 1272 |
1290 memcpy( auth_info.keychal, p_challenge, DVD_CHALLENGE_SIZE ); | 1273 memcpy( auth_info.keychal, p_challenge, DVD_CHALLENGE_SIZE ); |
1291 | 1274 |
1292 return ioctl( i_fd, DVDIOCSENDKEY, &auth_info ); | 1275 i_ret = ioctl( i_fd, DVDIOCSENDKEY, &auth_info ); |
1293 | 1276 |
1294 #elif defined( SYS_BEOS ) | 1277 #elif defined( SYS_BEOS ) |
1295 INIT_RDC( GPCMD_SEND_KEY, 16 ); | 1278 INIT_RDC( GPCMD_SEND_KEY, 16 ); |
1296 | 1279 |
1297 rdc.command[ 10 ] = DVD_SEND_CHALLENGE | (*pi_agid << 6); | 1280 rdc.command[ 10 ] = DVD_SEND_CHALLENGE | (*pi_agid << 6); |
1298 | 1281 |
1299 p_buffer[ 1 ] = 0xe; | 1282 p_buffer[ 1 ] = 0xe; |
1300 memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE ); | 1283 memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE ); |
1301 | 1284 |
1302 return ioctl( i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); | 1285 i_ret = ioctl( i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); |
1303 | 1286 |
1304 #elif defined( HPUX_SCTL_IO ) | 1287 #elif defined( HPUX_SCTL_IO ) |
1305 INIT_SCTL_IO( GPCMD_SEND_KEY, 16 ); | 1288 INIT_SCTL_IO( GPCMD_SEND_KEY, 16 ); |
1306 | 1289 |
1307 sctl_io.cdb[ 10 ] = DVD_SEND_CHALLENGE | (*pi_agid << 6); | 1290 sctl_io.cdb[ 10 ] = DVD_SEND_CHALLENGE | (*pi_agid << 6); |
1308 | 1291 |
1309 p_buffer[ 1 ] = 0xe; | 1292 p_buffer[ 1 ] = 0xe; |
1310 memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE ); | 1293 memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE ); |
1311 | 1294 |
1312 return ioctl( i_fd, SIOC_IO, &sctl_io ); | 1295 i_ret = ioctl( i_fd, SIOC_IO, &sctl_io ); |
1313 | 1296 |
1314 #elif defined( SOLARIS_USCSI ) | 1297 #elif defined( SOLARIS_USCSI ) |
1315 INIT_USCSI( GPCMD_SEND_KEY, 16 ); | 1298 INIT_USCSI( GPCMD_SEND_KEY, 16 ); |
1316 | 1299 |
1317 rs_cdb.cdb_opaque[ 10 ] = DVD_SEND_CHALLENGE | (*pi_agid << 6); | 1300 rs_cdb.cdb_opaque[ 10 ] = DVD_SEND_CHALLENGE | (*pi_agid << 6); |
1318 | 1301 |
1319 p_buffer[ 1 ] = 0xe; | 1302 p_buffer[ 1 ] = 0xe; |
1320 memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE ); | 1303 memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE ); |
1321 | 1304 |
1322 if( SolarisSendUSCSI( i_fd, &sc ) < 0 || sc.uscsi_status ) | 1305 if( SolarisSendUSCSI( i_fd, &sc ) < 0 || sc.uscsi_status ) |
1323 { | 1306 { |
1324 return -1; | 1307 return -1; |
1325 } | 1308 } |
1326 | 1309 |
1327 return 0; | 1310 i_ret = 0; |
1328 | 1311 |
1329 #elif defined( DARWIN_DVD_IOCTL ) | 1312 #elif defined( DARWIN_DVD_IOCTL ) |
1330 INIT_DVDIOCTL( dk_dvd_send_key_t, DVDChallengeKeyInfo, | 1313 INIT_DVDIOCTL( dk_dvd_send_key_t, DVDChallengeKeyInfo, |
1331 kDVDKeyFormatChallengeKey ); | 1314 kDVDKeyFormatChallengeKey ); |
1332 | 1315 |
1333 dvd.grantID = *pi_agid; | 1316 dvd.grantID = *pi_agid; |
1334 dvd.keyClass = kDVDKeyClassCSS_CPPM_CPRM; | 1317 dvd.keyClass = kDVDKeyClassCSS_CPPM_CPRM; |
1335 | 1318 |
1336 dvdbs.dataLength[ 1 ] = 0xe; | 1319 dvdbs.dataLength[ 1 ] = 0xe; |
1337 memcpy( dvdbs.challengeKeyValue, p_challenge, DVD_CHALLENGE_SIZE ); | 1320 memcpy( dvdbs.challengeKeyValue, p_challenge, DVD_CHALLENGE_SIZE ); |
1340 | 1323 |
1341 #elif defined( WIN32 ) | 1324 #elif defined( WIN32 ) |
1342 if( WIN2K ) /* NT/2k/XP */ | 1325 if( WIN2K ) /* NT/2k/XP */ |
1343 { | 1326 { |
1344 DWORD tmp; | 1327 DWORD tmp; |
1345 u8 buffer[DVD_CHALLENGE_KEY_LENGTH]; | 1328 uint8_t buffer[DVD_CHALLENGE_KEY_LENGTH]; |
1346 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; | 1329 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; |
1347 | 1330 |
1348 memset( &buffer, 0, sizeof( buffer ) ); | 1331 memset( &buffer, 0, sizeof( buffer ) ); |
1349 | 1332 |
1350 key->KeyLength = DVD_CHALLENGE_KEY_LENGTH; | 1333 key->KeyLength = DVD_CHALLENGE_KEY_LENGTH; |
1352 key->KeyType = DvdChallengeKey; | 1335 key->KeyType = DvdChallengeKey; |
1353 key->KeyFlags = 0; | 1336 key->KeyFlags = 0; |
1354 | 1337 |
1355 memcpy( key->KeyData, p_challenge, DVD_CHALLENGE_SIZE ); | 1338 memcpy( key->KeyData, p_challenge, DVD_CHALLENGE_SIZE ); |
1356 | 1339 |
1357 return DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_SEND_KEY, key, | 1340 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_SEND_KEY, key, |
1358 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; | 1341 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; |
1359 } | 1342 } |
1360 else | 1343 else |
1361 { | 1344 { |
1362 INIT_SSC( GPCMD_SEND_KEY, 16 ); | 1345 INIT_SSC( GPCMD_SEND_KEY, 16 ); |
1363 | 1346 |
1364 ssc.CDBByte[ 10 ] = DVD_SEND_CHALLENGE | (*pi_agid << 6); | 1347 ssc.CDBByte[ 10 ] = DVD_SEND_CHALLENGE | (*pi_agid << 6); |
1365 | 1348 |
1366 p_buffer[ 1 ] = 0xe; | 1349 p_buffer[ 1 ] = 0xe; |
1367 memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE ); | 1350 memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE ); |
1368 | 1351 |
1369 return WinSendSSC( i_fd, &ssc ); | 1352 i_ret = WinSendSSC( i_fd, &ssc ); |
1370 } | 1353 } |
1371 | 1354 |
1372 #elif defined( __QNXNTO__ ) | 1355 #elif defined( __QNXNTO__ ) |
1373 | 1356 |
1374 INIT_CPT( GPCMD_SEND_KEY, 16 ); | 1357 INIT_CPT( GPCMD_SEND_KEY, 16 ); |
1386 sdc.command[ 10 ] = DVD_SEND_CHALLENGE | (*pi_agid << 6); | 1369 sdc.command[ 10 ] = DVD_SEND_CHALLENGE | (*pi_agid << 6); |
1387 | 1370 |
1388 p_buffer[ 1 ] = 0xe; | 1371 p_buffer[ 1 ] = 0xe; |
1389 memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE ); | 1372 memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE ); |
1390 | 1373 |
1391 return DosDevIOCtl(i_fd, IOCTL_CDROMDISK, CDROMDISK_EXECMD, | 1374 i_ret = DosDevIOCtl( i_fd, IOCTL_CDROMDISK, CDROMDISK_EXECMD, |
1392 &sdc, sizeof(sdc), &ulParamLen, | 1375 &sdc, sizeof(sdc), &ulParamLen, |
1393 p_buffer, sizeof(p_buffer), &ulDataLen); | 1376 p_buffer, sizeof(p_buffer), &ulDataLen ); |
1394 | 1377 |
1395 #else | 1378 #else |
1396 # error "DVD ioctls are unavailable on this system" | 1379 # error "DVD ioctls are unavailable on this system" |
1397 | 1380 |
1398 #endif | 1381 #endif |
1400 } | 1383 } |
1401 | 1384 |
1402 /***************************************************************************** | 1385 /***************************************************************************** |
1403 * ioctl_SendKey2: send the second key to the drive | 1386 * ioctl_SendKey2: send the second key to the drive |
1404 *****************************************************************************/ | 1387 *****************************************************************************/ |
1405 int ioctl_SendKey2( int i_fd, int *pi_agid, u8 *p_key ) | 1388 int ioctl_SendKey2( int i_fd, int *pi_agid, uint8_t *p_key ) |
1406 { | 1389 { |
1407 int i_ret; | 1390 int i_ret; |
1408 | 1391 |
1409 #if defined( HAVE_LINUX_DVD_STRUCT ) | 1392 #if defined( HAVE_LINUX_DVD_STRUCT ) |
1410 dvd_authinfo auth_info; | 1393 dvd_authinfo auth_info; |
1413 auth_info.type = DVD_HOST_SEND_KEY2; | 1396 auth_info.type = DVD_HOST_SEND_KEY2; |
1414 auth_info.hsk.agid = *pi_agid; | 1397 auth_info.hsk.agid = *pi_agid; |
1415 | 1398 |
1416 memcpy( auth_info.hsk.key, p_key, DVD_KEY_SIZE ); | 1399 memcpy( auth_info.hsk.key, p_key, DVD_KEY_SIZE ); |
1417 | 1400 |
1418 return ioctl( i_fd, DVD_AUTH, &auth_info ); | 1401 i_ret = ioctl( i_fd, DVD_AUTH, &auth_info ); |
1419 | 1402 |
1420 #elif defined( HAVE_BSD_DVD_STRUCT ) | 1403 #elif defined( HAVE_BSD_DVD_STRUCT ) |
1421 struct dvd_authinfo auth_info; | 1404 struct dvd_authinfo auth_info; |
1422 | 1405 |
1423 memset( &auth_info, 0, sizeof( auth_info ) ); | 1406 memset( &auth_info, 0, sizeof( auth_info ) ); |
1424 auth_info.format = DVD_SEND_KEY2; | 1407 auth_info.format = DVD_SEND_KEY2; |
1425 auth_info.agid = *pi_agid; | 1408 auth_info.agid = *pi_agid; |
1426 | 1409 |
1427 memcpy( auth_info.keychal, p_key, DVD_KEY_SIZE ); | 1410 memcpy( auth_info.keychal, p_key, DVD_KEY_SIZE ); |
1428 | 1411 |
1429 return ioctl( i_fd, DVDIOCSENDKEY, &auth_info ); | 1412 i_ret = ioctl( i_fd, DVDIOCSENDKEY, &auth_info ); |
1430 | 1413 |
1431 #elif defined( SYS_BEOS ) | 1414 #elif defined( SYS_BEOS ) |
1432 INIT_RDC( GPCMD_SEND_KEY, 12 ); | 1415 INIT_RDC( GPCMD_SEND_KEY, 12 ); |
1433 | 1416 |
1434 rdc.command[ 10 ] = DVD_SEND_KEY2 | (*pi_agid << 6); | 1417 rdc.command[ 10 ] = DVD_SEND_KEY2 | (*pi_agid << 6); |
1435 | 1418 |
1436 p_buffer[ 1 ] = 0xa; | 1419 p_buffer[ 1 ] = 0xa; |
1437 memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE ); | 1420 memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE ); |
1438 | 1421 |
1439 return ioctl( i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); | 1422 i_ret = ioctl( i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); |
1440 | 1423 |
1441 #elif defined( HPUX_SCTL_IO ) | 1424 #elif defined( HPUX_SCTL_IO ) |
1442 INIT_SCTL_IO( GPCMD_SEND_KEY, 12 ); | 1425 INIT_SCTL_IO( GPCMD_SEND_KEY, 12 ); |
1443 | 1426 |
1444 sctl_io.cdb[ 10 ] = DVD_SEND_KEY2 | (*pi_agid << 6); | 1427 sctl_io.cdb[ 10 ] = DVD_SEND_KEY2 | (*pi_agid << 6); |
1445 | 1428 |
1446 p_buffer[ 1 ] = 0xa; | 1429 p_buffer[ 1 ] = 0xa; |
1447 memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE ); | 1430 memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE ); |
1448 | 1431 |
1449 return ioctl( i_fd, SIOC_IO, &sctl_io ); | 1432 i_ret = ioctl( i_fd, SIOC_IO, &sctl_io ); |
1450 | 1433 |
1451 #elif defined( SOLARIS_USCSI ) | 1434 #elif defined( SOLARIS_USCSI ) |
1452 INIT_USCSI( GPCMD_SEND_KEY, 12 ); | 1435 INIT_USCSI( GPCMD_SEND_KEY, 12 ); |
1453 | 1436 |
1454 rs_cdb.cdb_opaque[ 10 ] = DVD_SEND_KEY2 | (*pi_agid << 6); | 1437 rs_cdb.cdb_opaque[ 10 ] = DVD_SEND_KEY2 | (*pi_agid << 6); |
1455 | 1438 |
1456 p_buffer[ 1 ] = 0xa; | 1439 p_buffer[ 1 ] = 0xa; |
1457 memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE ); | 1440 memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE ); |
1458 | 1441 |
1459 if( SolarisSendUSCSI( i_fd, &sc ) < 0 || sc.uscsi_status ) | 1442 if( SolarisSendUSCSI( i_fd, &sc ) < 0 || sc.uscsi_status ) |
1460 { | 1443 { |
1461 return -1; | 1444 return -1; |
1462 } | 1445 } |
1463 | 1446 |
1464 return 0; | 1447 i_ret = 0; |
1465 | 1448 |
1466 #elif defined( DARWIN_DVD_IOCTL ) | 1449 #elif defined( DARWIN_DVD_IOCTL ) |
1467 INIT_DVDIOCTL( dk_dvd_send_key_t, DVDKey2Info, | 1450 INIT_DVDIOCTL( dk_dvd_send_key_t, DVDKey2Info, |
1468 kDVDKeyFormatKey2 ); | 1451 kDVDKeyFormatKey2 ); |
1469 | 1452 |
1470 dvd.grantID = *pi_agid; | 1453 dvd.grantID = *pi_agid; |
1477 | 1460 |
1478 #elif defined( WIN32 ) | 1461 #elif defined( WIN32 ) |
1479 if( WIN2K ) /* NT/2k/XP */ | 1462 if( WIN2K ) /* NT/2k/XP */ |
1480 { | 1463 { |
1481 DWORD tmp; | 1464 DWORD tmp; |
1482 u8 buffer[DVD_BUS_KEY_LENGTH]; | 1465 uint8_t buffer[DVD_BUS_KEY_LENGTH]; |
1483 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; | 1466 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; |
1484 | 1467 |
1485 memset( &buffer, 0, sizeof( buffer ) ); | 1468 memset( &buffer, 0, sizeof( buffer ) ); |
1486 | 1469 |
1487 key->KeyLength = DVD_BUS_KEY_LENGTH; | 1470 key->KeyLength = DVD_BUS_KEY_LENGTH; |
1489 key->KeyType = DvdBusKey2; | 1472 key->KeyType = DvdBusKey2; |
1490 key->KeyFlags = 0; | 1473 key->KeyFlags = 0; |
1491 | 1474 |
1492 memcpy( key->KeyData, p_key, DVD_KEY_SIZE ); | 1475 memcpy( key->KeyData, p_key, DVD_KEY_SIZE ); |
1493 | 1476 |
1494 return DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_SEND_KEY, key, | 1477 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_SEND_KEY, key, |
1495 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; | 1478 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; |
1496 } | 1479 } |
1497 else | 1480 else |
1498 { | 1481 { |
1499 INIT_SSC( GPCMD_SEND_KEY, 12 ); | 1482 INIT_SSC( GPCMD_SEND_KEY, 12 ); |
1500 | 1483 |
1501 ssc.CDBByte[ 10 ] = DVD_SEND_KEY2 | (*pi_agid << 6); | 1484 ssc.CDBByte[ 10 ] = DVD_SEND_KEY2 | (*pi_agid << 6); |
1502 | 1485 |
1503 p_buffer[ 1 ] = 0xa; | 1486 p_buffer[ 1 ] = 0xa; |
1504 memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE ); | 1487 memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE ); |
1505 | 1488 |
1506 return WinSendSSC( i_fd, &ssc ); | 1489 i_ret = WinSendSSC( i_fd, &ssc ); |
1507 } | 1490 } |
1508 | 1491 |
1509 #elif defined( __QNXNTO__ ) | 1492 #elif defined( __QNXNTO__ ) |
1510 | 1493 |
1511 INIT_CPT( GPCMD_SEND_KEY, 12 ); | 1494 INIT_CPT( GPCMD_SEND_KEY, 12 ); |
1523 sdc.command[ 10 ] = DVD_SEND_KEY2 | (*pi_agid << 6); | 1506 sdc.command[ 10 ] = DVD_SEND_KEY2 | (*pi_agid << 6); |
1524 | 1507 |
1525 p_buffer[ 1 ] = 0xa; | 1508 p_buffer[ 1 ] = 0xa; |
1526 memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE ); | 1509 memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE ); |
1527 | 1510 |
1528 return DosDevIOCtl(i_fd, IOCTL_CDROMDISK, CDROMDISK_EXECMD, | 1511 i_ret = DosDevIOCtl( i_fd, IOCTL_CDROMDISK, CDROMDISK_EXECMD, |
1529 &sdc, sizeof(sdc), &ulParamLen, | 1512 &sdc, sizeof(sdc), &ulParamLen, |
1530 p_buffer, sizeof(p_buffer), &ulDataLen); | 1513 p_buffer, sizeof(p_buffer), &ulDataLen ); |
1531 | 1514 |
1532 #else | 1515 #else |
1533 # error "DVD ioctls are unavailable on this system" | 1516 # error "DVD ioctls are unavailable on this system" |
1534 | 1517 |
1535 #endif | 1518 #endif |
1593 *p_mask = p_buffer[ 5 ]; | 1576 *p_mask = p_buffer[ 5 ]; |
1594 *p_scheme = p_buffer[ 6 ]; | 1577 *p_scheme = p_buffer[ 6 ]; |
1595 | 1578 |
1596 #elif defined( SOLARIS_USCSI ) | 1579 #elif defined( SOLARIS_USCSI ) |
1597 INIT_USCSI( GPCMD_REPORT_KEY, 8 ); | 1580 INIT_USCSI( GPCMD_REPORT_KEY, 8 ); |
1598 | 1581 |
1599 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_RPC; | 1582 rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_RPC; |
1600 | 1583 |
1601 i_ret = SolarisSendUSCSI( i_fd, &sc ); | 1584 i_ret = SolarisSendUSCSI( i_fd, &sc ); |
1602 | 1585 |
1603 if( i_ret < 0 || sc.uscsi_status ) | 1586 if( i_ret < 0 || sc.uscsi_status ) |
1604 { | 1587 { |
1605 i_ret = -1; | 1588 i_ret = -1; |
1606 } | 1589 } |
1607 | 1590 |
1608 *p_type = p_buffer[ 4 ] >> 6; | 1591 *p_type = p_buffer[ 4 ] >> 6; |
1609 *p_mask = p_buffer[ 5 ]; | 1592 *p_mask = p_buffer[ 5 ]; |
1610 *p_scheme = p_buffer[ 6 ]; | 1593 *p_scheme = p_buffer[ 6 ]; |
1611 | 1594 |
1612 #elif defined( DARWIN_DVD_IOCTL ) | 1595 #elif defined( DARWIN_DVD_IOCTL ) |
1613 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDRegionPlaybackControlInfo, | 1596 INIT_DVDIOCTL( dk_dvd_report_key_t, DVDRegionPlaybackControlInfo, |
1614 kDVDKeyFormatRegionState ); | 1597 kDVDKeyFormatRegionState ); |
1615 | 1598 |
1616 dvd.keyClass = kDVDKeyClassCSS_CPPM_CPRM; | 1599 dvd.keyClass = kDVDKeyClassCSS_CPPM_CPRM; |
1623 | 1606 |
1624 #elif defined( WIN32 ) | 1607 #elif defined( WIN32 ) |
1625 if( WIN2K ) /* NT/2k/XP */ | 1608 if( WIN2K ) /* NT/2k/XP */ |
1626 { | 1609 { |
1627 DWORD tmp; | 1610 DWORD tmp; |
1628 u8 buffer[ DVD_REGION_LENGTH ]; | 1611 uint8_t buffer[DVD_RPC_KEY_LENGTH]; |
1629 PDVD_REGION region = (PDVD_REGION) &buffer; | 1612 PDVD_COPY_PROTECT_KEY key = (PDVD_COPY_PROTECT_KEY) &buffer; |
1630 | 1613 |
1631 memset( &buffer, 0, sizeof( buffer ) ); | 1614 memset( &buffer, 0, sizeof( buffer ) ); |
1632 | 1615 |
1633 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_GET_REGION, NULL, 0, | 1616 key->KeyLength = DVD_RPC_KEY_LENGTH; |
1634 region, DVD_REGION_LENGTH, &tmp, NULL ) ? 0 : -1; | 1617 key->KeyType = DvdGetRpcKey; |
1635 | 1618 key->KeyFlags = 0; |
1636 /* Someone who has the headers should correct all this. */ | 1619 |
1637 /* Use the IOCTL_SCSI_PASS_THROUGH_DIRECT so we get the real | 1620 i_ret = DeviceIoControl( (HANDLE) i_fd, IOCTL_DVD_READ_KEY, key, |
1638 * values of theses entities? */ | 1621 key->KeyLength, key, key->KeyLength, &tmp, NULL ) ? 0 : -1; |
1639 if(region->SystemRegion != 0) { | 1622 |
1640 *p_type = region->ResetCount > 1 ? 1 : 3 - region->ResetCount; | 1623 if( i_ret < 0 ) |
1641 *p_mask = 0xff ^ (1 << (region->SystemRegion - 1)); | 1624 { |
1642 *p_scheme = 1; | 1625 return i_ret; |
1643 } | 1626 } |
1644 else | 1627 |
1645 { | 1628 *p_type = ((PDVD_RPC_KEY)key->KeyData)->TypeCode; |
1646 *p_type = 0; /* ?? */ | 1629 *p_mask = ((PDVD_RPC_KEY)key->KeyData)->RegionMask; |
1647 *p_mask = 0xff; | 1630 *p_scheme = ((PDVD_RPC_KEY)key->KeyData)->RpcScheme; |
1648 *p_scheme = 1; /* ?? */ | |
1649 } | |
1650 } | 1631 } |
1651 else | 1632 else |
1652 { | 1633 { |
1653 INIT_SSC( GPCMD_REPORT_KEY, 8 ); | 1634 INIT_SSC( GPCMD_REPORT_KEY, 8 ); |
1654 | 1635 |
1683 p_buffer, sizeof(p_buffer), &ulDataLen); | 1664 p_buffer, sizeof(p_buffer), &ulDataLen); |
1684 | 1665 |
1685 *p_type = p_buffer[ 4 ] >> 6; | 1666 *p_type = p_buffer[ 4 ] >> 6; |
1686 *p_mask = p_buffer[ 5 ]; | 1667 *p_mask = p_buffer[ 5 ]; |
1687 *p_scheme = p_buffer[ 6 ]; | 1668 *p_scheme = p_buffer[ 6 ]; |
1669 | |
1670 #else | |
1671 # error "DVD ioctls are unavailable on this system" | |
1672 | |
1673 #endif | |
1674 return i_ret; | |
1675 } | |
1676 | |
1677 /***************************************************************************** | |
1678 * ioctl_SendRPC: set RPC status for the drive | |
1679 *****************************************************************************/ | |
1680 int ioctl_SendRPC( int i_fd, int i_pdrc ) | |
1681 { | |
1682 int i_ret; | |
1683 | |
1684 #if defined( HAVE_LINUX_DVD_STRUCT ) && defined( DVD_HOST_SEND_RPC_STATE ) | |
1685 dvd_authinfo auth_info; | |
1686 | |
1687 memset( &auth_info, 0, sizeof( auth_info ) ); | |
1688 auth_info.type = DVD_HOST_SEND_RPC_STATE; | |
1689 auth_info.hrpcs.pdrc = i_pdrc; | |
1690 | |
1691 i_ret = ioctl( i_fd, DVD_AUTH, &auth_info ); | |
1692 | |
1693 #elif defined( HAVE_LINUX_DVD_STRUCT ) | |
1694 /* FIXME: OpenBSD doesn't know this */ | |
1695 i_ret = -1; | |
1696 | |
1697 #elif defined( HAVE_BSD_DVD_STRUCT ) | |
1698 struct dvd_authinfo auth_info; | |
1699 | |
1700 memset( &auth_info, 0, sizeof( auth_info ) ); | |
1701 auth_info.format = DVD_SEND_RPC; | |
1702 auth_info.region = i_pdrc; | |
1703 | |
1704 i_ret = ioctl( i_fd, DVDIOCSENDKEY, &auth_info ); | |
1705 | |
1706 #elif defined( SYS_BEOS ) | |
1707 INIT_RDC( GPCMD_SEND_KEY, 8 ); | |
1708 | |
1709 rdc.command[ 10 ] = DVD_SEND_RPC; | |
1710 | |
1711 p_buffer[ 1 ] = 6; | |
1712 p_buffer[ 4 ] = i_pdrc; | |
1713 | |
1714 i_ret = ioctl( i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) ); | |
1715 | |
1716 #elif defined( HPUX_SCTL_IO ) | |
1717 INIT_SCTL_IO( GPCMD_SEND_KEY, 8 ); | |
1718 | |
1719 sctl_io.cdb[ 10 ] = DVD_SEND_RPC; | |
1720 | |
1721 p_buffer[ 1 ] = 6; | |
1722 p_buffer[ 4 ] = i_pdrc; | |
1723 | |
1724 i_ret = ioctl( i_fd, SIOC_IO, &sctl_io ); | |
1725 | |
1726 #elif defined( SOLARIS_USCSI ) | |
1727 INIT_USCSI( GPCMD_SEND_KEY, 8 ); | |
1728 | |
1729 rs_cdb.cdb_opaque[ 10 ] = DVD_SEND_RPC; | |
1730 | |
1731 p_buffer[ 1 ] = 6; | |
1732 p_buffer[ 4 ] = i_pdrc; | |
1733 | |
1734 i_ret = SolarisSendUSCSI( i_fd, &sc ); | |
1735 | |
1736 if( i_ret < 0 || sc.uscsi_status ) | |
1737 { | |
1738 i_ret = -1; | |
1739 } | |
1740 | |
1741 #elif defined( DARWIN_DVD_IOCTL ) | |
1742 INIT_DVDIOCTL( dk_dvd_send_key_t, DVDRegionPlaybackControlInfo, | |
1743 kDVDKeyFormatSetRegion ); | |
1744 | |
1745 dvd.keyClass = kDVDKeyClassCSS_CPPM_CPRM; | |
1746 dvdbs.driveRegion = i_pdrc; | |
1747 | |
1748 i_ret = ioctl( i_fd, DKIOCDVDSENDKEY, &dvd ); | |
1749 | |
1750 #elif defined( WIN32 ) | |
1751 if( WIN2K ) /* NT/2k/XP */ | |
1752 { | |
1753 INIT_SPTD( GPCMD_SEND_KEY, 8 ); | |
1754 | |
1755 sptd.Cdb[ 10 ] = DVD_SEND_RPC; | |
1756 | |
1757 p_buffer[ 1 ] = 6; | |
1758 p_buffer[ 4 ] = i_pdrc; | |
1759 | |
1760 i_ret = SEND_SPTD( i_fd, &sptd, &tmp ); | |
1761 } | |
1762 else | |
1763 { | |
1764 INIT_SSC( GPCMD_SEND_KEY, 8 ); | |
1765 | |
1766 ssc.CDBByte[ 10 ] = DVD_SEND_RPC; | |
1767 | |
1768 p_buffer[ 1 ] = 6; | |
1769 p_buffer[ 4 ] = i_pdrc; | |
1770 | |
1771 i_ret = WinSendSSC( i_fd, &ssc ); | |
1772 } | |
1773 | |
1774 #elif defined( __QNXNTO__ ) | |
1775 | |
1776 INIT_CPT( GPCMD_SEND_KEY, 8 ); | |
1777 | |
1778 p_cpt->cam_cdb[ 10 ] = DVD_SEND_RPC; | |
1779 | |
1780 p_buffer[ 1 ] = 6; | |
1781 p_buffer[ 4 ] = i_pdrc; | |
1782 | |
1783 i_ret = devctl(i_fd, DCMD_CAM_PASS_THRU, p_cpt, structSize, NULL); | |
1784 | |
1785 #elif defined( SYS_OS2 ) | |
1786 INIT_SSC( GPCMD_SEND_KEY, 8 ); | |
1787 | |
1788 sdc.command[ 10 ] = DVD_SEND_RPC; | |
1789 | |
1790 p_buffer[ 1 ] = 6; | |
1791 p_buffer[ 4 ] = i_pdrc; | |
1792 | |
1793 i_ret = DosDevIOCtl( i_fd, IOCTL_CDROMDISK, CDROMDISK_EXECMD, | |
1794 &sdc, sizeof(sdc), &ulParamLen, | |
1795 p_buffer, sizeof(p_buffer), &ulDataLen ); | |
1688 | 1796 |
1689 #else | 1797 #else |
1690 # error "DVD ioctls are unavailable on this system" | 1798 # error "DVD ioctls are unavailable on this system" |
1691 | 1799 |
1692 #endif | 1800 #endif |
1763 | 1871 |
1764 #if defined( SOLARIS_USCSI ) | 1872 #if defined( SOLARIS_USCSI ) |
1765 /***************************************************************************** | 1873 /***************************************************************************** |
1766 * SolarisInitUSCSI: initialize a USCSICMD structure for the Solaris kernel | 1874 * SolarisInitUSCSI: initialize a USCSICMD structure for the Solaris kernel |
1767 ***************************************************************************** | 1875 ***************************************************************************** |
1768 * This function initializes a Solaris userspace scsi command structure for | 1876 * This function initializes a Solaris userspace scsi command structure for |
1769 * future use, either a read command or a write command. | 1877 * future use, either a read command or a write command. |
1770 *****************************************************************************/ | 1878 *****************************************************************************/ |
1771 static void SolarisInitUSCSI( struct uscsi_cmd *p_sc, int i_type ) | 1879 static void SolarisInitUSCSI( struct uscsi_cmd *p_sc, int i_type ) |
1772 { | 1880 { |
1773 union scsi_cdb *rs_cdb; | 1881 union scsi_cdb *rs_cdb; |
1774 memset( p_sc->uscsi_cdb, 0, sizeof( union scsi_cdb ) ); | 1882 memset( p_sc->uscsi_cdb, 0, sizeof( union scsi_cdb ) ); |
1775 memset( p_sc->uscsi_bufaddr, 0, p_sc->uscsi_buflen ); | 1883 memset( p_sc->uscsi_bufaddr, 0, p_sc->uscsi_buflen ); |
1776 | 1884 |
1777 switch( i_type ) | 1885 switch( i_type ) |
1778 { | 1886 { |
1779 case GPCMD_SEND_KEY: | 1887 case GPCMD_SEND_KEY: |
1780 p_sc->uscsi_flags = USCSI_ISOLATE | USCSI_WRITE; | 1888 p_sc->uscsi_flags = USCSI_ISOLATE | USCSI_WRITE; |
1781 break; | 1889 break; |
1783 case GPCMD_READ_DVD_STRUCTURE: | 1891 case GPCMD_READ_DVD_STRUCTURE: |
1784 case GPCMD_REPORT_KEY: | 1892 case GPCMD_REPORT_KEY: |
1785 p_sc->uscsi_flags = USCSI_ISOLATE | USCSI_READ; | 1893 p_sc->uscsi_flags = USCSI_ISOLATE | USCSI_READ; |
1786 break; | 1894 break; |
1787 } | 1895 } |
1788 | 1896 |
1789 rs_cdb = (union scsi_cdb *)p_sc->uscsi_cdb; | 1897 rs_cdb = (union scsi_cdb *)p_sc->uscsi_cdb; |
1790 | 1898 |
1791 rs_cdb->scc_cmd = i_type; | 1899 rs_cdb->scc_cmd = i_type; |
1792 | 1900 |
1793 rs_cdb->cdb_opaque[ 8 ] = (p_sc->uscsi_buflen >> 8) & 0xff; | 1901 rs_cdb->cdb_opaque[ 8 ] = (p_sc->uscsi_buflen >> 8) & 0xff; |
1794 rs_cdb->cdb_opaque[ 9 ] = p_sc->uscsi_buflen & 0xff; | 1902 rs_cdb->cdb_opaque[ 9 ] = p_sc->uscsi_buflen & 0xff; |
1795 p_sc->uscsi_cdblen = 12; | 1903 p_sc->uscsi_cdblen = 12; |
1846 } | 1954 } |
1847 #endif | 1955 #endif |
1848 | 1956 |
1849 #if defined( WIN32 ) | 1957 #if defined( WIN32 ) |
1850 /***************************************************************************** | 1958 /***************************************************************************** |
1959 * WinInitSPTD: initialize a sptd structure | |
1960 ***************************************************************************** | |
1961 * This function initializes a SCSI pass through command structure for future | |
1962 * use, either a read command or a write command. | |
1963 *****************************************************************************/ | |
1964 static void WinInitSPTD( SCSI_PASS_THROUGH_DIRECT *p_sptd, int i_type ) | |
1965 { | |
1966 memset( p_sptd->DataBuffer, 0, p_sptd->DataTransferLength ); | |
1967 | |
1968 switch( i_type ) | |
1969 { | |
1970 case GPCMD_SEND_KEY: | |
1971 p_sptd->DataIn = SCSI_IOCTL_DATA_OUT; | |
1972 break; | |
1973 | |
1974 case GPCMD_READ_DVD_STRUCTURE: | |
1975 case GPCMD_REPORT_KEY: | |
1976 p_sptd->DataIn = SCSI_IOCTL_DATA_IN; | |
1977 break; | |
1978 } | |
1979 | |
1980 p_sptd->Cdb[ 0 ] = i_type; | |
1981 p_sptd->Cdb[ 8 ] = (uint8_t)(p_sptd->DataTransferLength >> 8) & 0xff; | |
1982 p_sptd->Cdb[ 9 ] = (uint8_t) p_sptd->DataTransferLength & 0xff; | |
1983 p_sptd->CdbLength = 12; | |
1984 | |
1985 p_sptd->TimeOutValue = 2; | |
1986 } | |
1987 | |
1988 /***************************************************************************** | |
1851 * WinInitSSC: initialize a ssc structure for the win32 aspi layer | 1989 * WinInitSSC: initialize a ssc structure for the win32 aspi layer |
1852 ***************************************************************************** | 1990 ***************************************************************************** |
1853 * This function initializes a ssc raw device command structure for future | 1991 * This function initializes a ssc raw device command structure for future |
1854 * use, either a read command or a write command. | 1992 * use, either a read command or a write command. |
1855 *****************************************************************************/ | 1993 *****************************************************************************/ |
1872 p_ssc->SRB_Cmd = SC_EXEC_SCSI_CMD; | 2010 p_ssc->SRB_Cmd = SC_EXEC_SCSI_CMD; |
1873 p_ssc->SRB_Flags |= SRB_EVENT_NOTIFY; | 2011 p_ssc->SRB_Flags |= SRB_EVENT_NOTIFY; |
1874 | 2012 |
1875 p_ssc->CDBByte[ 0 ] = i_type; | 2013 p_ssc->CDBByte[ 0 ] = i_type; |
1876 | 2014 |
1877 p_ssc->CDBByte[ 8 ] = (u8)(p_ssc->SRB_BufLen >> 8) & 0xff; | 2015 p_ssc->CDBByte[ 8 ] = (uint8_t)(p_ssc->SRB_BufLen >> 8) & 0xff; |
1878 p_ssc->CDBByte[ 9 ] = (u8) p_ssc->SRB_BufLen & 0xff; | 2016 p_ssc->CDBByte[ 9 ] = (uint8_t) p_ssc->SRB_BufLen & 0xff; |
1879 p_ssc->SRB_CDBLen = 12; | 2017 p_ssc->SRB_CDBLen = 12; |
1880 | 2018 |
1881 p_ssc->SRB_SenseLen = SENSE_LEN; | 2019 p_ssc->SRB_SenseLen = SENSE_LEN; |
1882 } | 2020 } |
1883 | 2021 |
1942 | 2080 |
1943 #if defined( SYS_OS2 ) | 2081 #if defined( SYS_OS2 ) |
1944 /***************************************************************************** | 2082 /***************************************************************************** |
1945 * OS2InitSDC: initialize a SDC structure for the Execute SCSI-command | 2083 * OS2InitSDC: initialize a SDC structure for the Execute SCSI-command |
1946 ***************************************************************************** | 2084 ***************************************************************************** |
1947 * This function initializes a OS2 'execute SCSI command' structure for | 2085 * This function initializes a OS2 'execute SCSI command' structure for |
1948 * future use, either a read command or a write command. | 2086 * future use, either a read command or a write command. |
1949 *****************************************************************************/ | 2087 *****************************************************************************/ |
1950 static void OS2InitSDC( struct OS2_ExecSCSICmd *p_sdc, int i_type ) | 2088 static void OS2InitSDC( struct OS2_ExecSCSICmd *p_sdc, int i_type ) |
1951 { | 2089 { |
1952 switch( i_type ) | 2090 switch( i_type ) |