github/mpv
1
Fork 0
mirror of https://github.com/mpv-player/mpv synced 2025-03-26 22:42:47 +01:00
Code Releases Activity

upgrade to libdvdcss 1.2.9

Browse Source 
git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@16631 b3059339-0415-0410-9bf9-f77b7e298cf2
This commit is contained in:
diego 2005-10-01 17:19:33 +00:00
parent eceae67034
commit c4e6b9da66
12 changed files with 601 additions and 800 deletions

2
Copyright

@ -33,7 +33,7 @@ Directory: liba52
License: GNU General Public License License: GNU General Public License
Name: libdvdcss Name: libdvdcss
Version: 1.2.8 + patches Version: 1.2.9 + patches
Homepage: http://developers.videolan.org/libdvdcss/ Homepage: http://developers.videolan.org/libdvdcss/
Directory: libmpdvdkit2 Directory: libmpdvdkit2
License: GNU General Public License License: GNU General Public License

2
libmpdvdkit2/FILES

@ -23,7 +23,7 @@ nav_read.c
nav_read.h nav_read.h
nav_types.h nav_types.h
libdvdcss 1.2.8: libdvdcss 1.2.9:
---------------- ----------------
bsdi_dvd.h bsdi_dvd.h
bsdi_ioctl.c bsdi_ioctl.c

4
libmpdvdkit2/bsdi_ioctl.c

@ -4,10 +4,6 @@
* Hacked version of the linux cdrom.c kernel module - everything except the * Hacked version of the linux cdrom.c kernel module - everything except the
* DVD handling ripped out and the rest rewritten to use raw SCSI commands * DVD handling ripped out and the rest rewritten to use raw SCSI commands
* on BSD/OS 4.2 (but should work with earlier versions as well). * on BSD/OS 4.2 (but should work with earlier versions as well).
*
* Modified for use with MPlayer, changes contained in libdvdcss_changes.diff.
* detailed CVS changelog at http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
* $Id$
*/ */
#include <sys/types.h> #include <sys/types.h>

5
libmpdvdkit2/common.h

@ -3,9 +3,6 @@
* Collection of useful common types and macros definitions * Collection of useful common types and macros definitions
***************************************************************************** *****************************************************************************
* Copyright (C) 1998, 1999, 2000 VideoLAN * Copyright (C) 1998, 1999, 2000 VideoLAN
*
* Modified for use with MPlayer, changes contained in libdvdcss_changes.diff.
* detailed CVS changelog at http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
* $Id$ * $Id$
* *
* Authors: Samuel Hocevar <sam@via.ecp.fr> * Authors: Samuel Hocevar <sam@via.ecp.fr>
@ -42,6 +39,8 @@
# define PATH_MAX MAX_PATH # define PATH_MAX MAX_PATH
#endif #endif
#define lseek _lseeki64
/* several type definitions */ /* several type definitions */
# if defined( __MINGW32__ ) # if defined( __MINGW32__ )
# if !defined( _OFF_T_ ) # if !defined( _OFF_T_ )

501
libmpdvdkit2/css.c

@ -1,19 +1,17 @@
/***************************************************************************** /*****************************************************************************
* css.c: Functions for DVD authentication and descrambling * css.c: Functions for DVD authentication and descrambling
***************************************************************************** *****************************************************************************
* Copyright (C) 1999-2001 VideoLAN * Copyright (C) 1999-2003 VideoLAN
*
* Modified for use with MPlayer, changes contained in libdvdcss_changes.diff.
* detailed CVS changelog at http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
* $Id$ * $Id$
* *
* Author: Stéphane Borel <stef@via.ecp.fr> * Authors: Stéphane Borel <stef@via.ecp.fr>
* Håkan Hjort <d95hjort@dtek.chalmers.se> * Håkan Hjort <d95hjort@dtek.chalmers.se>
* *
* based on: * based on:
* - css-auth by Derek Fawcus <derek@spider.com> * - css-auth by Derek Fawcus <derek@spider.com>
* - DVD CSS ioctls example program by Andrew T. Veliath <andrewtv@usa.net> * - DVD CSS ioctls example program by Andrew T. Veliath <andrewtv@usa.net>
* - The Divide and conquer attack by Frank A. Stevenson <frank@funcom.com> * - The Divide and conquer attack by Frank A. Stevenson <frank@funcom.com>
* (see http://www-2.cs.cmu.edu/~dst/DeCSS/FrankStevenson/index.html)
* - DeCSSPlus by Ethan Hawke * - DeCSSPlus by Ethan Hawke
* - DecVOB * - DecVOB
* see http://www.lemuria.org/DeCSS/ by Tom Vogt for more information. * see http://www.lemuria.org/DeCSS/ by Tom Vogt for more information.
@ -43,9 +41,9 @@
#include <string.h> #include <string.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
# include <unistd.h>
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> # include <limits.h>
#include <limits.h>
#include "dvdcss.h" #include "dvdcss.h"
@ -59,6 +57,8 @@
/***************************************************************************** /*****************************************************************************
* Local prototypes * Local prototypes
*****************************************************************************/ *****************************************************************************/
static void PrintKey ( dvdcss_t, char *, uint8_t const * );
static int GetBusKey ( dvdcss_t ); static int GetBusKey ( dvdcss_t );
static int GetASF ( dvdcss_t ); static int GetASF ( dvdcss_t );
@ -66,7 +66,7 @@ static void CryptKey ( int, int, uint8_t const *, uint8_t * );
static void DecryptKey ( uint8_t, static void DecryptKey ( uint8_t,
uint8_t const *, uint8_t const *, uint8_t * ); uint8_t const *, uint8_t const *, uint8_t * );
static int DecryptDiscKey ( uint8_t const *, dvd_key_t ); static int DecryptDiscKey ( dvdcss_t, uint8_t const *, dvd_key_t );
static int CrackDiscKey ( dvdcss_t, uint8_t * ); static int CrackDiscKey ( dvdcss_t, uint8_t * );
static void DecryptTitleKey ( dvd_key_t, dvd_key_t ); static void DecryptTitleKey ( dvd_key_t, dvd_key_t );
@ -91,22 +91,23 @@ int _dvdcss_test( dvdcss_t dvdcss )
#ifdef WIN32 #ifdef WIN32
if( i_ret < 0 ) if( i_ret < 0 )
{ {
/* Maybe we didn't have enough priviledges to read the copyright /* Maybe we didn't have enough privileges to read the copyright
* (see ioctl_ReadCopyright comments). * (see ioctl_ReadCopyright comments).
* Apparently, on unencrypted DVDs _dvdcss_disckey() always fails, so * Apparently, on unencrypted DVDs _dvdcss_disckey() always fails, so
* we can check this as a work-around. */ * we can check this as a workaround. */
i_ret = 0; i_ret = 0;
if( _dvdcss_disckey( dvdcss ) < 0 )
i_copyright = 0;
else
i_copyright = 1; i_copyright = 1;
if( _dvdcss_disckey( dvdcss ) < 0 )
{
i_copyright = 0;
}
} }
#endif #endif
if( i_ret < 0 ) if( i_ret < 0 )
{ {
/* Since it's the first ioctl we try to issue, we add a notice */ /* Since it's the first ioctl we try to issue, we add a notice */
_dvdcss_error( dvdcss, "css error: ioctl_ReadCopyright failed, " print_error( dvdcss, "css error: ioctl_ReadCopyright failed, "
"make sure there is a DVD in the drive, and that " "make sure there is a DVD in the drive, and that "
"you have used the correct device node." ); "you have used the correct device node." );
@ -116,167 +117,6 @@ int _dvdcss_test( dvdcss_t dvdcss )
return i_copyright; return i_copyright;
} }
/*****************************************************************************
* GetBusKey : Go through the CSS Authentication process
*****************************************************************************
* It simulates the mutual authentication between logical unit and host,
* and stops when a session key (called bus key) has been established.
* Always do the full auth sequence. Some drives seem to lie and always
* respond with ASF=1. For instance the old DVD roms on Compaq Armada says
* that ASF=1 from the start and then later fail with a 'read of scrambled
* block without authentication' error.
*****************************************************************************/
static int GetBusKey( dvdcss_t dvdcss )
{
uint8_t p_buffer[10];
uint8_t p_challenge[2*KEY_SIZE];
dvd_key_t p_key1;
dvd_key_t p_key2;
dvd_key_t p_key_check;
uint8_t i_variant = 0;
char psz_warning[80];
int i_ret = -1;
int i;
_dvdcss_debug( dvdcss, "requesting AGID" );
i_ret = ioctl_ReportAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
/* We might have to reset hung authentication processes in the drive
by invalidating the corresponding AGID'. As long as we haven't got
an AGID, invalidate one (in sequence) and try again. */
for( i = 0; i_ret == -1 && i < 4 ; ++i )
{
sprintf( psz_warning,
"ioctl ReportAgid failed, invalidating AGID %d", i );
_dvdcss_debug( dvdcss, psz_warning );
/* This is really _not good_, should be handled by the OS.
Invalidating an AGID could make another process fail some
where in it's authentication process. */
dvdcss->css.i_agid = i;
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
_dvdcss_debug( dvdcss, "requesting AGID" );
i_ret = ioctl_ReportAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
}
/* Unable to authenticate without AGID */
if( i_ret == -1 )
{
_dvdcss_error( dvdcss, "ioctl ReportAgid failed, fatal" );
return -1;
}
/* Setup a challenge, any values should work */
for( i = 0 ; i < 10; ++i )
{
p_challenge[i] = i;
}
/* Get challenge from host */
for( i = 0 ; i < 10 ; ++i )
{
p_buffer[9-i] = p_challenge[i];
}
/* Send challenge to LU */
if( ioctl_SendChallenge( dvdcss->i_fd,
&dvdcss->css.i_agid, p_buffer ) < 0 )
{
_dvdcss_error( dvdcss, "ioctl SendChallenge failed" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1;
}
/* Get key1 from LU */
if( ioctl_ReportKey1( dvdcss->i_fd, &dvdcss->css.i_agid, p_buffer ) < 0)
{
_dvdcss_error( dvdcss, "ioctl ReportKey1 failed" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1;
}
/* Send key1 to host */
for( i = 0 ; i < KEY_SIZE ; i++ )
{
p_key1[i] = p_buffer[4-i];
}
for( i = 0 ; i < 32 ; ++i )
{
CryptKey( 0, i, p_challenge, p_key_check );
if( memcmp( p_key_check, p_key1, KEY_SIZE ) == 0 )
{
snprintf( psz_warning, sizeof(psz_warning),
"drive authenticated, using variant %d", i );
_dvdcss_debug( dvdcss, psz_warning );
i_variant = i;
break;
}
}
if( i == 32 )
{
_dvdcss_error( dvdcss, "drive would not authenticate" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1;
}
/* Get challenge from LU */
if( ioctl_ReportChallenge( dvdcss->i_fd,
&dvdcss->css.i_agid, p_buffer ) < 0 )
{
_dvdcss_error( dvdcss, "ioctl ReportKeyChallenge failed" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1;
}
/* Send challenge to host */
for( i = 0 ; i < 10 ; ++i )
{
p_challenge[i] = p_buffer[9-i];
}
CryptKey( 1, i_variant, p_challenge, p_key2 );
/* Get key2 from host */
for( i = 0 ; i < KEY_SIZE ; ++i )
{
p_buffer[4-i] = p_key2[i];
}
/* Send key2 to LU */
if( ioctl_SendKey2( dvdcss->i_fd, &dvdcss->css.i_agid, p_buffer ) < 0 )
{
_dvdcss_error( dvdcss, "ioctl SendKey2 failed" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1;
}
/* The drive has accepted us as authentic. */
_dvdcss_debug( dvdcss, "authentication established" );
memcpy( p_challenge, p_key1, KEY_SIZE );
memcpy( p_challenge + KEY_SIZE, p_key2, KEY_SIZE );
CryptKey( 2, i_variant, p_challenge, dvdcss->css.p_bus_key );
return 0;
}
/*****************************************************************************
* PrintKey : debug function that dumps a key value
*****************************************************************************/
static void PrintKey( dvdcss_t dvdcss, char *prefix, uint8_t const *data )
{
char psz_output[80];
sprintf( psz_output, "%s%02x:%02x:%02x:%02x:%02x", prefix,
data[0], data[1], data[2], data[3], data[4] );
_dvdcss_debug( dvdcss, psz_output );
}
/***************************************************************************** /*****************************************************************************
* _dvdcss_title: crack or decrypt the current title key if needed * _dvdcss_title: crack or decrypt the current title key if needed
***************************************************************************** *****************************************************************************
@ -322,13 +162,27 @@ int _dvdcss_title ( dvdcss_t dvdcss, int i_block )
if( i_fd >= 0 ) if( i_fd >= 0 )
{ {
if( read( i_fd, p_title_key, 5 ) == 5 ) unsigned char psz_key[KEY_SIZE * 3];
unsigned int k0, k1, k2, k3, k4;
psz_key[KEY_SIZE * 3 - 1] = '\0';
if( read( i_fd, psz_key, KEY_SIZE * 3 - 1 ) == KEY_SIZE * 3 - 1
&& sscanf( psz_key, "%x:%x:%x:%x:%x",
&k0, &k1, &k2, &k3, &k4 ) == 5 )
{ {
_dvdcss_debug( dvdcss, "key found in cache" ); p_title_key[0] = k0;
p_title_key[1] = k1;
p_title_key[2] = k2;
p_title_key[3] = k3;
p_title_key[4] = k4;
PrintKey( dvdcss, "title key found in cache ", p_title_key );
/* Don't try to save it again */ /* Don't try to save it again */
b_cache = 0; b_cache = 0;
i_ret = 1; i_ret = 1;
} }
close( i_fd ); close( i_fd );
} }
} }
@ -340,24 +194,30 @@ int _dvdcss_title ( dvdcss_t dvdcss, int i_block )
if( i_ret < 0 ) if( i_ret < 0 )
{ {
_dvdcss_error( dvdcss, "fatal error in vts css key" ); print_error( dvdcss, "fatal error in vts css key" );
return i_ret; return i_ret;
} }
if( i_ret == 0 ) if( i_ret == 0 )
{ {
_dvdcss_debug( dvdcss, "unencrypted title" ); print_debug( dvdcss, "unencrypted title" );
/* We cache this anyway, so we don't need to check again. */ /* We cache this anyway, so we don't need to check again. */
} }
} }
/* Key is valid, we store it on disk. */ /* Key is valid, we store it on disk. */
if( b_cache ) if( dvdcss->psz_cachefile[0] && b_cache )
{ {
i_fd = open( dvdcss->psz_cachefile, O_RDWR|O_CREAT|O_EXCL, 0644 ); i_fd = open( dvdcss->psz_cachefile, O_RDWR|O_CREAT, 0644 );
if( i_fd >= 0 ) if( i_fd >= 0 )
{ {
write( i_fd, p_title_key, 5 ); unsigned char psz_key[KEY_SIZE * 3 + 2];
sprintf( psz_key, "%02x:%02x:%02x:%02x:%02x\r\n",
p_title_key[0], p_title_key[1], p_title_key[2],
p_title_key[3], p_title_key[4] );
write( i_fd, psz_key, KEY_SIZE * 3 + 1 );
close( i_fd ); close( i_fd );
} }
} }
@ -420,7 +280,7 @@ int _dvdcss_disckey( dvdcss_t dvdcss )
/* Get encrypted disc key */ /* Get encrypted disc key */
if( ioctl_ReadDiscKey( dvdcss->i_fd, &dvdcss->css.i_agid, p_buffer ) < 0 ) if( ioctl_ReadDiscKey( dvdcss->i_fd, &dvdcss->css.i_agid, p_buffer ) < 0 )
{ {
_dvdcss_error( dvdcss, "ioctl ReadDiscKey failed" ); print_error( dvdcss, "ioctl ReadDiscKey failed" );
return -1; return -1;
} }
@ -428,30 +288,31 @@ int _dvdcss_disckey( dvdcss_t dvdcss )
if( GetASF( dvdcss ) != 1 ) if( GetASF( dvdcss ) != 1 )
{ {
/* Region mismatch (or region not set) is the most likely source. */ /* Region mismatch (or region not set) is the most likely source. */
_dvdcss_error( dvdcss, print_error( dvdcss,
"ASF not 1 after reading disc key (region mismatch?)" ); "ASF not 1 after reading disc key (region mismatch?)" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid ); ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1; return -1;
} }
/* Decrypt disc key using bus key */ /* Shuffle disc key using bus key */
for( i = 0 ; i < DVD_DISCKEY_SIZE ; i++ ) for( i = 0 ; i < DVD_DISCKEY_SIZE ; i++ )
{ {
p_buffer[ i ] ^= dvdcss->css.p_bus_key[ 4 - (i % KEY_SIZE) ]; p_buffer[ i ] ^= dvdcss->css.p_bus_key[ 4 - (i % KEY_SIZE) ];
} }
/* Decrypt disc key */
switch( dvdcss->i_method ) switch( dvdcss->i_method )
{ {
case DVDCSS_METHOD_KEY: case DVDCSS_METHOD_KEY:
/* Decrypt disc key with player key. */ /* Decrypt disc key with player key. */
_dvdcss_debug( dvdcss, "decrypting disc key with player keys" ); PrintKey( dvdcss, "decrypting disc key ", p_buffer );
if( ! DecryptDiscKey( p_buffer, p_disc_key ) ) if( ! DecryptDiscKey( dvdcss, p_buffer, p_disc_key ) )
{ {
PrintKey( dvdcss, "decrypted disc key is ", p_disc_key ); PrintKey( dvdcss, "decrypted disc key is ", p_disc_key );
break; break;
} }
_dvdcss_debug( dvdcss, "failed to decrypt the disc key, " print_debug( dvdcss, "failed to decrypt the disc key, "
"faulty drive/kernel? " "faulty drive/kernel? "
"cracking title keys instead" ); "cracking title keys instead" );
@ -462,22 +323,21 @@ int _dvdcss_disckey( dvdcss_t dvdcss )
case DVDCSS_METHOD_DISC: case DVDCSS_METHOD_DISC:
/* Crack Disc key to be able to use it */ /* Crack Disc key to be able to use it */
_dvdcss_debug( dvdcss, "cracking disc key from key hash ..."
" this will take some time" );
memcpy( p_disc_key, p_buffer, KEY_SIZE ); memcpy( p_disc_key, p_buffer, KEY_SIZE );
PrintKey( dvdcss, "cracking disc key ", p_disc_key );
if( ! CrackDiscKey( dvdcss, p_disc_key ) ) if( ! CrackDiscKey( dvdcss, p_disc_key ) )
{ {
PrintKey( dvdcss, "cracked disc key is ", p_disc_key ); PrintKey( dvdcss, "cracked disc key is ", p_disc_key );
break; break;
} }
_dvdcss_debug( dvdcss, "failed to crack the disc key" ); print_debug( dvdcss, "failed to crack the disc key" );
memset( p_disc_key, 0, KEY_SIZE ); memset( p_disc_key, 0, KEY_SIZE );
dvdcss->i_method = DVDCSS_METHOD_TITLE; dvdcss->i_method = DVDCSS_METHOD_TITLE;
break; break;
default: default:
_dvdcss_debug( dvdcss, "disc key needs not be decrypted" ); print_debug( dvdcss, "disc key needs not be decrypted" );
memset( p_disc_key, 0, KEY_SIZE ); memset( p_disc_key, 0, KEY_SIZE );
break; break;
} }
@ -504,7 +364,8 @@ int _dvdcss_titlekey( dvdcss_t dvdcss, int i_pos, dvd_key_t p_title_key )
* read the title key and decrypt it. * read the title key and decrypt it.
*/ */
_dvdcss_debug( dvdcss, "getting title key the classic way" ); print_debug( dvdcss, "getting title key at block %i the classic way",
i_pos );
/* We need to authenticate again every time to get a new session key */ /* We need to authenticate again every time to get a new session key */
if( GetBusKey( dvdcss ) < 0 ) if( GetBusKey( dvdcss ) < 0 )
@ -516,7 +377,7 @@ int _dvdcss_titlekey( dvdcss_t dvdcss, int i_pos, dvd_key_t p_title_key )
if( ioctl_ReadTitleKey( dvdcss->i_fd, &dvdcss->css.i_agid, if( ioctl_ReadTitleKey( dvdcss->i_fd, &dvdcss->css.i_agid,
i_pos, p_key ) < 0 ) i_pos, p_key ) < 0 )
{ {
_dvdcss_debug( dvdcss, print_debug( dvdcss,
"ioctl ReadTitleKey failed (region mismatch?)" ); "ioctl ReadTitleKey failed (region mismatch?)" );
i_ret = -1; i_ret = -1;
} }
@ -526,7 +387,7 @@ int _dvdcss_titlekey( dvdcss_t dvdcss, int i_pos, dvd_key_t p_title_key )
{ {
case -1: case -1:
/* An error getting the ASF status, something must be wrong. */ /* An error getting the ASF status, something must be wrong. */
_dvdcss_debug( dvdcss, "lost ASF requesting title key" ); print_debug( dvdcss, "lost ASF requesting title key" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid ); ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
i_ret = -1; i_ret = -1;
break; break;
@ -534,7 +395,7 @@ int _dvdcss_titlekey( dvdcss_t dvdcss, int i_pos, dvd_key_t p_title_key )
case 0: case 0:
/* This might either be a title that has no key, /* This might either be a title that has no key,
* or we encountered a region error. */ * or we encountered a region error. */
_dvdcss_debug( dvdcss, "lost ASF requesting title key" ); print_debug( dvdcss, "lost ASF requesting title key" );
break; break;
case 1: case 1:
@ -565,7 +426,9 @@ int _dvdcss_titlekey( dvdcss_t dvdcss, int i_pos, dvd_key_t p_title_key )
} }
else else
{ {
PrintKey( dvdcss, "initial disc key ", dvdcss->css.p_disc_key );
DecryptTitleKey( dvdcss->css.p_disc_key, p_key ); DecryptTitleKey( dvdcss->css.p_disc_key, p_key );
PrintKey( dvdcss, "decrypted title key ", p_key );
i_ret = 1; i_ret = 1;
} }
@ -577,7 +440,7 @@ int _dvdcss_titlekey( dvdcss_t dvdcss, int i_pos, dvd_key_t p_title_key )
} }
/* The title key request failed */ /* The title key request failed */
_dvdcss_debug( dvdcss, "resetting drive and cracking title key" ); print_debug( dvdcss, "resetting drive and cracking title key" );
/* Read an unscrambled sector and reset the drive */ /* Read an unscrambled sector and reset the drive */
dvdcss->pf_seek( dvdcss, 0 ); dvdcss->pf_seek( dvdcss, 0 );
@ -612,8 +475,11 @@ int _dvdcss_unscramble( dvd_key_t p_key, uint8_t *p_sec )
uint8_t *p_end = p_sec + DVDCSS_BLOCK_SIZE; uint8_t *p_end = p_sec + DVDCSS_BLOCK_SIZE;
/* PES_scrambling_control */ /* PES_scrambling_control */
if( p_sec[0x14] & 0x30) if( !(p_sec[0x14] & 0x30) )
{ {
return 0;
}
i_t1 = (p_key[0] ^ p_sec[0x54]) | 0x100; i_t1 = (p_key[0] ^ p_sec[0x54]) | 0x100;
i_t2 = p_key[1] ^ p_sec[0x55]; i_t2 = p_key[1] ^ p_sec[0x55];
i_t3 = (p_key[2] | (p_key[3] << 8) | i_t3 = (p_key[2] | (p_key[3] << 8) |
@ -639,13 +505,166 @@ int _dvdcss_unscramble( dvd_key_t p_key, uint8_t *p_sec )
p_sec++; p_sec++;
i_t5 >>= 8; i_t5 >>= 8;
} }
}
return 0; return 0;
} }
/* Following functions are local */ /* Following functions are local */
/*****************************************************************************
* GetBusKey : Go through the CSS Authentication process
*****************************************************************************
* It simulates the mutual authentication between logical unit and host,
* and stops when a session key (called bus key) has been established.
* Always do the full auth sequence. Some drives seem to lie and always
* respond with ASF=1. For instance the old DVD roms on Compaq Armada says
* that ASF=1 from the start and then later fail with a 'read of scrambled
* block without authentication' error.
*****************************************************************************/
static int GetBusKey( dvdcss_t dvdcss )
{
uint8_t p_buffer[10];
uint8_t p_challenge[2*KEY_SIZE];
dvd_key_t p_key1;
dvd_key_t p_key2;
dvd_key_t p_key_check;
uint8_t i_variant = 0;
int i_ret = -1;
int i;
print_debug( dvdcss, "requesting AGID" );
i_ret = ioctl_ReportAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
/* We might have to reset hung authentication processes in the drive
* by invalidating the corresponding AGID'. As long as we haven't got
* an AGID, invalidate one (in sequence) and try again. */
for( i = 0; i_ret == -1 && i < 4 ; ++i )
{
print_debug( dvdcss, "ioctl ReportAgid failed, "
"invalidating AGID %d", i );
/* This is really _not good_, should be handled by the OS.
* Invalidating an AGID could make another process fail somewhere
* in its authentication process. */
dvdcss->css.i_agid = i;
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
print_debug( dvdcss, "requesting AGID" );
i_ret = ioctl_ReportAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
}
/* Unable to authenticate without AGID */
if( i_ret == -1 )
{
print_error( dvdcss, "ioctl ReportAgid failed, fatal" );
return -1;
}
/* Setup a challenge, any values should work */
for( i = 0 ; i < 10; ++i )
{
p_challenge[i] = i;
}
/* Get challenge from host */
for( i = 0 ; i < 10 ; ++i )
{
p_buffer[9-i] = p_challenge[i];
}
/* Send challenge to LU */
if( ioctl_SendChallenge( dvdcss->i_fd,
&dvdcss->css.i_agid, p_buffer ) < 0 )
{
print_error( dvdcss, "ioctl SendChallenge failed" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1;
}
/* Get key1 from LU */
if( ioctl_ReportKey1( dvdcss->i_fd, &dvdcss->css.i_agid, p_buffer ) < 0)
{
print_error( dvdcss, "ioctl ReportKey1 failed" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1;
}
/* Send key1 to host */
for( i = 0 ; i < KEY_SIZE ; i++ )
{
p_key1[i] = p_buffer[4-i];
}
for( i = 0 ; i < 32 ; ++i )
{
CryptKey( 0, i, p_challenge, p_key_check );
if( memcmp( p_key_check, p_key1, KEY_SIZE ) == 0 )
{
print_debug( dvdcss, "drive authenticated, using variant %d", i );
i_variant = i;
break;
}
}
if( i == 32 )
{
print_error( dvdcss, "drive would not authenticate" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1;
}
/* Get challenge from LU */
if( ioctl_ReportChallenge( dvdcss->i_fd,
&dvdcss->css.i_agid, p_buffer ) < 0 )
{
print_error( dvdcss, "ioctl ReportKeyChallenge failed" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1;
}
/* Send challenge to host */
for( i = 0 ; i < 10 ; ++i )
{
p_challenge[i] = p_buffer[9-i];
}
CryptKey( 1, i_variant, p_challenge, p_key2 );
/* Get key2 from host */
for( i = 0 ; i < KEY_SIZE ; ++i )
{
p_buffer[4-i] = p_key2[i];
}
/* Send key2 to LU */
if( ioctl_SendKey2( dvdcss->i_fd, &dvdcss->css.i_agid, p_buffer ) < 0 )
{
print_error( dvdcss, "ioctl SendKey2 failed" );
ioctl_InvalidateAgid( dvdcss->i_fd, &dvdcss->css.i_agid );
return -1;
}
/* The drive has accepted us as authentic. */
print_debug( dvdcss, "authentication established" );
memcpy( p_challenge, p_key1, KEY_SIZE );
memcpy( p_challenge + KEY_SIZE, p_key2, KEY_SIZE );
CryptKey( 2, i_variant, p_challenge, dvdcss->css.p_bus_key );
return 0;
}
/*****************************************************************************
* PrintKey : debug function that dumps a key value
*****************************************************************************/
static void PrintKey( dvdcss_t dvdcss, char *prefix, uint8_t const *data )
{
print_debug( dvdcss, "%s%02x:%02x:%02x:%02x:%02x", prefix,
data[0], data[1], data[2], data[3], data[4] );
}
/***************************************************************************** /*****************************************************************************
* GetASF : Get Authentication success flag * GetASF : Get Authentication success flag
***************************************************************************** *****************************************************************************
@ -661,17 +680,17 @@ static int GetASF( dvdcss_t dvdcss )
if( ioctl_ReportASF( dvdcss->i_fd, NULL, &i_asf ) != 0 ) if( ioctl_ReportASF( dvdcss->i_fd, NULL, &i_asf ) != 0 )
{ {
/* The ioctl process has failed */ /* The ioctl process has failed */
_dvdcss_error( dvdcss, "GetASF fatal error" ); print_error( dvdcss, "GetASF fatal error" );
return -1; return -1;
} }
if( i_asf ) if( i_asf )
{ {
_dvdcss_debug( dvdcss, "GetASF authenticated, ASF=1" ); print_debug( dvdcss, "GetASF authenticated, ASF=1" );
} }
else else
{ {
_dvdcss_debug( dvdcss, "GetASF not authenticated, ASF=0" ); print_debug( dvdcss, "GetASF not authenticated, ASF=0" );
} }
return i_asf; return i_asf;
@ -945,21 +964,14 @@ static void DecryptKey( uint8_t invert, uint8_t const *p_key,
} }
/***************************************************************************** /*****************************************************************************
* DecryptDiscKey * player_keys: alternate DVD player keys
***************************************************************************** *****************************************************************************
* Decryption of the disc key with player keys if they are available. * These player keys were generated using Frank A. Stevenson's PlayerKey
* Try to decrypt the disc key from every position with every player key. * cracker. A copy of his article can be found here:
* p_struct_disckey: the 2048 byte DVD_STRUCT_DISCKEY data * http://www-2.cs.cmu.edu/~dst/DeCSS/FrankStevenson/mail2.txt
* p_disc_key: result, the 5 byte disc key
*****************************************************************************/ *****************************************************************************/
static int DecryptDiscKey( uint8_t const *p_struct_disckey, static const dvd_key_t player_keys[] =
dvd_key_t p_disc_key )
{ {
uint8_t p_verify[KEY_SIZE];
unsigned int i, n = 0;
static const dvd_key_t player_keys[] =
{
{ 0x01, 0xaf, 0xe3, 0x12, 0x80 }, { 0x01, 0xaf, 0xe3, 0x12, 0x80 },
{ 0x12, 0x11, 0xca, 0x04, 0x3b }, { 0x12, 0x11, 0xca, 0x04, 0x3b },
{ 0x14, 0x0c, 0x9e, 0xd0, 0x09 }, { 0x14, 0x0c, 0x9e, 0xd0, 0x09 },
@ -991,11 +1003,27 @@ static int DecryptDiscKey( uint8_t const *p_struct_disckey,
{ 0xcf, 0x1a, 0xb2, 0xf8, 0x0a }, { 0xcf, 0x1a, 0xb2, 0xf8, 0x0a },
{ 0xec, 0xa0, 0xcf, 0xb3, 0xff }, { 0xec, 0xa0, 0xcf, 0xb3, 0xff },
{ 0xfc, 0x95, 0xa9, 0x87, 0x35 } { 0xfc, 0x95, 0xa9, 0x87, 0x35 }
}; };
/*****************************************************************************
* DecryptDiscKey
*****************************************************************************
* Decryption of the disc key with player keys: try to decrypt the disc key
* from every position with every player key.
* p_struct_disckey: the 2048 byte DVD_STRUCT_DISCKEY data
* p_disc_key: result, the 5 byte disc key
*****************************************************************************/
static int DecryptDiscKey( dvdcss_t dvdcss, uint8_t const *p_struct_disckey,
dvd_key_t p_disc_key )
{
uint8_t p_verify[KEY_SIZE];
unsigned int i, n = 0;
/* Decrypt disc key with the above player keys */ /* Decrypt disc key with the above player keys */
while( n < sizeof(player_keys) / sizeof(dvd_key_t) ) for( n = 0; n < sizeof(player_keys) / sizeof(dvd_key_t); n++ )
{ {
PrintKey( dvdcss, "trying player key ", player_keys[n] );
for( i = 1; i < 409; i++ ) for( i = 1; i < 409; i++ )
{ {
/* Check if player key n is the right key for position i. */ /* Check if player key n is the right key for position i. */
@ -1013,7 +1041,6 @@ static int DecryptDiscKey( uint8_t const *p_struct_disckey,
return 0; return 0;
} }
} }
n++;
} }
/* Have tried all combinations of positions and keys, /* Have tried all combinations of positions and keys,
@ -1076,13 +1103,10 @@ static int CrackDiscKey( dvdcss_t dvdcss, uint8_t *p_disc_key )
unsigned int* BigTable; /* LFSR2 startstate indexed by unsigned int* BigTable; /* LFSR2 startstate indexed by
* 1,2,5 output byte */ * 1,2,5 output byte */
_dvdcss_debug( dvdcss, "cracking disc key" );
/* /*
* Prepare tables for hash reversal * Prepare tables for hash reversal
*/ */
/* initialize lookup tables for k[1] */ /* initialize lookup tables for k[1] */
K1table = malloc( 65536 * K1TABLEWIDTH ); K1table = malloc( 65536 * K1TABLEWIDTH );
memset( K1table, 0 , 65536 * K1TABLEWIDTH ); memset( K1table, 0 , 65536 * K1TABLEWIDTH );
@ -1104,7 +1128,7 @@ static int CrackDiscKey( dvdcss_t dvdcss, uint8_t *p_disc_key )
/* /*
if( tmp4 == K1TABLEWIDTH ) if( tmp4 == K1TABLEWIDTH )
{ {
_dvdcss_debug( dvdcss, "Table disaster %d", tmp4 ); print_debug( dvdcss, "Table disaster %d", tmp4 );
} }
*/ */
if( tmp4 < K1TABLEWIDTH ) if( tmp4 < K1TABLEWIDTH )
@ -1125,7 +1149,7 @@ static int CrackDiscKey( dvdcss_t dvdcss, uint8_t *p_disc_key )
tmp3 = 0; tmp3 = 0;
_dvdcss_debug( dvdcss, "initializing the big table" ); print_debug( dvdcss, "initializing the big table" );
for( i = 0 ; i < 16777216 ; i++ ) for( i = 0 ; i < 16777216 ; i++ )
{ {
@ -1376,7 +1400,7 @@ static int RecoverTitleKey( int i_start, uint8_t const *p_crypted,
/****************************************************************************** /******************************************************************************
* Various pices for the title crack engine. * Various pieces for the title crack engine.
****************************************************************************** ******************************************************************************
* The length of the PES packet is located at 0x12-0x13. * The length of the PES packet is located at 0x12-0x13.
* The the copyrigth protection bits are located at 0x14 (bits 0x20 and 0x10). * The the copyrigth protection bits are located at 0x14 (bits 0x20 and 0x10).
@ -1408,7 +1432,7 @@ static int CrackTitleKey( dvdcss_t dvdcss, int i_pos, int i_len,
int b_read_error = 0; int b_read_error = 0;
int i_ret; int i_ret;
_dvdcss_debug( dvdcss, "cracking title key" ); print_debug( dvdcss, "cracking title key at block %i", i_pos );
i_tries = 0; i_tries = 0;
i_success = 0; i_success = 0;
@ -1419,7 +1443,7 @@ static int CrackTitleKey( dvdcss_t dvdcss, int i_pos, int i_len,
if( i_ret != i_pos ) if( i_ret != i_pos )
{ {
_dvdcss_error( dvdcss, "seek failed" ); print_error( dvdcss, "seek failed" );
} }
i_ret = dvdcss_read( dvdcss, p_buf, 1, DVDCSS_NOFLAGS ); i_ret = dvdcss_read( dvdcss, p_buf, 1, DVDCSS_NOFLAGS );
@ -1430,12 +1454,12 @@ static int CrackTitleKey( dvdcss_t dvdcss, int i_pos, int i_len,
{ {
if( i_ret == 0 ) if( i_ret == 0 )
{ {
_dvdcss_debug( dvdcss, "read returned 0 (end of device?)" ); print_debug( dvdcss, "read returned 0 (end of device?)" );
} }
else if( !b_read_error ) else if( !b_read_error )
{ {
_dvdcss_debug( dvdcss, "read error, resorting to secret " print_debug( dvdcss, "read error at block %i, resorting to "
"arcanes to recover" ); "secret arcanes to recover", i_pos );
/* Reset the drive before trying to continue */ /* Reset the drive before trying to continue */
_dvdcss_close( dvdcss ); _dvdcss_close( dvdcss );
@ -1452,12 +1476,13 @@ static int CrackTitleKey( dvdcss_t dvdcss, int i_pos, int i_len,
* For now, allow all blocks that begin with a start code. */ * For now, allow all blocks that begin with a start code. */
if( memcmp( p_buf, p_packstart, 3 ) ) if( memcmp( p_buf, p_packstart, 3 ) )
{ {
_dvdcss_debug( dvdcss, "non MPEG block found (end of title)" ); print_debug( dvdcss, "non MPEG block found at block %i "
"(end of title)", i_pos );
break; break;
} }
if( p_buf[0x0d] & 0x07 ) if( p_buf[0x0d] & 0x07 )
_dvdcss_debug( dvdcss, "stuffing in pack header" ); print_debug( dvdcss, "stuffing in pack header" );
/* PES_scrambling_control does not exist in a system_header, /* PES_scrambling_control does not exist in a system_header,
* a padding_stream or a private_stream2 (and others?). */ * a padding_stream or a private_stream2 (and others?). */
@ -1486,7 +1511,7 @@ static int CrackTitleKey( dvdcss_t dvdcss, int i_pos, int i_len,
/* Emit a progress indication now and then. */ /* Emit a progress indication now and then. */
if( !( i_reads & 0xfff ) ) if( !( i_reads & 0xfff ) )
{ {
_dvdcss_debug( dvdcss, "still cracking..." ); print_debug( dvdcss, "at block %i, still cracking...", i_pos );
} }
/* Stop after 2000 blocks if we haven't seen any encrypted blocks. */ /* Stop after 2000 blocks if we haven't seen any encrypted blocks. */
@ -1496,27 +1521,23 @@ static int CrackTitleKey( dvdcss_t dvdcss, int i_pos, int i_len,
if( !b_stop_scanning ) if( !b_stop_scanning )
{ {
_dvdcss_debug( dvdcss, "end of title reached" ); print_debug( dvdcss, "end of title reached" );
} }
{ /* Print some statistics. */ /* Print some statistics. */
char psz_info[128]; print_debug( dvdcss, "successful attempts %d/%d, scrambled blocks %d/%d",
snprintf( psz_info, sizeof(psz_info),
"%d of %d attempts successful, %d of %d blocks scrambled",
i_success, i_tries, i_encrypted, i_reads ); i_success, i_tries, i_encrypted, i_reads );
_dvdcss_debug( dvdcss, psz_info );
}
if( i_success > 0 /* b_stop_scanning */ ) if( i_success > 0 /* b_stop_scanning */ )
{ {
_dvdcss_debug( dvdcss, "vts key initialized" ); print_debug( dvdcss, "vts key initialized" );
return 1; return 1;
} }
if( i_encrypted == 0 && i_reads > 0 ) if( i_encrypted == 0 && i_reads > 0 )
{ {
memset( p_titlekey, 0, KEY_SIZE ); memset( p_titlekey, 0, KEY_SIZE );
_dvdcss_debug( dvdcss, "file was unscrambled" ); print_debug( dvdcss, "no scrambled sectors found" );
return 0; return 0;
} }

63
libmpdvdkit2/device.c

@ -2,9 +2,6 @@
* device.h: DVD device access * device.h: DVD device access
***************************************************************************** *****************************************************************************
* Copyright (C) 1998-2002 VideoLAN * Copyright (C) 1998-2002 VideoLAN
*
* Modified for use with MPlayer, changes contained in libdvdcss_changes.diff.
* detailed CVS changelog at http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
* $Id$ * $Id$
* *
* Authors: Stéphane Borel <stef@via.ecp.fr> * Authors: Stéphane Borel <stef@via.ecp.fr>
@ -34,11 +31,12 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
# include <errno.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> # include <unistd.h>
#include <limits.h> # include <limits.h>
#if defined( WIN32 ) && !defined( SYS_CYGWIN ) #if defined( WIN32 ) && !defined( SYS_CYGWIN )
# include <io.h> /* read() */ # include <io.h> /* read() */
@ -129,12 +127,9 @@ int _dvdcss_use_ioctls( dvdcss_t dvdcss )
int _dvdcss_open ( dvdcss_t dvdcss ) int _dvdcss_open ( dvdcss_t dvdcss )
{ {
char psz_debug[200];
char const *psz_device = dvdcss->psz_device; char const *psz_device = dvdcss->psz_device;
snprintf( psz_debug, 199, "opening target `%s'", psz_device ); print_debug( dvdcss, "opening target `%s'", psz_device );
psz_debug[199] = '\0';
_dvdcss_debug( dvdcss, psz_debug );
#if defined( WIN32 ) #if defined( WIN32 )
dvdcss->b_file = 1; dvdcss->b_file = 1;
@ -149,7 +144,7 @@ int _dvdcss_open ( dvdcss_t dvdcss )
if( !dvdcss->b_file && WIN2K ) if( !dvdcss->b_file && WIN2K )
{ {
_dvdcss_debug( dvdcss, "using Win2K API for access" ); print_debug( dvdcss, "using Win2K API for access" );
dvdcss->pf_seek = win2k_seek; dvdcss->pf_seek = win2k_seek;
dvdcss->pf_read = win2k_read; dvdcss->pf_read = win2k_read;
dvdcss->pf_readv = win_readv; dvdcss->pf_readv = win_readv;
@ -157,7 +152,7 @@ int _dvdcss_open ( dvdcss_t dvdcss )
} }
else if( !dvdcss->b_file ) else if( !dvdcss->b_file )
{ {
_dvdcss_debug( dvdcss, "using ASPI for access" ); print_debug( dvdcss, "using ASPI for access" );
dvdcss->pf_seek = aspi_seek; dvdcss->pf_seek = aspi_seek;
dvdcss->pf_read = aspi_read; dvdcss->pf_read = aspi_read;
dvdcss->pf_readv = win_readv; dvdcss->pf_readv = win_readv;
@ -166,7 +161,7 @@ int _dvdcss_open ( dvdcss_t dvdcss )
else else
#endif #endif
{ {
_dvdcss_debug( dvdcss, "using libc for access" ); print_debug( dvdcss, "using libc for access" );
dvdcss->pf_seek = libc_seek; dvdcss->pf_seek = libc_seek;
dvdcss->pf_read = libc_read; dvdcss->pf_read = libc_read;
dvdcss->pf_readv = libc_readv; dvdcss->pf_readv = libc_readv;
@ -181,7 +176,9 @@ int _dvdcss_raw_open ( dvdcss_t dvdcss, char const *psz_device )
if( dvdcss->i_raw_fd == -1 ) if( dvdcss->i_raw_fd == -1 )
{ {
_dvdcss_error( dvdcss, "failed opening raw device, continuing" ); print_debug( dvdcss, "cannot open %s (%s)",
psz_device, strerror(errno) );
print_error( dvdcss, "failed to open raw device, but continuing" );
return -1; return -1;
} }
else else
@ -250,7 +247,9 @@ static int libc_open ( dvdcss_t dvdcss, char const *psz_device )
if( dvdcss->i_fd == -1 ) if( dvdcss->i_fd == -1 )
{ {
_dvdcss_error( dvdcss, "failed opening device" ); print_debug( dvdcss, "cannot open %s (%s)",
psz_device, strerror(errno) );
print_error( dvdcss, "failed to open device" );
return -1; return -1;
} }
@ -287,7 +286,7 @@ static int win2k_open ( dvdcss_t dvdcss, char const *psz_device )
if( (HANDLE) dvdcss->i_fd == INVALID_HANDLE_VALUE ) if( (HANDLE) dvdcss->i_fd == INVALID_HANDLE_VALUE )
{ {
_dvdcss_error( dvdcss, "failed opening device" ); print_error( dvdcss, "failed opening device" );
return -1; return -1;
} }
@ -310,7 +309,7 @@ static int aspi_open( dvdcss_t dvdcss, char const * psz_device )
hASPI = LoadLibrary( "wnaspi32.dll" ); hASPI = LoadLibrary( "wnaspi32.dll" );
if( hASPI == NULL ) if( hASPI == NULL )
{ {
_dvdcss_error( dvdcss, "unable to load wnaspi32.dll" ); print_error( dvdcss, "unable to load wnaspi32.dll" );
return -1; return -1;
} }
@ -319,7 +318,7 @@ static int aspi_open( dvdcss_t dvdcss, char const * psz_device )
if(lpGetSupport == NULL || lpSendCommand == NULL ) if(lpGetSupport == NULL || lpSendCommand == NULL )
{ {
_dvdcss_error( dvdcss, "unable to get aspi function pointers" ); print_error( dvdcss, "unable to get aspi function pointers" );
FreeLibrary( hASPI ); FreeLibrary( hASPI );
return -1; return -1;
} }
@ -328,14 +327,14 @@ static int aspi_open( dvdcss_t dvdcss, char const * psz_device )
if( HIBYTE( LOWORD ( dwSupportInfo ) ) == SS_NO_ADAPTERS ) if( HIBYTE( LOWORD ( dwSupportInfo ) ) == SS_NO_ADAPTERS )
{ {
_dvdcss_error( dvdcss, "no ASPI adapters found" ); print_error( dvdcss, "no ASPI adapters found" );
FreeLibrary( hASPI ); FreeLibrary( hASPI );
return -1; return -1;
} }
if( HIBYTE( LOWORD ( dwSupportInfo ) ) != SS_COMP ) if( HIBYTE( LOWORD ( dwSupportInfo ) ) != SS_COMP )
{ {
_dvdcss_error( dvdcss, "unable to initalize aspi layer" ); print_error( dvdcss, "unable to initalize aspi layer" );
FreeLibrary( hASPI ); FreeLibrary( hASPI );
return -1; return -1;
} }
@ -343,7 +342,7 @@ static int aspi_open( dvdcss_t dvdcss, char const * psz_device )
i_hostadapters = LOBYTE( LOWORD( dwSupportInfo ) ); i_hostadapters = LOBYTE( LOWORD( dwSupportInfo ) );
if( i_hostadapters == 0 ) if( i_hostadapters == 0 )
{ {
_dvdcss_error( dvdcss, "no ASPI adapters ready" ); print_error( dvdcss, "no ASPI adapters ready" );
FreeLibrary( hASPI ); FreeLibrary( hASPI );
return -1; return -1;
} }
@ -351,7 +350,7 @@ static int aspi_open( dvdcss_t dvdcss, char const * psz_device )
fd = malloc( sizeof( struct w32_aspidev ) ); fd = malloc( sizeof( struct w32_aspidev ) );
if( fd == NULL ) if( fd == NULL )
{ {
_dvdcss_error( dvdcss, "not enough memory" ); print_error( dvdcss, "not enough memory" );
FreeLibrary( hASPI ); FreeLibrary( hASPI );
return -1; return -1;
} }
@ -402,7 +401,7 @@ static int aspi_open( dvdcss_t dvdcss, char const * psz_device )
{ {
free( (void*) fd ); free( (void*) fd );
FreeLibrary( hASPI ); FreeLibrary( hASPI );
_dvdcss_error( dvdcss,"this is not a cdrom drive" ); print_error( dvdcss,"this is not a cdrom drive" );
return -1; return -1;
} }
} }
@ -411,7 +410,7 @@ static int aspi_open( dvdcss_t dvdcss, char const * psz_device )
free( (void*) fd ); free( (void*) fd );
FreeLibrary( hASPI ); FreeLibrary( hASPI );
_dvdcss_error( dvdcss, "unable to get haid and target (aspi)" ); print_error( dvdcss, "unable to get haid and target (aspi)" );
return -1; return -1;
} }
#endif #endif
@ -429,12 +428,12 @@ static int libc_seek( dvdcss_t dvdcss, int i_blocks )
return i_blocks; return i_blocks;
} }
i_seek = lseek( dvdcss->i_read_fd, i_seek = (off_t)i_blocks * (off_t)DVDCSS_BLOCK_SIZE;
(off_t)i_blocks * (off_t)DVDCSS_BLOCK_SIZE, SEEK_SET ); i_seek = lseek( dvdcss->i_read_fd, i_seek, SEEK_SET );
if( i_seek < 0 ) if( i_seek < 0 )
{ {
_dvdcss_error( dvdcss, "seek error" ); print_error( dvdcss, "seek error" );
dvdcss->i_pos = -1; dvdcss->i_pos = -1;
return i_seek; return i_seek;
} }
@ -511,20 +510,20 @@ static int aspi_seek( dvdcss_t dvdcss, int i_blocks )
*****************************************************************************/ *****************************************************************************/
static int libc_read ( dvdcss_t dvdcss, void *p_buffer, int i_blocks ) static int libc_read ( dvdcss_t dvdcss, void *p_buffer, int i_blocks )
{ {
off_t i_ret; off_t i_size, i_ret;
i_ret = read( dvdcss->i_read_fd, p_buffer, i_size = (off_t)i_blocks * (off_t)DVDCSS_BLOCK_SIZE;
(off_t)i_blocks * DVDCSS_BLOCK_SIZE ); i_ret = read( dvdcss->i_read_fd, p_buffer, i_size );
if( i_ret < 0 ) if( i_ret < 0 )
{ {
_dvdcss_error( dvdcss, "read error" ); print_error( dvdcss, "read error" );
dvdcss->i_pos = -1; dvdcss->i_pos = -1;
return i_ret; return i_ret;
} }
/* Handle partial reads */ /* Handle partial reads */
if( i_ret != (off_t)i_blocks * DVDCSS_BLOCK_SIZE ) if( i_ret != i_size )
{ {
int i_seek; int i_seek;
@ -667,7 +666,7 @@ static int win_readv ( dvdcss_t dvdcss, struct iovec *p_iovec, int i_blocks )
dvdcss->p_readv_buffer = malloc( dvdcss->i_readv_buf_size ); dvdcss->p_readv_buffer = malloc( dvdcss->i_readv_buf_size );
if( !dvdcss->p_readv_buffer ) if( !dvdcss->p_readv_buffer )
{ {
_dvdcss_error( dvdcss, " failed (readv)" ); print_error( dvdcss, " failed (readv)" );
dvdcss->i_pos = -1; dvdcss->i_pos = -1;
return -1; return -1;
} }

5
libmpdvdkit2/dvdcss.h

@ -10,9 +10,6 @@
/* /*
* Copyright (C) 1998-2002 VideoLAN * Copyright (C) 1998-2002 VideoLAN
*
* Modified for use with MPlayer, changes contained in libdvdcss_changes.diff.
* detailed CVS changelog at http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
* $Id$ * $Id$
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
@ -70,8 +67,6 @@ extern char * dvdcss_interface_2;
*/ */
extern dvdcss_t dvdcss_open ( char *psz_target ); extern dvdcss_t dvdcss_open ( char *psz_target );
extern int dvdcss_close ( dvdcss_t ); extern int dvdcss_close ( dvdcss_t );
extern int dvdcss_title ( dvdcss_t,
int i_block );
extern int dvdcss_seek ( dvdcss_t, extern int dvdcss_seek ( dvdcss_t,
int i_blocks, int i_blocks,
int i_flags ); int i_flags );

11
libmpdvdkit2/error.c

@ -2,9 +2,6 @@
* error.c: error management functions * error.c: error management functions
***************************************************************************** *****************************************************************************
* Copyright (C) 1998-2002 VideoLAN * Copyright (C) 1998-2002 VideoLAN
*
* Modified for use with MPlayer, changes contained in libdvdcss_changes.diff.
* detailed CVS changelog at http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
* $Id$ * $Id$
* *
* Author: Samuel Hocevar <sam@zoy.org> * Author: Samuel Hocevar <sam@zoy.org>
@ -28,7 +25,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <limits.h> # include <limits.h>
#include "dvdcss.h" #include "dvdcss.h"
@ -39,7 +36,7 @@
/***************************************************************************** /*****************************************************************************
* Error messages * Error messages
*****************************************************************************/ *****************************************************************************/
void _dvdcss_error( dvdcss_t dvdcss, char *psz_string ) void _print_error( dvdcss_t dvdcss, char *psz_string )
{ {
if( dvdcss->b_errors ) if( dvdcss->b_errors )
{ {
@ -52,11 +49,13 @@ void _dvdcss_error( dvdcss_t dvdcss, char *psz_string )
/***************************************************************************** /*****************************************************************************
* Debug messages * Debug messages
*****************************************************************************/ *****************************************************************************/
void _dvdcss_debug( dvdcss_t dvdcss, char *psz_string ) #if 0
void _print_debug( dvdcss_t dvdcss, char *psz_string )
{ {
if( dvdcss->b_debug ) if( dvdcss->b_debug )
{ {
fprintf( stderr, "libdvdcss debug: %s\n", psz_string ); fprintf( stderr, "libdvdcss debug: %s\n", psz_string );
} }
} }
#endif

65
libmpdvdkit2/ioctl.c

@ -2,9 +2,6 @@
* ioctl.c: DVD ioctl replacement function * ioctl.c: DVD ioctl replacement function
***************************************************************************** *****************************************************************************
* Copyright (C) 1999-2001 VideoLAN * Copyright (C) 1999-2001 VideoLAN
*
* Modified for use with MPlayer, changes contained in libdvdcss_changes.diff.
* detailed CVS changelog at http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
* $Id$ * $Id$
* *
* Authors: Markus Kuespert <ltlBeBoy@beosmail.com> * Authors: Markus Kuespert <ltlBeBoy@beosmail.com>
@ -1912,43 +1909,59 @@ static void SolarisInitUSCSI( struct uscsi_cmd *p_sc, int i_type )
* for execution * for execution
***************************************************************************** *****************************************************************************
* When available, this function uses the function smedia_uscsi_cmd() * When available, this function uses the function smedia_uscsi_cmd()
* from solaris' libsmedia library (solaris 9 or newer) to execute the * from Solaris' libsmedia library (Solaris 9 or newer) to execute the
* USCSI command. smedia_uscsi_cmd() allows USCSI commands for * USCSI command. smedia_uscsi_cmd() allows USCSI commands for
* non-root users on removable media devices on solaris 9; sending the * non-root users on removable media devices on Solaris 9; sending the
* USCSI command directly to the device using the USCSICMD ioctl fails * USCSI command directly to the device using the USCSICMD ioctl fails
* with an EPERM error on solaris 9. * with an EPERM error on Solaris 9.
* *
* The code will fall back to the USCSICMD ioctl method, when * The code will fall back to the USCSICMD ioctl method, when
* libsmedia.so is not available or does not export the * libsmedia.so is not available or does not export the
* smedia_uscsi_cmd() function (on solaris releases upto and including * smedia_uscsi_cmd() function (on Solaris releases upto and including
* solaris 8). Fortunatelly, on these old releases non-root users are * Solaris 8). Fortunatelly, on these old releases non-root users are
* allowed to perform USCSICMD ioctls on removable media devices. * allowed to perform USCSICMD ioctls on removable media devices.
*****************************************************************************/ *****************************************************************************/
static int SolarisSendUSCSI( int i_fd, struct uscsi_cmd *p_sc ) { static int SolarisSendUSCSI( int i_fd, struct uscsi_cmd *p_sc )
void *sm_hdl; {
static int initialized; void *p_handle;
static void* (*sm_get_handle)(int32_t);
static int (*sm_release_handle)(void*);
static int (*sm_uscsi_cmd)(void*, struct uscsi_cmd *);
if (!initialized) /* We use static variables to keep track of the libsmedia symbols, which
* is harmless even in a multithreaded program because the library and
* its symbols will always be mapped at the same address. */
static int b_tried = 0;
static int b_have_sm = 0;
static void * (*p_get_handle) ( int32_t );
static int (*p_uscsi_cmd) ( void *, struct uscsi_cmd * );
static int (*p_release_handle) ( void * );
if( !b_tried )
{ {
void *smedia_lib; void *p_lib;
smedia_lib = dlopen("libsmedia.so", RTLD_NOW); p_lib = dlopen( "libsmedia.so", RTLD_NOW );
if (smedia_lib) { if( p_lib )
sm_get_handle = dlsym(smedia_lib, "smedia_get_handle"); {
sm_release_handle = dlsym(smedia_lib, "smedia_release_handle"); p_get_handle = dlsym( p_lib, "smedia_get_handle" );
sm_uscsi_cmd = dlsym(smedia_lib, "smedia_uscsi_cmd"); p_uscsi_cmd = dlsym( p_lib, "smedia_uscsi_cmd" );
p_release_handle = dlsym( p_lib, "smedia_release_handle" );
if( p_get_handle && p_uscsi_cmd && p_release_handle )
{
b_have_sm = 1;
}
else
{
dlclose( p_lib );
} }
initialized = 1;
} }
if (sm_get_handle && sm_uscsi_cmd && sm_release_handle b_tried = 1;
&& (sm_hdl = sm_get_handle(i_fd))) }
if( b_have_sm && (p_handle = p_get_handle(i_fd)) )
{ {
int i_ret = sm_uscsi_cmd(sm_hdl, p_sc); int i_ret = p_uscsi_cmd( p_handle, p_sc );
sm_release_handle(sm_hdl); p_release_handle( p_handle );
return i_ret; return i_ret;
} }

154
libmpdvdkit2/libdvdcss.c

@ -5,9 +5,6 @@
* Håkan Hjort <d95hjort@dtek.chalmers.se> * Håkan Hjort <d95hjort@dtek.chalmers.se>
* *
* Copyright (C) 1998-2002 VideoLAN * Copyright (C) 1998-2002 VideoLAN
*
* Modified for use with MPlayer, changes contained in libdvdcss_changes.diff.
* detailed CVS changelog at http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
* $Id$ * $Id$
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
@ -25,7 +22,7 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*/ */
/* /**
* \mainpage libdvdcss developer documentation * \mainpage libdvdcss developer documentation
* *
* \section intro Introduction * \section intro Introduction
@ -105,8 +102,8 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <errno.h> #include <errno.h>
#include <unistd.h> # include <unistd.h>
#include <limits.h> # include <limits.h>
#include "dvdcss.h" #include "dvdcss.h"
@ -192,7 +189,7 @@ extern dvdcss_t dvdcss_open ( char *psz_target )
{ {
int i = atoi( psz_verbose ); int i = atoi( psz_verbose );
if( i >= 2 ) dvdcss->b_debug = 1; if( i >= 2 ) dvdcss->b_debug = i;
if( i >= 1 ) dvdcss->b_errors = 1; if( i >= 1 ) dvdcss->b_errors = 1;
} }
@ -215,7 +212,7 @@ extern dvdcss_t dvdcss_open ( char *psz_target )
} }
else else
{ {
_dvdcss_error( dvdcss, "unknown decrypt method, please choose " print_error( dvdcss, "unknown decrypt method, please choose "
"from 'title', 'key' or 'disc'" ); "from 'title', 'key' or 'disc'" );
free( dvdcss->psz_device ); free( dvdcss->psz_device );
free( dvdcss ); free( dvdcss );
@ -223,19 +220,100 @@ extern dvdcss_t dvdcss_open ( char *psz_target )
} }
} }
#if 0 /* MPlayer caches keys in its own configuration directory */
/*
* If DVDCSS_CACHE was not set, try to guess a default value
*/
if( psz_cache == NULL || psz_cache[0] == '\0' )
{
#ifdef HAVE_DIRECT_H
typedef HRESULT( WINAPI *SHGETFOLDERPATH )
( HWND, int, HANDLE, DWORD, LPTSTR );
# define CSIDL_FLAG_CREATE 0x8000
# define CSIDL_APPDATA 0x1A
# define SHGFP_TYPE_CURRENT 0
char psz_home[MAX_PATH];
HINSTANCE p_dll;
SHGETFOLDERPATH p_getpath;
*psz_home = '\0';
/* Load the shfolder dll to retrieve SHGetFolderPath */
p_dll = LoadLibrary( "shfolder.dll" );
if( p_dll )
{
p_getpath = (void*)GetProcAddress( p_dll, "SHGetFolderPathA" );
if( p_getpath )
{
/* Get the "Application Data" folder for the current user */
if( p_getpath( NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE,
NULL, SHGFP_TYPE_CURRENT, psz_home ) == S_OK )
{
FreeLibrary( p_dll );
}
else
{
*psz_home = '\0';
}
}
FreeLibrary( p_dll );
}
/* Cache our keys in
* C:\Documents and Settings\$USER\Application Data\dvdcss\ */
if( *psz_home )
{
snprintf( psz_buffer, PATH_MAX, "%s/dvdcss", psz_home );
psz_buffer[PATH_MAX-1] = '\0';
psz_cache = psz_buffer;
}
#else
char *psz_home = NULL;
# ifdef HAVE_PWD_H
struct passwd *p_pwd;
/* Try looking in password file for home dir. */
p_pwd = getpwuid(getuid());
if( p_pwd )
{
psz_home = p_pwd->pw_dir;
}
# endif
if( psz_home == NULL )
{
psz_home = getenv( "HOME" );
}
/* Cache our keys in ${HOME}/.dvdcss/ */
if( psz_home )
{
snprintf( psz_buffer, PATH_MAX, "%s/.dvdcss", psz_home );
psz_buffer[PATH_MAX-1] = '\0';
psz_cache = psz_buffer;
}
#endif
}
#endif /* 0 */
/* /*
* Find cache dir from the DVDCSS_CACHE environment variable * Find cache dir from the DVDCSS_CACHE environment variable
*/ */
if( psz_cache != NULL ) if( psz_cache != NULL )
{ {
if( psz_cache[0] == '\0' ) if( psz_cache[0] == '\0' || !strcmp( psz_cache, "off" ) )
{ {
psz_cache = NULL; psz_cache = NULL;
} }
/* Check that we can add the ID directory and the block filename */ /* Check that we can add the ID directory and the block filename */
else if( strlen( psz_cache ) + 1 + 32 + 1 + 10 + 1 > PATH_MAX ) else if( strlen( psz_cache ) + 1 + 32 + 1 + (KEY_SIZE * 2) + 10 + 1
> PATH_MAX )
{ {
_dvdcss_error( dvdcss, "cache directory name is too long" ); print_error( dvdcss, "cache directory name is too long" );
psz_cache = NULL; psz_cache = NULL;
} }
} }
@ -261,13 +339,13 @@ extern dvdcss_t dvdcss_open ( char *psz_target )
if( i_ret < 0 ) if( i_ret < 0 )
{ {
/* Disable the CSS ioctls and hope that it works? */ /* Disable the CSS ioctls and hope that it works? */
_dvdcss_debug( dvdcss, print_debug( dvdcss,
"could not check whether the disc was scrambled" ); "could not check whether the disc was scrambled" );
dvdcss->b_ioctls = 0; dvdcss->b_ioctls = 0;
} }
else else
{ {
_dvdcss_debug( dvdcss, i_ret ? "disc is scrambled" print_debug( dvdcss, i_ret ? "disc is scrambled"
: "disc is unscrambled" ); : "disc is unscrambled" );
dvdcss->b_scrambled = i_ret; dvdcss->b_scrambled = i_ret;
} }
@ -287,11 +365,31 @@ extern dvdcss_t dvdcss_open ( char *psz_target )
} }
} }
/* If the cache is enabled, write the cache directory tag */
if( psz_cache )
{
char *psz_tag = "Signature: 8a477f597d28d172789f06886806bc55\r\n"
"# This file is a cache directory tag created by libdvdcss.\r\n"
"# For information about cache directory tags, see:\r\n"
"# http://www.brynosaurus.com/cachedir/\r\n";
unsigned char psz_tagfile[PATH_MAX+1+12+1];
int i_fd;
sprintf( psz_tagfile, "%s/CACHEDIR.TAG", psz_cache );
i_fd = open( psz_tagfile, O_RDWR|O_CREAT, 0644 );
if( i_fd >= 0 )
{
write( i_fd, psz_tag, strlen(psz_tag) );
close( i_fd );
}
}
/* If the cache is enabled, extract a unique disc ID */ /* If the cache is enabled, extract a unique disc ID */
if( psz_cache ) if( psz_cache )
{ {
uint8_t p_sector[DVDCSS_BLOCK_SIZE]; uint8_t p_sector[DVDCSS_BLOCK_SIZE];
unsigned char psz_debug[PATH_MAX+30]; unsigned char psz_debug[PATH_MAX+30];
unsigned char psz_key[1 + KEY_SIZE * 2 + 1];
unsigned char * psz_title, * psz_serial; unsigned char * psz_title, * psz_serial;
int i; int i;
@ -358,15 +456,33 @@ extern dvdcss_t dvdcss_open ( char *psz_target )
{ {
if( psz_serial[i] < '0' || psz_serial[i] > '9' ) if( psz_serial[i] < '0' || psz_serial[i] > '9' )
{ {
sprintf( psz_serial, unsigned char psz_tmp[16 + 1];
"%.2X%.2X%.2X%.2X%.2X%.2X%.2X%.2X", sprintf( psz_tmp,
"%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x",
psz_serial[0], psz_serial[1], psz_serial[2], psz_serial[0], psz_serial[1], psz_serial[2],
psz_serial[3], psz_serial[4], psz_serial[5], psz_serial[3], psz_serial[4], psz_serial[5],
psz_serial[6], psz_serial[7] ); psz_serial[6], psz_serial[7] );
memcpy( psz_serial, psz_tmp, 16 );
break; break;
} }
} }
/* Get disk key, since some discs have got same title, manufacturing
* date and serial number, but different keys */
if( dvdcss->b_scrambled )
{
psz_key[0] = '-';
for( i = 0; i < KEY_SIZE; i++ )
{
sprintf( &psz_key[1+i*2], "%.2x", dvdcss->css.p_disc_key[i] );
}
psz_key[1 + KEY_SIZE * 2] = '\0';
}
else
{
psz_key[0] = 0;
}
/* We have a disc name or ID, we can create the cache dir */ /* We have a disc name or ID, we can create the cache dir */
i = sprintf( dvdcss->psz_cachefile, "%s", psz_cache ); i = sprintf( dvdcss->psz_cachefile, "%s", psz_cache );
#if !defined( WIN32 ) || defined( SYS_CYGWIN ) #if !defined( WIN32 ) || defined( SYS_CYGWIN )
@ -376,7 +492,7 @@ extern dvdcss_t dvdcss_open ( char *psz_target )
#endif #endif
if( i_ret < 0 && errno != EEXIST ) if( i_ret < 0 && errno != EEXIST )
{ {
_dvdcss_error( dvdcss, "failed creating cache directory" ); print_error( dvdcss, "failed creating cache directory" );
dvdcss->psz_cachefile[0] = '\0'; dvdcss->psz_cachefile[0] = '\0';
goto nocache; goto nocache;
} }
@ -391,7 +507,7 @@ extern dvdcss_t dvdcss_open ( char *psz_target )
#endif #endif
if( i_ret < 0 && errno != EEXIST ) if( i_ret < 0 && errno != EEXIST )
{ {
_dvdcss_error( dvdcss, "failed creating cache subdirectory" ); print_error( dvdcss, "failed creating cache subdirectory" );
dvdcss->psz_cachefile[0] = '\0'; dvdcss->psz_cachefile[0] = '\0';
goto nocache; goto nocache;
} }
@ -402,7 +518,7 @@ extern dvdcss_t dvdcss_open ( char *psz_target )
sprintf( psz_debug, "using CSS key cache dir: %s", sprintf( psz_debug, "using CSS key cache dir: %s",
dvdcss->psz_cachefile ); dvdcss->psz_cachefile );
_dvdcss_debug( dvdcss, psz_debug ); print_debug( dvdcss, psz_debug );
} }
nocache: nocache:
@ -522,7 +638,7 @@ extern int dvdcss_read ( dvdcss_t dvdcss, void *p_buffer,
{ {
if( ((uint8_t*)p_buffer)[0x14] & 0x30 ) if( ((uint8_t*)p_buffer)[0x14] & 0x30 )
{ {
_dvdcss_error( dvdcss, "no key but found encrypted block" ); print_error( dvdcss, "no key but found encrypted block" );
/* Only return the initial range of unscrambled blocks? */ /* Only return the initial range of unscrambled blocks? */
/* or fail completely? return 0; */ /* or fail completely? return 0; */
break; break;

12
libmpdvdkit2/libdvdcss.h

@ -77,6 +77,14 @@ struct dvdcss_s
/***************************************************************************** /*****************************************************************************
* Functions used across the library * Functions used across the library
*****************************************************************************/ *****************************************************************************/
void _dvdcss_error ( dvdcss_t, char * ); #define print_error(dvdcss,msg) _print_error(dvdcss,msg)
void _dvdcss_debug ( dvdcss_t, char * ); #define print_debug(dvdcss,msg,args...) \
if( dvdcss->b_debug ) \
{ \
fprintf( stderr, "libdvdcss debug: " ); \
fprintf( stderr, msg, ##args ); \
fprintf( stderr, "\n" ); \
}
void _print_error ( dvdcss_t, char * );

453
libmpdvdkit2/libdvdcss_changes.diff

@ -1,17 +1,6 @@
--- bsdi_ioctl.c 2003-03-10 00:34:10.000000000 +0100
+++ bsdi_ioctl.c 2005-03-01 07:41:41.000000000 +0100
@@ -694,7 +698,7 @@
struct cdrom_tocentry entry;
int ret, i;
- bzero(tracks, sizeof (*tracks));
+ memset(tracks, 0, sizeof (*tracks));
ret = cdrom_ioctl(fd, CDROMREADTOCHDR, &header);
/*
* This whole business is a crock anyhow so we don't bother distinguishing
--- common.h 2003-06-13 19:33:35.000000000 +0200 --- common.h 2003-06-13 19:33:35.000000000 +0200
+++ common.h 2005-03-01 07:41:41.000000000 +0100 +++ common.h 2005-03-01 07:41:41.000000000 +0100
@@ -27,21 +30,10 @@ @@ -27,21 +27,10 @@
/***************************************************************************** /*****************************************************************************
* Basic types definitions * Basic types definitions
*****************************************************************************/ *****************************************************************************/
@ -37,9 +26,9 @@
#endif #endif
#if defined( WIN32 ) #if defined( WIN32 )
--- css.c 2003-07-29 01:37:06.000000000 +0200 --- css.c 2005-07-11 14:24:09.000000000 +0200
+++ css.c 2005-03-01 07:41:41.000000000 +0100 +++ css.c 2005-10-01 19:02:35.000000000 +0200
@@ -40,19 +43,11 @@ @@ -41,19 +41,11 @@
#include <string.h> #include <string.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
@ -47,25 +36,28 @@
-# include <sys/param.h> -# include <sys/param.h>
-#endif -#endif
-#ifdef HAVE_UNISTD_H -#ifdef HAVE_UNISTD_H
-# include <unistd.h> # include <unistd.h>
-#endif -#endif
#include <fcntl.h> #include <fcntl.h>
+#include <unistd.h>
+#include <limits.h>
-#ifdef HAVE_LIMITS_H
-# include <limits.h>
-#endif
- -
-#ifdef HAVE_LIMITS_H
# include <limits.h>
-#endif
-#include "dvdcss/dvdcss.h" -#include "dvdcss/dvdcss.h"
+#include "dvdcss.h" +#include "dvdcss.h"
#include "common.h" #include "common.h"
#include "css.h" #include "css.h"
--- dvdcss/device.c 2005-06-07 19:22:40.181853664 +0200 --- device.c 2005-07-11 13:33:34.000000000 +0200
+++ device.c 2005-06-07 15:36:21.000000000 +0200 +++ device.c 2005-10-01 19:08:07.000000000 +0200
@@ -33,18 +36,9 @@ @@ -31,23 +31,12 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
-#ifdef HAVE_ERRNO_H
# include <errno.h>
-#endif
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
-#ifdef HAVE_SYS_PARAM_H -#ifdef HAVE_SYS_PARAM_H
@ -74,18 +66,16 @@
#include <fcntl.h> #include <fcntl.h>
- -
-#ifdef HAVE_UNISTD_H -#ifdef HAVE_UNISTD_H
-# include <unistd.h> # include <unistd.h>
-#endif -#endif
- -
-#ifdef HAVE_LIMITS_H -#ifdef HAVE_LIMITS_H
-# include <limits.h> # include <limits.h>
-#endif -#endif
+#include <unistd.h>
+#include <limits.h>
#if defined( WIN32 ) && !defined( SYS_CYGWIN ) #if defined( WIN32 ) && !defined( SYS_CYGWIN )
# include <io.h> /* read() */ # include <io.h> /* read() */
@@ -52,7 +46,7 @@ @@ -55,7 +44,7 @@
# include <sys/uio.h> /* struct iovec */ # include <sys/uio.h> /* struct iovec */
#endif #endif
@ -94,8 +84,8 @@
#include "common.h" #include "common.h"
#include "css.h" #include "css.h"
@@ -143,8 +137,11 @@ @@ -143,8 +132,11 @@
_dvdcss_debug( dvdcss, psz_debug ); print_debug( dvdcss, "opening target `%s'", psz_device );
#if defined( WIN32 ) #if defined( WIN32 )
- /* If device is not "X:", we are actually opening a file. */ - /* If device is not "X:", we are actually opening a file. */
@ -108,259 +98,29 @@
/* Initialize readv temporary buffer */ /* Initialize readv temporary buffer */
dvdcss->p_readv_buffer = NULL; dvdcss->p_readv_buffer = NULL;
@@ -276,14 +273,14 @@ --- error.c 2004-02-24 16:46:49.000000000 +0100
* won't send back the right result). +++ error.c 2005-10-01 19:10:06.000000000 +0200
* (See Microsoft Q241374: Read and Write Access Required for SCSI @@ -25,16 +25,9 @@
* Pass Through Requests) */
- (HANDLE) dvdcss->i_fd =
+ dvdcss->i_fd = (int)
CreateFile( psz_dvd, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING,
FILE_FLAG_RANDOM_ACCESS, NULL );
if( (HANDLE) dvdcss->i_fd == INVALID_HANDLE_VALUE )
- (HANDLE) dvdcss->i_fd =
+ dvdcss->i_fd = (int)
CreateFile( psz_dvd, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING,
FILE_FLAG_RANDOM_ACCESS, NULL );
@@ -305,8 +302,8 @@
DWORD dwSupportInfo;
struct w32_aspidev *fd;
int i, j, i_hostadapters;
- long (*lpGetSupport)( void );
- long (*lpSendCommand)( void* );
+ GETASPI32SUPPORTINFO lpGetSupport;
+ SENDASPI32COMMAND lpSendCommand;
char c_drive = psz_device[0];
/* load aspi and init w32_aspidev structure */
@@ -317,8 +314,8 @@
return -1;
}
- (FARPROC) lpGetSupport = GetProcAddress( hASPI, "GetASPI32SupportInfo" );
- (FARPROC) lpSendCommand = GetProcAddress( hASPI, "SendASPI32Command" );
+ lpGetSupport = (GETASPI32SUPPORTINFO) GetProcAddress( hASPI, "GetASPI32SupportInfo" );
+ lpSendCommand = (SENDASPI32COMMAND) GetProcAddress( hASPI, "SendASPI32Command" );
if(lpGetSupport == NULL || lpSendCommand == NULL )
{
--- error.c 2003-03-10 01:15:31.000000000 +0100
+++ error.c 2005-03-01 07:41:41.000000000 +0100
@@ -25,16 +28,9 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
+#include <limits.h> -
-#ifdef HAVE_SYS_PARAM_H -#ifdef HAVE_SYS_PARAM_H
-# include <sys/param.h> -# include <sys/param.h>
-#endif -#endif
- -
-#ifdef HAVE_LIMITS_H -#ifdef HAVE_LIMITS_H
-# include <limits.h> # include <limits.h>
-#endif -#endif
-
-#include "dvdcss/dvdcss.h" -#include "dvdcss/dvdcss.h"
+#include "dvdcss.h" +#include "dvdcss.h"
#include "common.h" #include "common.h"
#include "css.h" #include "css.h"
--- ioctl.c 2003-03-10 00:34:10.000000000 +0100 --- libdvdcss.c 2004-08-13 15:40:18.000000000 +0200
+++ ioctl.c 2005-03-01 07:41:41.000000000 +0100 +++ libdvdcss.c 2005-10-01 19:11:27.000000000 +0200
@@ -76,6 +79,7 @@ @@ -87,10 +87,7 @@
# include <sys/scsi.h>
#endif
#ifdef SOLARIS_USCSI
+# include <dlfcn.h>
# include <unistd.h>
# include <stropts.h>
# include <sys/scsi/scsi_types.h>
@@ -112,6 +116,7 @@
*****************************************************************************/
#if defined( SOLARIS_USCSI )
static void SolarisInitUSCSI( struct uscsi_cmd *p_sc, int i_type );
+static int SolarisSendUSCSI( int fd, struct uscsi_cmd *p_sc );
#endif
/*****************************************************************************
@@ -192,7 +197,7 @@
rs_cdb.cdb_opaque[ 6 ] = i_layer;
rs_cdb.cdb_opaque[ 7 ] = DVD_STRUCT_COPYRIGHT;
- i_ret = ioctl(i_fd, USCSICMD, &sc);
+ i_ret = SolarisSendUSCSI(i_fd, &sc);
if( i_ret < 0 || sc.uscsi_status ) {
i_ret = -1;
@@ -351,7 +356,7 @@
rs_cdb.cdb_opaque[ 7 ] = DVD_STRUCT_DISCKEY;
rs_cdb.cdb_opaque[ 10 ] = *pi_agid << 6;
- i_ret = ioctl( i_fd, USCSICMD, &sc );
+ i_ret = SolarisSendUSCSI( i_fd, &sc );
if( i_ret < 0 || sc.uscsi_status )
{
@@ -513,7 +518,7 @@
rs_cdb.cdb_opaque[ 5 ] = ( i_pos ) & 0xff;
rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_TITLE_KEY | (*pi_agid << 6);
- i_ret = ioctl( i_fd, USCSICMD, &sc );
+ i_ret = SolarisSendUSCSI( i_fd, &sc );
if( i_ret < 0 || sc.uscsi_status )
{
@@ -665,7 +670,7 @@
rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_AGID | (*pi_agid << 6);
- i_ret = ioctl( i_fd, USCSICMD, &sc );
+ i_ret = SolarisSendUSCSI( i_fd, &sc );
if( i_ret < 0 || sc.uscsi_status )
{
@@ -787,7 +792,7 @@
rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_CHALLENGE | (*pi_agid << 6);
- i_ret = ioctl( i_fd, USCSICMD, &sc );
+ i_ret = SolarisSendUSCSI( i_fd, &sc );
if( i_ret < 0 || sc.uscsi_status )
{
@@ -921,7 +926,7 @@
rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_ASF;
- i_ret = ioctl( i_fd, USCSICMD, &sc );
+ i_ret = SolarisSendUSCSI( i_fd, &sc );
if( i_ret < 0 || sc.uscsi_status )
{
@@ -1054,7 +1059,7 @@
rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_KEY1 | (*pi_agid << 6);
- i_ret = ioctl( i_fd, USCSICMD, &sc );
+ i_ret = SolarisSendUSCSI( i_fd, &sc );
if( i_ret < 0 || sc.uscsi_status )
{
@@ -1175,7 +1180,7 @@
rs_cdb.cdb_opaque[ 10 ] = DVD_INVALIDATE_AGID | (*pi_agid << 6);
- i_ret = ioctl( i_fd, USCSICMD, &sc );
+ i_ret = SolarisSendUSCSI( i_fd, &sc );
if( i_ret < 0 || sc.uscsi_status )
{
@@ -1299,7 +1304,7 @@
p_buffer[ 1 ] = 0xe;
memcpy( p_buffer + 4, p_challenge, DVD_CHALLENGE_SIZE );
- if( ioctl( i_fd, USCSICMD, &sc ) < 0 || sc.uscsi_status )
+ if( SolarisSendUSCSI( i_fd, &sc ) < 0 || sc.uscsi_status )
{
return -1;
}
@@ -1436,7 +1441,7 @@
p_buffer[ 1 ] = 0xa;
memcpy( p_buffer + 4, p_key, DVD_KEY_SIZE );
- if( ioctl( i_fd, USCSICMD, &sc ) < 0 || sc.uscsi_status )
+ if( SolarisSendUSCSI( i_fd, &sc ) < 0 || sc.uscsi_status )
{
return -1;
}
@@ -1578,7 +1583,7 @@
rs_cdb.cdb_opaque[ 10 ] = DVD_REPORT_RPC;
- i_ret = ioctl( i_fd, USCSICMD, &sc );
+ i_ret = SolarisSendUSCSI( i_fd, &sc );
if( i_ret < 0 || sc.uscsi_status )
{
@@ -1728,7 +1733,7 @@
p_buffer[ 1 ] = 6;
p_buffer[ 4 ] = i_pdrc;
- i_ret = ioctl( i_fd, USCSICMD, &sc );
+ i_ret = SolarisSendUSCSI( i_fd, &sc );
if( i_ret < 0 || sc.uscsi_status )
{
@@ -1901,6 +1906,54 @@
USCSI_TIMEOUT( p_sc, 15 );
}
+
+/*****************************************************************************
+ * SolarisSendUSCSI: send a USCSICMD structure to the Solaris kernel
+ * for execution
+ *****************************************************************************
+ * When available, this function uses the function smedia_uscsi_cmd()
+ * from solaris' libsmedia library (solaris 9 or newer) to execute the
+ * USCSI command. smedia_uscsi_cmd() allows USCSI commands for
+ * non-root users on removable media devices on solaris 9; sending the
+ * USCSI command directly to the device using the USCSICMD ioctl fails
+ * with an EPERM error on solaris 9.
+ *
+ * The code will fall back to the USCSICMD ioctl method, when
+ * libsmedia.so is not available or does not export the
+ * smedia_uscsi_cmd() function (on solaris releases upto and including
+ * solaris 8). Fortunatelly, on these old releases non-root users are
+ * allowed to perform USCSICMD ioctls on removable media devices.
+ *****************************************************************************/
+static int SolarisSendUSCSI( int i_fd, struct uscsi_cmd *p_sc ) {
+ void *sm_hdl;
+ static int initialized;
+ static void* (*sm_get_handle)(int32_t);
+ static int (*sm_release_handle)(void*);
+ static int (*sm_uscsi_cmd)(void*, struct uscsi_cmd *);
+
+ if (!initialized)
+ {
+ void *smedia_lib;
+
+ smedia_lib = dlopen("libsmedia.so", RTLD_NOW);
+ if (smedia_lib) {
+ sm_get_handle = dlsym(smedia_lib, "smedia_get_handle");
+ sm_release_handle = dlsym(smedia_lib, "smedia_release_handle");
+ sm_uscsi_cmd = dlsym(smedia_lib, "smedia_uscsi_cmd");
+ }
+ initialized = 1;
+ }
+
+ if (sm_get_handle && sm_uscsi_cmd && sm_release_handle
+ && (sm_hdl = sm_get_handle(i_fd)))
+ {
+ int i_ret = sm_uscsi_cmd(sm_hdl, p_sc);
+ sm_release_handle(sm_hdl);
+ return i_ret;
+ }
+
+ return ioctl( i_fd, USCSICMD, p_sc );
+}
#endif
#if defined( WIN32 )
--- libdvdcss.c 2003-06-22 16:08:53.000000000 +0200
+++ libdvdcss.c 2005-03-01 07:41:41.000000000 +0100
@@ -22,7 +25,7 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*/
-/**
+/*
* \mainpage libdvdcss developer documentation
*
* \section intro Introduction
@@ -87,10 +90,7 @@
* values. This will speed up descrambling of DVDs which are in the * values. This will speed up descrambling of DVDs which are in the
* cache. The DVDCSS_CACHE directory is created if it does not exist, * cache. The DVDCSS_CACHE directory is created if it does not exist,
* and a subdirectory is created named after the DVD's title or * and a subdirectory is created named after the DVD's title or
@ -372,7 +132,7 @@
*/ */
/* /*
@@ -103,28 +103,12 @@ @@ -103,28 +100,12 @@
#include <string.h> #include <string.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
@ -384,17 +144,15 @@
-#endif -#endif
#include <fcntl.h> #include <fcntl.h>
#include <errno.h> #include <errno.h>
+#include <unistd.h> -
+#include <limits.h>
-#ifdef HAVE_UNISTD_H -#ifdef HAVE_UNISTD_H
-# include <unistd.h> # include <unistd.h>
-#endif -#endif
- -
-#ifdef HAVE_LIMITS_H -#ifdef HAVE_LIMITS_H
-# include <limits.h> # include <limits.h>
-#endif -#endif
-
-#ifdef HAVE_DIRECT_H -#ifdef HAVE_DIRECT_H
-# include <direct.h> -# include <direct.h>
-#endif -#endif
@ -404,7 +162,7 @@
#include "common.h" #include "common.h"
#include "css.h" #include "css.h"
@@ -132,6 +116,12 @@ @@ -132,6 +113,12 @@
#include "ioctl.h" #include "ioctl.h"
#include "device.h" #include "device.h"
@ -417,96 +175,25 @@
/** /**
* \brief Symbol for version checks. * \brief Symbol for version checks.
* *
@@ -234,87 +224,11 @@ @@ -233,6 +220,8 @@
}
} }
+#if 0 /* MPlayer caches keys in its own configuration directory */
+
/*
* If DVDCSS_CACHE was not set, try to guess a default value
*/
@@ -309,6 +298,8 @@
#endif
}
+#endif /* 0 */
+
/* /*
- * If DVDCSS_CACHE was not set, try to guess a default value
- */
- if( psz_cache == NULL || psz_cache[0] == '\0' )
- {
-#ifdef HAVE_DIRECT_H
- typedef HRESULT( WINAPI *SHGETFOLDERPATH )
- ( HWND, int, HANDLE, DWORD, LPTSTR );
-
-# define CSIDL_FLAG_CREATE 0x8000
-# define CSIDL_APPDATA 0x1A
-# define SHGFP_TYPE_CURRENT 0
-
- char psz_home[MAX_PATH];
- HINSTANCE p_dll;
- SHGETFOLDERPATH p_getpath;
-
- *psz_home = '\0';
-
- /* Load the shfolder dll to retrieve SHGetFolderPath */
- p_dll = LoadLibrary( "shfolder.dll" );
- if( p_dll )
- {
- p_getpath = (void*)GetProcAddress( p_dll, "SHGetFolderPathA" );
- if( p_getpath )
- {
- /* Get the "Application Data" folder for the current user */
- if( p_getpath( NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE,
- NULL, SHGFP_TYPE_CURRENT, psz_home ) == S_OK )
- {
- FreeLibrary( p_dll );
- }
- else
- {
- *psz_home = '\0';
- }
- }
- FreeLibrary( p_dll );
- }
-
- /* Cache our keys in
- * C:\Documents and Settings\$USER\Application Data\dvdcss\ */
- if( *psz_home )
- {
- snprintf( psz_buffer, PATH_MAX, "%s/dvdcss", psz_home );
- psz_buffer[PATH_MAX-1] = '\0';
- psz_cache = psz_buffer;
- }
-#else
- char *psz_home = NULL;
-# ifdef HAVE_PWD_H
- struct passwd *p_pwd;
-
- /* Try looking in password file for home dir. */
- p_pwd = getpwuid(getuid());
- if( p_pwd )
- {
- psz_home = p_pwd->pw_dir;
- }
-# endif
-
- if( psz_home == NULL )
- {
- psz_home = getenv( "HOME" );
- }
-
- /* Cache our keys in ${HOME}/.dvdcss/ */
- if( psz_home )
- {
- snprintf( psz_buffer, PATH_MAX, "%s/.dvdcss", psz_home );
- psz_buffer[PATH_MAX-1] = '\0';
- psz_cache = psz_buffer;
- }
-#endif
- }
-
- /*
* Find cache dir from the DVDCSS_CACHE environment variable * Find cache dir from the DVDCSS_CACHE environment variable
*/ */
if( psz_cache != NULL ) @@ -326,6 +317,7 @@
{
- if( psz_cache[0] == '\0' || !strcmp( psz_cache, "off" ) )
+ if( psz_cache[0] == '\0' )
{
psz_cache = NULL;
}
@@ -325,6 +239,7 @@
psz_cache = NULL; psz_cache = NULL;
} }
} }
@ -514,48 +201,16 @@
/* /*
* Open device * Open device
@@ -465,9 +380,10 @@ @@ -504,9 +496,10 @@
dvdcss->psz_cachefile[0] = '\0'; dvdcss->psz_cachefile[0] = '\0';
goto nocache; goto nocache;
} }
+ i += sprintf( dvdcss->psz_cachefile + i, "/"); + i += sprintf( dvdcss->psz_cachefile + i, "/");
- i += sprintf( dvdcss->psz_cachefile + i, "/%s#%s", psz_title, - i += sprintf( dvdcss->psz_cachefile + i, "/%s-%s%s", psz_title,
- psz_serial ); - psz_serial, psz_key );
+// i += sprintf( dvdcss->psz_cachefile + i, "/%s", psz_data ); +// i += sprintf( dvdcss->psz_cachefile + i, "/%s", psz_data );
+ i += sprintf( dvdcss->psz_cachefile + i, "/%s#%s", psz_title, psz_serial ); + i += sprintf( dvdcss->psz_cachefile + i, "/%s#%s", psz_title, psz_serial );
#if !defined( WIN32 ) || defined( SYS_CYGWIN ) #if !defined( WIN32 ) || defined( SYS_CYGWIN )
i_ret = mkdir( dvdcss->psz_cachefile, 0755 ); i_ret = mkdir( dvdcss->psz_cachefile, 0755 );
#else #else
--- dvdcss/dvdcss.h 2003-04-18 20:05:36.000000000 +0200
+++ dvdcss.h 2005-03-01 07:41:41.000000000 +0100
@@ -67,6 +70,8 @@
*/
extern dvdcss_t dvdcss_open ( char *psz_target );
extern int dvdcss_close ( dvdcss_t );
+extern int dvdcss_title ( dvdcss_t,
+ int i_block );
extern int dvdcss_seek ( dvdcss_t,
int i_blocks,
int i_flags );
--- dvdcss/ioctl.h 2005-06-07 19:22:40.187852752 +0200
+++ ioctl.h 2005-06-07 15:31:43.000000000 +0200
@@ -318,6 +318,9 @@
* win32 aspi specific
*****************************************************************************/
+typedef WINAPI DWORD (*GETASPI32SUPPORTINFO)(VOID);
+typedef WINAPI DWORD (*SENDASPI32COMMAND)(LPVOID);
+
#define WIN2K ( GetVersion() < 0x80000000 )
#define ASPI_HAID 0
#define ASPI_TARGET 0
@@ -339,7 +342,7 @@
long hASPI;
short i_sid;
int i_blocks;
- long (*lpSendCommand)( void* );
+ SENDASPI32COMMAND lpSendCommand;
};
#pragma pack(1)