Navigation

← Previous Changeset
Next Changeset →

Changeset 57801bcb3a53d860425eaec6a1f838f763900f32

Timestamp:

04/04/01 04:49:18 (8 years ago)

Author:

Sam Hocevar <sam@videolan.org>

git-committer:

Sam Hocevar <sam@videolan.org> 986352558 +0000

git-parent:

[0fee43a45c5c05c42ca8da004fc15eba9442970b]

git-author:

Sam Hocevar <sam@videolan.org> 986352558 +0000

Message:

additional enhancements to the OS X DVD ioctl module
big cleaning of the BeOS DVD ioctl code, got rid of all Linuxisms

Files:

extras/MacOSX_dvdioctl/DVDioctl.cpp (modified) (12 diffs)
extras/MacOSX_dvdioctl/DVDioctl.h (modified) (2 diffs)
plugins/dvd/dvd_css.c (modified) (15 diffs)
plugins/dvd/dvd_ifo.h (modified) (2 diffs)
plugins/dvd/dvd_ioctl.c (modified) (12 diffs)
plugins/dvd/dvd_ioctl.h (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

extras/MacOSX_dvdioctl/DVDioctl.cpp

r8ccd224	r57801bc
4	4	* Copyright (C) 1998-2000 Apple Computer, Inc. All rights reserved.
5	5	* Copyright (C) 2001 VideoLAN
6		* $Id: DVDioctl.cpp,v 1.~~1 2001/04/02 23:30:41~~ sam Exp $
	6	* $Id: DVDioctl.cpp,v 1.2 2001/04/04 02:49:18 sam Exp $
7	7	*
8	8	* Authors: Samuel Hocevar <sam@zoy.org>
…	…
30	30	*****************************************************************************/
31	31
	32	//XXX: uncomment to activate the key exchange ioctls - may hang the machine
	33	//#define ACTIVATE_DANGEROUS_IOCTL 1
	34
32	35	/*****************************************************************************
33	36	* Preamble
…	…
50	53	#include <IOKit/IOLib.h>
51	54	#include <IOKit/IOService.h>
	55	#include <IOKit/storage/IOMedia.h>
52	56	#include <IOKit/storage/IODVDMedia.h>
53		#include <IOKit/storage/IO~~Media~~.h>
	57	#include <IOKit/storage/IODVDBlockStorageDriver.h>
54	58
55	59	#include "DVDioctl.h"
…	…
85	89	* Local prototypes
86	90	*****************************************************************************/
87		static int DVDClose ( dev_t, int, int, struct proc * );
88		static int DVD~~Ioctl~~ ( dev_t, u_long, caddr_t, int, struct proc * );
89		static int DVDOpen ( dev_t, int, int, struct proc * );
90		static int DVDSize ( dev_t );
91		static void DVDStrategy ( buf_t * );
92		static int DVDReadWrite( dkr_t, dkrtype_t );
	91	static int DVDClose ( dev_t, int, int, struct proc * );
	92	static int DVDBlockIoctl ( dev_t, u_long, caddr_t, int, struct proc * );
	93	static int DVDOpen ( dev_t, int, int, struct proc * );
	94	static int DVDSize ( dev_t );
	95	static void DVDStrategy ( buf_t * );
	96	static int DVDReadWrite ( dkr_t, dkrtype_t );
93	97	static void DVDReadWriteCompletion( void , void , IOReturn, UInt64 );
94	98
95	99	static struct bdevsw device_functions =
96	100	{
97		DVDOpen, DVDClose, DVDStrategy, DVDIoctl, eno_dump, DVDSize, D_DISK
	101	DVDOpen, DVDClose, DVDStrategy, DVDBlockIoctl, eno_dump, DVDSize, D_DISK
98	102	};
99	103
…	…
107	111	static void *p_node;
108	112	static IODVDMedia *p_dvd;
	113	static IODVDBlockStorageDriver *p_drive;
109	114
110	115	/*****************************************************************************
…	…
250	255	p_node = NULL;
251	256	p_dvd = NULL;
	257	p_drive = NULL;
252	258	i_major = -1;
253	259	b_inuse = false;
…	…
342	348	}
343	349
344		~~#if 0~~
345		~~IOReturn DVDioctl::report( IODVDMedia DVD, IOMemoryDescriptor buffer, const DVDKeyClass keyClass, const UInt32 lba, const UInt8 agid, const DVDKeyFormat keyFormat )~~
346		{
347		~~IOLog( "DVD ioctl: reportkey\n" );~~
348		~~return DVD->getProvider()->reportKey( buffer, keyClass, lba, agid, keyFormat );~~
349		}
350
351		~~IOReturn DVDioctl::send( IODVDMedia DVD, IOMemoryDescriptor buffer, const DVDKeyClass keyClass, const UInt32 lba, const DVDKeyFormat keyFormat )~~
352		{
353		~~IOLog( "DVD ioctl: sendkey\n" );~~
354		~~return DVD->getProvider()->sendKey( buffer, keyClass, lba, keyFormat );~~
355		}
356		~~#endif~~
357
358	350	/* following functions are local */
359	351
…	…
364	356	{
365	357	IOStorageAccess level;
366		~~int i_err;~~
367	358
368	359	/* Check that the device hasn't already been opened */
…	…
409	400	: kIOStorageAccessReader;
410	401
411		if( p_dvd->open( p_this, 0, level) )
412		{
413		log( LOG_INFO, "DVD ioctl: IODVDMedia->open()\n" );
414		i_err = 0;
415		}
416		else
	402	if( ! p_dvd->open( p_this, 0, level) )
417	403	{
418	404	log( LOG_INFO, "DVD ioctl: IODVDMedia object busy\n" );
419	405	b_inuse = false;
420		i_err = EBUSY;
421		}
422
423		return i_err;
	406	return EBUSY;
	407	}
	408
	409	p_drive = p_dvd->getProvider();
	410
	411	log( LOG_INFO, "DVD ioctl: IODVDMedia->open()\n" );
	412
	413	return 0;
424	414	}
425	415
…	…
431	421	/* Release the device */
432	422	p_dvd->close( p_this );
	423
	424	p_dvd = NULL;
	425	p_drive = NULL;
433	426	b_inuse = false;
434	427
…	…
456	449
457	450	/*****************************************************************************
458		* DVDIoctl: issue an ioctl on the device
459		*****************************************************************************/
460		static int DVDIoctl( dev_t dev, u_long cmd, caddr_t addr, int flags,
461		struct proc *p )
462		{
	451	* DVDBlockIoctl: issue an ioctl on the block device
	452	*****************************************************************************/
	453	static int DVDBlockIoctl( dev_t dev, u_long cmd, caddr_t addr, int flags,
	454	struct proc *p )
	455	{
	456	dvdioctl_data_t * p_data = (dvdioctl_data_t *)addr;
	457
463	458	switch( cmd )
464	459	{
465	460	case IODVD_READ_STRUCTURE:
466		//log( LOG_INFO, "DVD ioctl: IODVD_READ_STRUCTURE\n" );
	461
	462	log( LOG_INFO, "DVD ioctl: IODVD_READ_STRUCTURE\n" );
	463
467	464	return 0;
468	465
469	466	case IODVD_SEND_KEY:
470		//log( LOG_INFO, "DVD ioctl: IODVD_SEND_KEY\n" );
471		return 0;
	467
	468	log( LOG_INFO, "DVD ioctl: send key to `%s', "
	469	"buf %d, format %d, class %d, agid %d\n",
	470	p_drive->getDeviceTypeName(),
	471	(int)p_data->p_buffer, p_data->i_keyformat,
	472	p_data->i_keyclass, p_data->i_agid );
	473
	474	#ifdef ACTIVATE_DANGEROUS_IOCTL
	475	return p_drive->sendKey( (IOMemoryDescriptor *)p_data->p_buffer,
	476	(DVDKeyClass)p_data->i_keyclass,
	477	p_data->i_agid,
	478	(DVDKeyFormat)p_data->i_keyformat );
	479	#else
	480	return -1;
	481	#endif
472	482
473	483	case IODVD_REPORT_KEY:
474		//log( LOG_INFO, "DVD ioctl: IODVD_REPORT_KEY\n" );
475		return 0;
	484
	485	log( LOG_INFO, "DVD ioctl: report key from `%s', "
	486	p_drive->getDeviceTypeName(),
	487	"buf %d, class %d, lba %d, agid %d, format %d\n",
	488	(int)p_data->p_buffer, p_data->i_keyclass, p_data->i_lba,
	489	p_data->i_agid, p_data->i_keyformat );
	490
	491	#ifdef ACTIVATE_DANGEROUS_IOCTL
	492	return p_drive->reportKey( (IOMemoryDescriptor *)p_data->p_buffer,
	493	(DVDKeyClass)p_data->i_keyclass,
	494	p_data->i_lba, p_data->i_agid,
	495	(DVDKeyFormat)p_data->i_keyformat );
	496	#else
	497	return -1;
	498	#endif
476	499
477	500	default:
478		//log( LOG_INFO, "DVD ioctl: unknown ioctl\n" );
	501
	502	log( LOG_INFO, "DVD ioctl: unknown ioctl\n" );
	503
479	504	return EINVAL;
480	505	}
…	…
592	617	if ( status != kIOReturnSuccess )
593	618	{
594		IOLog( "~~%s: %s.\n", /p_this->name/ "DVD ioctl~~",
	619	IOLog( "DVD ioctl: %s (is the disc authenticated ?)\n",
595	620	p_this->stringFromReturn(status) );
596	621	}

extras/MacOSX_dvdioctl/DVDioctl.h

r8ccd224	r57801bc
3	3	*****************************************************************************
4	4	* Copyright (C) 2001 VideoLAN
5		* $Id: DVDioctl.h,v 1.~~1 2001/04/02 23:30:41~~ sam Exp $
	5	* $Id: DVDioctl.h,v 1.2 2001/04/04 02:49:18 sam Exp $
6	6	*
7	7	* Authors: Samuel Hocevar <sam@zoy.org>
…	…
22	22	*****************************************************************************/
23	23
24		struct sum { int a, b, r; };
25		#define IODVD_READ_STRUCTURE _IOWR('B', 1, struct sum)
26		#define IODVD_SEND_KEY _IOWR('B', 2, struct sum)
27		#define IODVD_REPORT_KEY _IOWR('B', 3, struct sum)
	24	#if defined(KERNEL)
	25	/* Everything has already been defined */
	26	#else
	27	enum DVDKeyFormat
	28	{
	29	kCSSAGID = 0x00,
	30	kChallengeKey = 0x01,
	31	kKey1 = 0x02,
	32	kKey2 = 0x03,
	33	kTitleKey = 0x04,
	34	kASF = 0x05,
	35	kSetRegion = 0x06,
	36	kRPCState = 0x08,
	37	kCSS2AGID = 0x10,
	38	kCPRMAGID = 0x11,
	39	kInvalidateAGID = 0x3f
	40	};
28	41
	42	enum DVDKeyClass
	43	{
	44	kCSS_CSS2_CPRM = 0x00,
	45	kRSSA = 0x01
	46	};
	47	#endif
	48
	49	typedef struct dvdioctl_data
	50	{
	51	void *p_buffer;
	52
	53	#if defined(KERNEL)
	54	UInt32 i_lba;
	55	UInt8 i_agid;
	56	#else
	57	u32 i_lba;
	58	u8 i_agid;
	59	#endif
	60
	61	int i_keyclass;
	62	int i_keyformat;
	63
	64	} dvdioctl_data_t;
	65
	66	#define IODVD_READ_STRUCTURE _IOWR('B', 1, dvdioctl_data_t)
	67	#define IODVD_SEND_KEY _IOWR('B', 2, dvdioctl_data_t)
	68	#define IODVD_REPORT_KEY _IOWR('B', 3, dvdioctl_data_t)
	69

plugins/dvd/dvd_css.c

r8ccd224	r57801bc
3	3	*****************************************************************************
4	4	* Copyright (C) 1999-2001 VideoLAN
5		* $Id: dvd_css.c,v 1.~~19 2001/04/02 23:30:41~~ sam Exp $
	5	* $Id: dvd_css.c,v 1.20 2001/04/04 02:49:18 sam Exp $
6	6	*
7	7	* Author: St�ane Borel <stef@via.ecp.fr>
…	…
72	72	int i_ret, i_copyright;
73	73
74		i_ret = ~~dvd~~_ReadCopyright( i_fd, 0 /* i_layer */, &i_copyright );
	74	i_ret = ioctl_ReadCopyright( i_fd, 0 /* i_layer */, &i_copyright );
75	75
76	76	if( i_ret < 0 )
…	…
106	106
107	107	case 1:
	108	intf_WarnMsg( 3, "css info: already authenticated" );
108	109	return 0;
109	110
110	111	case 0:
111		intf_WarnMsg( 3, "css info: ~~authenticating~~" );
	112	intf_WarnMsg( 3, "css info: need to authenticate" );
112	113	}
113	114
…	…
117	118	intf_WarnMsg( 3, "css info: requesting AGID %d", i );
118	119
119		i_ret = ~~dvd~~_LUSendAgid( p_css );
	120	i_ret = ioctl_LUSendAgid( p_css );
120	121
121	122	if( i_ret != -1 )
…	…
128	129
129	130	p_css->i_agid = 0;
130		~~dvd~~_InvalidateAgid( p_css );
	131	ioctl_InvalidateAgid( p_css );
131	132	}
132	133
…	…
150	151
151	152	/* Send challenge to LU */
152		if( ~~dvd~~_HostSendChallenge( p_css, p_buffer ) < 0 )
	153	if( ioctl_HostSendChallenge( p_css, p_buffer ) < 0 )
153	154	{
154	155	intf_ErrMsg( "css error: failed sending challenge to LU" );
…	…
157	158
158	159	/* Get key1 from LU */
159		if( ~~dvd~~_LUSendKey1( p_css, p_buffer ) < 0)
	160	if( ioctl_LUSendKey1( p_css, p_buffer ) < 0)
160	161	{
161	162	intf_ErrMsg( "css error: failed getting key1 from LU" );
…	…
190	191
191	192	/* Get challenge from LU */
192		if( ~~dvd~~_LUSendChallenge( p_css, p_buffer ) < 0 )
	193	if( ioctl_LUSendChallenge( p_css, p_buffer ) < 0 )
193	194	{
194	195	intf_ErrMsg( "css error: failed getting challenge from LU" );
…	…
212	213
213	214	/* Send key2 to LU */
214		if( ~~dvd~~_HostSendKey2( p_css, p_buffer ) < 0 )
	215	if( ioctl_HostSendKey2( p_css, p_buffer ) < 0 )
215	216	{
216	217	intf_ErrMsg( "css error: failed sending key2 to LU" );
…	…
239	240
240	241	case 1:
	242	intf_WarnMsg( 3, "css info: already authenticated" );
241	243	return 0;
242	244
243	245	case 0:
244		intf_WarnMsg( 3, "css info: ~~getting~~ disc key" );
	246	intf_WarnMsg( 3, "css info: need to get disc key" );
245	247	}
246	248
247	249	/* Get encrypted disc key */
248		if( ~~dvd~~_ReadKey( p_css, p_buffer ) < 0 )
	250	if( ioctl_ReadKey( p_css, p_buffer ) < 0 )
249	251	{
250	252	intf_ErrMsg( "css error: could not read Disc Key" );
…	…
263	265	{
264	266	case -1:
	267	return -1;
	268
	269	case 1:
	270	intf_WarnMsg( 3, "css info: successfully authenticated" );
	271	return 0;
	272
265	273	case 0:
266		return -1;
267
268		case 1:
269		return 0;
270		}
271
272		return 0;
	274	intf_WarnMsg( 3, "css info: no way to authenticate" );
	275	}
273	276
274	277	#else /* HAVE_CSS */
275	278	intf_ErrMsg( "css error: CSS decryption is disabled in this module" );
276	279
	280	#endif /* HAVE_CSS */
277	281	return -1;
278	282
279		~~#endif /* HAVE_CSS */~~
280	283	}
281	284
…	…
476	479
477	480	return 0;
	481
478	482	#else /* HAVE_CSS */
479	483	return 1;
	484
480	485	#endif /* HAVE_CSS */
481	486	}
…	…
523	528
524	529	return 0;
	530
525	531	#else /* HAVE_CSS */
526	532	return 1;
	533
527	534	#endif /* HAVE_CSS */
528	535	}
529	536
530	537	#ifdef HAVE_CSS
531		/*
532		* Following functions are local
533		*/
	538
	539	/* Following functions are local */
534	540
535	541	/*****************************************************************************
…	…
547	553	for( p_css->i_agid = 0 ; p_css->i_agid < 4 ; p_css->i_agid++ )
548	554	{
549		if( ~~dvd~~_LUSendASF( p_css, &i_asf ) == 0 )
	555	if( ioctl_LUSendASF( p_css, &i_asf ) == 0 )
550	556	{
551	557	intf_WarnMsg( 3, "css info: %sauthenticated", i_asf ? "":"not " );
…	…
899	905	return i_exit;
900	906	}
	907
901	908	#endif /* HAVE_CSS */
902	909

plugins/dvd/dvd_ifo.h

rf6c80a7	r57801bc
3	3	*****************************************************************************
4	4	* Copyright (C) 1999-2001 VideoLAN
5		* $Id: dvd_ifo.h,v 1.~~9 2001/04/01 07:31:38 stef~~ Exp $
	5	* $Id: dvd_ifo.h,v 1.10 2001/04/04 02:49:18 sam Exp $
6	6	*
7	7	* Author: St�ane Borel <stef@via.ecp.fr>
…	…
87	87	union
88	88	{
89		u8 pi_8[6];
90		u16 pi_16[3];
	89	u8 pi_8[6];
	90	u16 pi_16[3];
91	91	} data;
92	92	} command_desc_t;

plugins/dvd/dvd_ioctl.c

r8ccd224	r57801bc
3	3	*****************************************************************************
4	4	* Copyright (C) 1999-2001 VideoLAN
5		* $Id: dvd_ioctl.c,v 1.~~4 2001/04/02 23:30:41~~ sam Exp $
	5	* $Id: dvd_ioctl.c,v 1.5 2001/04/04 02:49:18 sam Exp $
6	6	*
7	7	* Authors: Markus Kuespert <ltlBeBoy@beosmail.com>
…	…
30	30	#include <sys/types.h>
31	31	#include <netinet/in.h>
	32
32	33	#ifdef HAVE_SYS_DVDIO_H
33	34	# include <sys/ioctl.h>
…	…
45	46	#ifdef SYS_DARWIN1_3
46	47	# include <sys/ioctl.h>
47		~~# include <DVDioctl/DVDioctl.h>~~
48	48	#endif
49	49
50	50	#include "common.h"
	51
51	52	#include "intf_msg.h"
	53
	54	#ifdef SYS_DARWIN1_3
	55	# include "DVDioctl/DVDioctl.h"
	56	#endif
52	57
53	58	#include "dvd_css.h"
…	…
58	63	*****************************************************************************/
59	64	#if defined( SYS_BEOS )
60		static void InitCommand ( struct cdrom_generic_command *p_cgc,
61		void *buf, int i_len, int i_type );
62		static int SendCommand ( int i_fd, struct cdrom_generic_command *p_cgc );
63		#endif
64
65		/*****************************************************************************
66		* dvd_ReadKey:
67		*****************************************************************************
68		*
69		*****************************************************************************/
70		int dvd_ReadKey( css_t p_css, u8 p_key )
71		{
72		#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
73		int i_ret;
	65	static void BeInitRDC ( raw_device_command , void , int );
	66	#endif
	67
	68	/*****************************************************************************
	69	* ioctl_ReadCopyright: check whether the disc is encrypted or not
	70	*****************************************************************************/
	71	int ioctl_ReadCopyright( int i_fd, int i_layer, int *pi_copyright )
	72	{
	73	int i_ret;
	74
	75	#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
	76	dvd_struct dvd;
	77
	78	dvd.type = DVD_STRUCT_COPYRIGHT;
	79	dvd.copyright.layer_num = i_layer;
	80
	81	i_ret = ioctl( i_fd, DVD_READ_STRUCT, &dvd );
	82
	83	*pi_copyright = dvd.copyright.cpst;
	84
	85	#elif defined( SYS_BEOS )
	86	raw_device_command rdc;
	87	u8 p_buffer[ 8 ];
	88
	89	BeInitRDC( &rdc, p_buffer, 8 );
	90
	91	rdc.flags = B_RAW_DEVICE_DATA_IN;
	92	rdc.command[ 0 ] = GPCMD_READ_DVD_STRUCTURE;
	93	rdc.command[ 6 ] = i_layer;
	94	rdc.command[ 7 ] = DVD_STRUCT_COPYRIGHT;
	95
	96	i_ret = ioctl( i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) );
	97
	98	*pi_copyright = p_buffer[ 4 ];
	99
	100	#elif defined( SYS_DARWIN1_3 )
	101	intf_ErrMsg( "css error: DVD ioctls not fully functional yet" );
	102
	103	intf_ErrMsg( "css error: assuming disc is unencrypted" );
	104	*pi_copyright = 0;
	105
	106	i_ret = 0;
	107
	108	#else
	109	/* DVD ioctls unavailable - do as if the ioctl failed */
	110	i_ret = -1;
	111
	112	#endif
	113	return i_ret;
	114	}
	115
	116	/*****************************************************************************
	117	* ioctl_ReadKey: get the disc key
	118	*****************************************************************************/
	119	int ioctl_ReadKey( css_t p_css, u8 p_key )
	120	{
	121	int i_ret;
	122
	123	#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
74	124	dvd_struct dvd;
75	125
…	…
87	137
88	138	memcpy( p_key, dvd.disckey.value, 2048 );
89		return i_ret;
90
91		#elif defined( SYS_BEOS )
92		int i_ret, size;
93		u8 p_buf[ 2048 + 4];
94		struct cdrom_generic_command cgc;
95
96		size = 2048 + 4;
97
98		InitCommand( &cgc, p_buf, size, CGC_DATA_READ );
99
100		cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
101
102		cgc.cmd[7] = DVD_STRUCT_DISCKEY;
103		cgc.cmd[8] = size >> 8;
104		cgc.cmd[9] = size & 0xff;
105		cgc.cmd[10] = p_css->i_agid << 6;
106
107		i_ret = SendCommand( p_css->i_fd, &cgc );
	139
	140	#elif defined( SYS_BEOS )
	141	raw_device_command rdc;
	142	u8 p_buffer[ 2048 + 4 ];
	143
	144	BeInitRDC( &rdc, p_buffer, 2048 + 4 );
	145
	146	rdc.flags = B_RAW_DEVICE_DATA_IN;
	147	rdc.command[ 0 ] = GPCMD_READ_DVD_STRUCTURE;
	148	rdc.command[ 7 ] = DVD_STRUCT_DISCKEY;
	149	rdc.command[ 10 ] = p_css->i_agid << 6;
	150
	151	i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) );
108	152
109	153	if( i_ret < 0 )
…	…
112	156	}
113	157
114		memcpy( p_key, p_buf + 4, 2048 );
115		return i_ret;
116
117		#else
118		return -1;
119
120		#endif
121		}
122
123		/*****************************************************************************
124		* dvd_ReadCopyright:
125		*****************************************************************************
126		*
127		*****************************************************************************/
128		int dvd_ReadCopyright( int i_fd, int i_layer, int *pi_copyright )
129		{
130		#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
131		int i_ret;
132		dvd_struct dvd;
133
134		dvd.type = DVD_STRUCT_COPYRIGHT;
135		dvd.copyright.layer_num = i_layer;
136
137		i_ret = ioctl( i_fd, DVD_READ_STRUCT, &dvd );
138
139		*pi_copyright = dvd.copyright.cpst;
140		return i_ret;
141
142		#elif defined( SYS_BEOS )
143		int i_ret;
144		u8 p_buf[8];
145		struct cdrom_generic_command cgc;
146
147		InitCommand( &cgc, p_buf, sizeof(p_buf), CGC_DATA_READ );
148
149		cgc.cmd[0] = GPCMD_READ_DVD_STRUCTURE;
150
151		cgc.cmd[6] = i_layer;
152		cgc.cmd[7] = DVD_STRUCT_COPYRIGHT;
153		cgc.cmd[8] = cgc.buflen >> 8;
154		cgc.cmd[9] = cgc.buflen & 0xff;
155
156		i_ret = SendCommand( i_fd, &cgc );
157
158		*pi_copyright = p_buf[4];
159		return i_ret;
160
161		#elif defined( SYS_DARWIN1_3 )
162		intf_ErrMsg( "css error: DVD ioctls not fully functional yet" );
163		intf_ErrMsg( "css error: assuming disc is unencrypted" );
164
165		*pi_copyright = 0;
166		return 0;
167
168		#else
169		return -1;
170
171		#endif
172		}
173
174		/*****************************************************************************
175		* dvd_LUSendAgid:
176		*****************************************************************************
177		*
178		*****************************************************************************/
179		int dvd_LUSendAgid( css_t *p_css )
180		{
181		#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
182		int i_ret;
	158	memcpy( p_key, p_buffer + 4, 2048 );
	159
	160	#else
	161	/* DVD ioctls unavailable - do as if the ioctl failed */
	162	i_ret = -1;
	163
	164	#endif
	165	return i_ret;
	166	}
	167
	168	/*****************************************************************************
	169	* ioctl_LUSendAgid: get AGID from the drive
	170	*****************************************************************************/
	171	int ioctl_LUSendAgid( css_t *p_css )
	172	{
	173	int i_ret;
	174
	175	#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
183	176	dvd_authinfo auth_info;
184	177
…	…
189	182
190	183	p_css->i_agid = auth_info.lsa.agid;
191		return i_ret;
192
193		#elif defined( SYS_BEOS )
194		u8 p_buf[8];
195		int i_ret;
196		struct cdrom_generic_command cgc;
197
198		//memset( p_buf, 0, sizeof( p_buf ) );
199
200		InitCommand( &cgc, p_buf, 0, CGC_DATA_READ );
201
202		cgc.cmd[0] = GPCMD_REPORT_KEY;
203		cgc.cmd[10] = 0x00 \| (p_css->i_agid << 6);
204		cgc.buflen = 8;
205		cgc.cmd[9] = cgc.buflen;
206		cgc.data_direction = CGC_DATA_READ;
207
208		i_ret = SendCommand( p_css->i_fd, &cgc );
209
210		p_css->i_agid = p_buf[7] >> 6;
211		return i_ret;
212
213		#else
214		return -1;
215
216		#endif
217		}
218
219		/*****************************************************************************
220		* dvd_InvalidateAgid:
221		*****************************************************************************
222		*
223		*****************************************************************************/
224		int dvd_InvalidateAgid( css_t *p_css )
225		{
226		#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
227		int i_ret;
228		dvd_authinfo auth_info;
229
230		auth_info.type = DVD_INVALIDATE_AGID;
231		auth_info.lsa.agid = p_css->i_agid;
	184
	185	#elif defined( SYS_BEOS )
	186	raw_device_command rdc;
	187	u8 p_buffer[ 8 ];
	188
	189	BeInitRDC( &rdc, p_buffer, 8 );
	190
	191	rdc.flags = B_RAW_DEVICE_DATA_IN;
	192	rdc.command[ 0 ] = GPCMD_REPORT_KEY;
	193	rdc.command[ 10 ] = 0x00 \| (p_css->i_agid << 6);
	194
	195	i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) );
	196
	197	p_css->i_agid = p_buffer[ 7 ] >> 6;
	198
	199	#else
	200	/* DVD ioctls unavailable - do as if the ioctl failed */
	201	i_ret = -1;
	202
	203	#endif
	204	return i_ret;
	205	}
	206
	207	/*****************************************************************************
	208	* ioctl_LUSendChallenge: get challenge from the drive
	209	*****************************************************************************/
	210	int ioctl_LUSendChallenge( css_t p_css, u8 p_challenge )
	211	{
	212	int i_ret;
	213
	214	#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
	215	dvd_authinfo auth_info;
	216
	217	auth_info.type = DVD_LU_SEND_CHALLENGE;
232	218
233	219	i_ret = ioctl( p_css->i_fd, DVD_AUTH, &auth_info );
234	220
235		p_css->i_agid = auth_info.lsa.agid;
236		return i_ret;
237
238		#elif defined( SYS_BEOS )
239		u8 p_buf[0];
240		struct cdrom_generic_command cgc;
241
242		//memset( p_buf, 0, sizeof( p_buf ) );
243
244		InitCommand( &cgc, p_buf, 0, CGC_DATA_READ );
245
246		cgc.cmd[0] = GPCMD_REPORT_KEY;
247		cgc.cmd[10] = 0x3f \| (p_css->i_agid << 6);
248		cgc.cmd[9] = cgc.buflen = 0;
249		cgc.data_direction = CGC_DATA_READ;
250
251		return SendCommand( p_css->i_fd, &cgc );
252
253		#else
254		return -1;
255
256		#endif
257		}
258
259		/*****************************************************************************
260		* dvd_HostSendChallenge:
261		*****************************************************************************
262		*
263		*****************************************************************************/
264		int dvd_HostSendChallenge( css_t p_css, u8 p_challenge )
265		{
266		#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
267		dvd_authinfo auth_info;
268
269		auth_info.type = DVD_HOST_SEND_CHALLENGE;
270
271		memcpy( auth_info.hsc.chal, p_challenge, sizeof(dvd_challenge) );
272
273		return ioctl( p_css->i_fd, DVD_AUTH, &auth_info );
274
275		#elif defined( SYS_BEOS )
276		u8 p_buf[16];
277		struct cdrom_generic_command cgc;
278
279		//memset( p_buf, 0, sizeof( p_buf ) );
280
281		InitCommand( &cgc, p_buf, 0, CGC_DATA_READ );
282
283		cgc.cmd[0] = GPCMD_SEND_KEY;
284		cgc.cmd[10] = 0x01 \| (p_css->i_agid << 6);
285		cgc.buflen = 16;
286		cgc.cmd[9] = cgc.buflen;
287		cgc.data_direction = CGC_DATA_WRITE;
288
289		p_buf[1] = 0xe;
290		memcpy( p_buf + 4, p_challenge, sizeof(dvd_challenge) );
291
292		return SendCommand( p_css->i_fd, &cgc );
293
294		#else
295		return -1;
296
297		#endif
298		}
299
300		/*****************************************************************************
301		* dvd_LUSendASF:
302		*****************************************************************************
303		*
304		*****************************************************************************/
305		int dvd_LUSendASF( css_t p_css, int pi_asf )
306		{
307		#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
308		int i_ret;
	221	memcpy( p_challenge, auth_info.lsc.chal, sizeof(dvd_challenge) );
	222
	223	#elif defined( SYS_BEOS )
	224	raw_device_command rdc;
	225	u8 p_buffer[ 16 ];
	226
	227	BeInitRDC( &rdc, p_buffer, 16 );
	228
	229	rdc.flags = B_RAW_DEVICE_DATA_IN;
	230	rdc.command[ 0 ] = GPCMD_REPORT_KEY;
	231	rdc.command[ 10 ] = 0x01 \| (p_css->i_agid << 6);
	232
	233	i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) );
	234
	235	memcpy( p_challenge, p_buffer + 4, sizeof(dvd_challenge) );
	236
	237	#else
	238	/* DVD ioctls unavailable - do as if the ioctl failed */
	239	i_ret = -1;
	240
	241	#endif
	242	return i_ret;
	243	}
	244
	245	/*****************************************************************************
	246	* ioctl_LUSendASF: get ASF from the drive
	247	*****************************************************************************/
	248	int ioctl_LUSendASF( css_t p_css, int pi_asf )
	249	{
	250	int i_ret;
	251
	252	#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
309	253	dvd_authinfo auth_info;
310	254
…	…
316	260
317	261	*pi_asf = auth_info.lsasf.asf;
318		return i_ret;
319
320		#elif defined( SYS_BEOS )
321		int i_ret;
322		u8 p_buf[8];
323		struct cdrom_generic_command cgc;
324
325		//memset( p_buf, 0, sizeof( p_buf ) );
326
327		InitCommand( &cgc, p_buf, 0, CGC_DATA_READ );
328
329		cgc.cmd[0] = GPCMD_REPORT_KEY;
330		cgc.cmd[10] = 0x05 \| (p_css->i_agid << 6);
331		cgc.buflen = 8;
332		cgc.cmd[9] = cgc.buflen;
333		cgc.data_direction = CGC_DATA_READ;
334
335		i_ret = SendCommand( p_css->i_fd, &cgc );
336
337		*pi_asf = p_buf[7] & 1;
338		return i_ret;
339
340		#else
341		return -1;
342
343		#endif
344		}
345
346		/*****************************************************************************
347		* dvd_LUSendChallenge:
348		*****************************************************************************
349		*
350		*****************************************************************************/
351		int dvd_LUSendChallenge( css_t p_css, u8 p_challenge )
352		{
353		#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
354		int i_ret;
355		dvd_authinfo auth_info;
356
357		auth_info.type = DVD_LU_SEND_CHALLENGE;
358
359		i_ret = ioctl( p_css->i_fd, DVD_AUTH, &auth_info );
360
361		memcpy( p_challenge, auth_info.lsc.chal, sizeof(dvd_challenge) );
362		return i_ret;
363
364		#elif defined( SYS_BEOS )
365		int i_ret;
366		u8 p_buf[16];
367		struct cdrom_generic_command cgc;
368
369		//memset( p_buf, 0, sizeof( p_buf ) );
370
371		InitCommand( &cgc, p_buf, 0, CGC_DATA_READ );
372
373		cgc.cmd[0] = GPCMD_REPORT_KEY;
374		cgc.cmd[10] = 0x01 \| (p_css->i_agid << 6);
375		cgc.buflen = 16;
376		cgc.cmd[9] = cgc.buflen;
377		cgc.data_direction = CGC_DATA_READ;
378
379		i_ret = SendCommand( p_css->i_fd, &cgc );
380
381		memcpy( p_challenge, p_buf + 4, sizeof(dvd_challenge) );
382		return i_ret;
383
384		#else
385		return -1;
386
387		#endif
388		}
389
390		/*****************************************************************************
391		* dvd_LUSendKey1:
392		*****************************************************************************
393		*
394		*****************************************************************************/
395		int dvd_LUSendKey1( css_t p_css, u8 p_key )
396		{
397		#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
398		int i_ret;
	262
	263	#elif defined( SYS_BEOS )
	264	raw_device_command rdc;
	265	u8 p_buffer[ 8 ];
	266
	267	BeInitRDC( &rdc, p_buffer, 8 );
	268
	269	rdc.flags = B_RAW_DEVICE_DATA_IN;
	270	rdc.command[ 0 ] = GPCMD_REPORT_KEY;
	271	rdc.command[ 10 ] = 0x05 \| (p_css->i_agid << 6);
	272
	273	i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) );
	274
	275	*pi_asf = p_buffer[ 7 ] & 1;
	276
	277	#elif defined( SYS_DARWIN1_3 )
	278	dvdioctl_data_t data;
	279	u8 p_buffer[ 8 ];
	280
	281	data.p_buffer = p_buffer;
	282	data.i_lba = 0;
	283	data.i_agid = p_css->i_agid;
	284	data.i_keyclass = kCSS_CSS2_CPRM;
	285	data.i_keyformat = kASF;
	286
	287	i_ret = ioctl( p_css->i_fd, IODVD_REPORT_KEY, &data );
	288
	289	*pi_asf = p_buffer[ 7 ] & 1;
	290
	291	#else
	292	/* DVD ioctls unavailable - do as if the ioctl failed */
	293	i_ret = -1;
	294
	295	#endif
	296	return i_ret;
	297	}
	298
	299	/*****************************************************************************
	300	* ioctl_LUSendKey1: get the first key from the drive
	301	*****************************************************************************/
	302	int ioctl_LUSendKey1( css_t p_css, u8 p_key )
	303	{
	304	int i_ret;
	305
	306	#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
399	307	dvd_authinfo auth_info;
400	308
…	…
405	313
406	314	memcpy( p_key, auth_info.lsk.key, sizeof(dvd_key) );
407		return i_ret;
408
409		#elif defined( SYS_BEOS )
410		int i_ret;
411		u8 p_buf[12];
412		struct cdrom_generic_command cgc;
413
414		//memset( p_buf, 0, sizeof( p_buf ) );
415
416		InitCommand( &cgc, p_buf, 0, CGC_DATA_READ );
417
418		cgc.cmd[0] = GPCMD_REPORT_KEY;
419		cgc.cmd[10] = 0x02 \| (p_css->i_agid << 6);
420		cgc.buflen = 12;
421		cgc.cmd[9] = cgc.buflen;
422		cgc.data_direction = CGC_DATA_READ;
423
424		i_ret = SendCommand( p_css->i_fd, &cgc );
425
426		memcpy( p_key, p_buf + 4, sizeof(dvd_key) );
427		return i_ret;
428
429		#else
	315
	316	#elif defined( SYS_BEOS )
	317	raw_device_command rdc;
	318	u8 p_buffer[ 12 ];
	319
	320	BeInitRDC( &rdc, p_buffer, 12 );
	321
	322	rdc.flags = B_RAW_DEVICE_DATA_IN;
	323	rdc.command[ 0 ] = GPCMD_REPORT_KEY;
	324	rdc.command[ 10 ] = 0x02 \| (p_css->i_agid << 6);
	325
	326	i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) );
	327
	328	memcpy( p_key, p_buffer + 4, sizeof(dvd_key) );
	329
	330	#else
	331	/* DVD ioctls unavailable - do as if the ioctl failed */
	332	i_ret = -1;
	333
	334	#endif
	335	return i_ret;
	336	}
	337
	338	/*****************************************************************************
	339	* ioctl_InvalidateAgid: invalidate the current AGID
	340	*****************************************************************************/
	341	int ioctl_InvalidateAgid( css_t *p_css )
	342	{
	343	int i_ret;
	344
	345	#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
	346	dvd_authinfo auth_info;
	347
	348	auth_info.type = DVD_INVALIDATE_AGID;
	349	auth_info.lsa.agid = p_css->i_agid;
	350
	351	i_ret = ioctl( p_css->i_fd, DVD_AUTH, &auth_info );
	352
	353	p_css->i_agid = auth_info.lsa.agid;
	354
	355	#elif defined( SYS_BEOS )
	356	raw_device_command rdc;
	357	u8 p_buffer[ 0 ];
	358
	359	BeInitRDC( &rdc, p_buffer, 0 );
	360
	361	rdc.flags = B_RAW_DEVICE_DATA_IN;
	362	rdc.command[ 0 ] = GPCMD_REPORT_KEY;
	363	rdc.command[ 10 ] = 0x3f \| (p_css->i_agid << 6);
	364
	365	i_ret = ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) );
	366
	367	#else
	368	/* DVD ioctls unavailable - do as if the ioctl failed */
	369	i_ret = -1;
	370
	371	#endif
	372	return i_ret;
	373	}
	374
	375	/*****************************************************************************
	376	* ioctl_HostSendChallenge: send challenge to the drive
	377	*****************************************************************************/
	378	int ioctl_HostSendChallenge( css_t p_css, u8 p_challenge )
	379	{
	380	#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
	381	dvd_authinfo auth_info;
	382
	383	auth_info.type = DVD_HOST_SEND_CHALLENGE;
	384
	385	memcpy( auth_info.hsc.chal, p_challenge, sizeof(dvd_challenge) );
	386
	387	return ioctl( p_css->i_fd, DVD_AUTH, &auth_info );
	388
	389	#elif defined( SYS_BEOS )
	390	raw_device_command rdc;
	391	u8 p_buffer[ 16 ];
	392
	393	BeInitRDC( &rdc, p_buffer, 16 );
	394
	395	rdc.command[ 0 ] = GPCMD_SEND_KEY;
	396	rdc.command[ 10 ] = 0x01 \| (p_css->i_agid << 6);
	397
	398	p_buffer[ 1 ] = 0xe;
	399	memcpy( p_buffer + 4, p_challenge, sizeof(dvd_challenge) );
	400
	401	return ioctl( p_css->i_fd, B_RAW_DEVICE_COMMAND, &rdc, sizeof(rdc) );
	402
	403	#else
	404	/* DVD ioctls unavailable - do as if the ioctl failed */
430	405	return -1;
431	406
…	…
434	409
435	410	/*****************************************************************************
436		* dvd_HostSendKey2:
437		*****************************************************************************
438		*
439		*****************************************************************************/
440		int dvd_HostSendKey2( css_t p_css, u8 p_key )
	411	* ioctl_HostSendKey2: send the second key to the drive
	412	*****************************************************************************/
	413	int ioctl_HostSendKey2( css_t p_css, u8 p_key )
441	414	{
442	415	#if defined( HAVE_SYS_DVDIO_H ) \|\| defined( LINUX_DVD )
…	…
451	424
452	425	#elif defined( SYS_BEOS )
453		u8 p_buf[12];
454		struct cdrom_generic_command cgc;
455
456		//memset( p_buf, 0, sizeof( p_buf ) );
457
458		InitCommand( &cgc, p_buf, 0, CGC_DATA_READ );
459
460		cgc.cmd[0] = GPCMD_SEND_KEY;
461		cgc.cmd[10] = 0x3 \| (p_css->i_agid << 6);
462		cgc.buflen = 12;
463		cgc.cmd[9] = cgc.buflen;
464