Mercurial > mplayer.hg
annotate libdvdcss/libdvdcss.c @ 24682:67d29f7793e6
sync'd up to r24423
author | ptt |
---|---|
date | Thu, 04 Oct 2007 17:32:08 +0000 |
parents | 2273bfbb8e40 |
children | f0788169e503 |
rev | line source |
---|---|
20613 | 1 /* libdvdcss.c: DVD reading library. |
2 * | |
3 * Authors: Stéphane Borel <stef@via.ecp.fr> | |
4 * Samuel Hocevar <sam@zoy.org> | |
5 * Håkan Hjort <d95hjort@dtek.chalmers.se> | |
6 * | |
7 * Copyright (C) 1998-2002 VideoLAN | |
8 * $Id$ | |
9 * | |
10 * This program is free software; you can redistribute it and/or modify | |
11 * it under the terms of the GNU General Public License as published by | |
12 * the Free Software Foundation; either version 2 of the License, or | |
13 * (at your option) any later version. | |
14 * | |
15 * This program is distributed in the hope that it will be useful, | |
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 * GNU General Public License for more details. | |
19 * | |
20 * You should have received a copy of the GNU General Public License | |
21 * along with this program; if not, write to the Free Software | |
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. | |
23 */ | |
24 | |
25 /** | |
26 * \mainpage libdvdcss developer documentation | |
27 * | |
28 * \section intro Introduction | |
29 * | |
30 * \e libdvdcss is a simple library designed for accessing DVDs like a block | |
31 * device without having to bother about the decryption. The important features | |
32 * are: | |
33 * \li portability: currently supported platforms are GNU/Linux, FreeBSD, | |
34 * NetBSD, OpenBSD, BSD/OS, BeOS, Windows 95/98, Windows NT/2000, MacOS X, | |
35 * Solaris, HP-UX and OS/2. | |
36 * \li adaptability: unlike most similar projects, libdvdcss doesn't require | |
37 * the region of your drive to be set and will try its best to read from | |
38 * the disc even in the case of a region mismatch. | |
39 * \li simplicity: a DVD player can be built around the \e libdvdcss API using | |
40 * no more than 4 or 5 library calls. | |
41 * | |
42 * \e libdvdcss is free software, released under the General Public License. | |
43 * This ensures that \e libdvdcss remains free and used only with free | |
44 * software. | |
45 * | |
46 * \section api The libdvdcss API | |
47 * | |
48 * The complete \e libdvdcss programming interface is documented in the | |
49 * dvdcss.h file. | |
50 * | |
51 * \section env Environment variables | |
52 * | |
53 * Some environment variables can be used to change the behaviour of | |
54 * \e libdvdcss without having to modify the program which uses it. These | |
55 * variables are: | |
56 * | |
57 * \li \b DVDCSS_VERBOSE: sets the verbosity level. | |
58 * - \c 0 outputs no messages at all. | |
59 * - \c 1 outputs error messages to stderr. | |
60 * - \c 2 outputs error messages and debug messages to stderr. | |
61 * | |
62 * \li \b DVDCSS_METHOD: sets the authentication and decryption method | |
63 * that \e libdvdcss will use to read scrambled discs. Can be one | |
64 * of \c title, \c key or \c disc. | |
65 * - \c key is the default method. \e libdvdcss will use a set of | |
66 * calculated player keys to try and get the disc key. This can fail | |
67 * if the drive does not recognize any of the player keys. | |
68 * - \c disc is a fallback method when \c key has failed. Instead of | |
69 * using player keys, \e libdvdcss will crack the disc key using | |
70 * a brute force algorithm. This process is CPU intensive and requires | |
71 * 64 MB of memory to store temporary data. | |
72 * - \c title is the fallback when all other methods have failed. It does | |
73 * not rely on a key exchange with the DVD drive, but rather uses a | |
74 * crypto attack to guess the title key. On rare cases this may fail | |
75 * because there is not enough encrypted data on the disc to perform | |
76 * a statistical attack, but in the other hand it is the only way to | |
77 * decrypt a DVD stored on a hard disc, or a DVD with the wrong region | |
78 * on an RPC2 drive. | |
79 * | |
80 * \li \b DVDCSS_RAW_DEVICE: specify the raw device to use. Exact usage will | |
81 * depend on your operating system, the Linux utility to set up raw devices | |
82 * is \c raw(8) for instance. Please note that on most operating systems, | |
83 * using a raw device requires highly aligned buffers: Linux requires a | |
84 * 2048 bytes alignment (which is the size of a DVD sector). | |
85 * | |
86 * \li \b DVDCSS_CACHE: specify a directory in which to store title key | |
87 * values. This will speed up descrambling of DVDs which are in the | |
88 * cache. The DVDCSS_CACHE directory is created if it does not exist, | |
89 * and a subdirectory is created named after the DVD's title or | |
90 * manufacturing date. If DVDCSS_CACHE is not set or is empty, \e libdvdcss | |
91 * will use the default value which is "${HOME}/.dvdcss/" under Unix and | |
92 * "C:\Documents and Settings\$USER\Application Data\dvdcss\" under Win32. | |
93 * The special value "off" disables caching. | |
94 */ | |
95 | |
96 /* | |
97 * Preamble | |
98 */ | |
99 #include "config.h" | |
100 | |
101 #include <stdio.h> | |
102 #include <stdlib.h> | |
103 #include <string.h> | |
104 #include <sys/types.h> | |
105 #include <sys/stat.h> | |
106 #ifdef HAVE_SYS_PARAM_H | |
107 # include <sys/param.h> | |
108 #endif | |
109 #ifdef HAVE_PWD_H | |
110 # include <pwd.h> | |
111 #endif | |
112 #include <fcntl.h> | |
113 #include <errno.h> | |
114 | |
115 #ifdef HAVE_UNISTD_H | |
116 # include <unistd.h> | |
117 #endif | |
118 | |
119 #ifdef HAVE_LIMITS_H | |
120 # include <limits.h> | |
121 #endif | |
122 | |
123 #ifdef HAVE_DIRECT_H | |
124 # include <direct.h> | |
125 #endif | |
126 | |
127 #include "dvdcss/dvdcss.h" | |
128 | |
129 #include "common.h" | |
130 #include "css.h" | |
131 #include "libdvdcss.h" | |
132 #include "ioctl.h" | |
133 #include "device.h" | |
134 | |
135 /** | |
136 * \brief Symbol for version checks. | |
137 * | |
138 * The name of this symbol contains the library major number, which makes it | |
139 * easy to check which \e libdvdcss development headers are installed on the | |
140 * system with tools such as autoconf. | |
141 * | |
142 * The variable itself contains the exact version number of the library, | |
143 * which can be useful for specific feature needs. | |
144 */ | |
145 char * dvdcss_interface_2 = VERSION; | |
146 | |
147 /** | |
148 * \brief Open a DVD device or directory and return a dvdcss instance. | |
149 * | |
150 * \param psz_target a string containing the target name, for instance | |
151 * "/dev/hdc" or "E:". | |
152 * \return a handle to a dvdcss instance or NULL on error. | |
153 * | |
154 * Initialize the \e libdvdcss library and open the requested DVD device or | |
155 * directory. \e libdvdcss checks whether ioctls can be performed on the disc, | |
156 * and when possible, the disc key is retrieved. | |
157 * | |
158 * dvdcss_open() returns a handle to be used for all subsequent \e libdvdcss | |
159 * calls. If an error occurred, NULL is returned. | |
160 */ | |
161 LIBDVDCSS_EXPORT dvdcss_t dvdcss_open ( char *psz_target ) | |
162 { | |
163 char psz_buffer[PATH_MAX]; | |
164 int i_ret; | |
165 | |
166 char *psz_method = getenv( "DVDCSS_METHOD" ); | |
167 char *psz_verbose = getenv( "DVDCSS_VERBOSE" ); | |
168 char *psz_cache = getenv( "DVDCSS_CACHE" ); | |
169 #ifndef WIN32 | |
170 char *psz_raw_device = getenv( "DVDCSS_RAW_DEVICE" ); | |
171 #endif | |
172 | |
173 dvdcss_t dvdcss; | |
174 | |
175 /* | |
176 * Allocate the library structure | |
177 */ | |
178 dvdcss = malloc( sizeof( struct dvdcss_s ) ); | |
179 if( dvdcss == NULL ) | |
180 { | |
181 return NULL; | |
182 } | |
183 | |
184 /* | |
185 * Initialize structure with default values | |
186 */ | |
187 #ifndef WIN32 | |
188 dvdcss->i_raw_fd = -1; | |
189 #endif | |
190 dvdcss->p_titles = NULL; | |
191 dvdcss->psz_device = (char *)strdup( psz_target ); | |
192 dvdcss->psz_error = "no error"; | |
193 dvdcss->i_method = DVDCSS_METHOD_KEY; | |
194 dvdcss->psz_cachefile[0] = '\0'; | |
195 dvdcss->b_debug = 0; | |
196 dvdcss->b_errors = 0; | |
197 | |
198 /* | |
199 * Find verbosity from DVDCSS_VERBOSE environment variable | |
200 */ | |
201 if( psz_verbose != NULL ) | |
202 { | |
203 int i = atoi( psz_verbose ); | |
204 | |
205 if( i >= 2 ) dvdcss->b_debug = i; | |
206 if( i >= 1 ) dvdcss->b_errors = 1; | |
207 } | |
208 | |
209 /* | |
210 * Find method from DVDCSS_METHOD environment variable | |
211 */ | |
212 if( psz_method != NULL ) | |
213 { | |
214 if( !strncmp( psz_method, "key", 4 ) ) | |
215 { | |
216 dvdcss->i_method = DVDCSS_METHOD_KEY; | |
217 } | |
218 else if( !strncmp( psz_method, "disc", 5 ) ) | |
219 { | |
220 dvdcss->i_method = DVDCSS_METHOD_DISC; | |
221 } | |
222 else if( !strncmp( psz_method, "title", 5 ) ) | |
223 { | |
224 dvdcss->i_method = DVDCSS_METHOD_TITLE; | |
225 } | |
226 else | |
227 { | |
228 print_error( dvdcss, "unknown decrypt method, please choose " | |
229 "from 'title', 'key' or 'disc'" ); | |
230 free( dvdcss->psz_device ); | |
231 free( dvdcss ); | |
232 return NULL; | |
233 } | |
234 } | |
235 | |
236 /* | |
237 * If DVDCSS_CACHE was not set, try to guess a default value | |
238 */ | |
239 if( psz_cache == NULL || psz_cache[0] == '\0' ) | |
240 { | |
241 #ifdef HAVE_DIRECT_H | |
242 typedef HRESULT( WINAPI *SHGETFOLDERPATH ) | |
243 ( HWND, int, HANDLE, DWORD, LPTSTR ); | |
244 | |
245 # define CSIDL_FLAG_CREATE 0x8000 | |
246 # define CSIDL_APPDATA 0x1A | |
247 # define SHGFP_TYPE_CURRENT 0 | |
248 | |
249 char psz_home[MAX_PATH]; | |
250 HINSTANCE p_dll; | |
251 SHGETFOLDERPATH p_getpath; | |
252 | |
253 *psz_home = '\0'; | |
254 | |
255 /* Load the shfolder dll to retrieve SHGetFolderPath */ | |
256 p_dll = LoadLibrary( "shfolder.dll" ); | |
257 if( p_dll ) | |
258 { | |
259 p_getpath = (void*)GetProcAddress( p_dll, "SHGetFolderPathA" ); | |
260 if( p_getpath ) | |
261 { | |
262 /* Get the "Application Data" folder for the current user */ | |
263 if( p_getpath( NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE, | |
264 NULL, SHGFP_TYPE_CURRENT, psz_home ) == S_OK ) | |
265 { | |
266 FreeLibrary( p_dll ); | |
267 } | |
268 else | |
269 { | |
270 *psz_home = '\0'; | |
271 } | |
272 } | |
273 FreeLibrary( p_dll ); | |
274 } | |
275 | |
276 /* Cache our keys in | |
277 * C:\Documents and Settings\$USER\Application Data\dvdcss\ */ | |
278 if( *psz_home ) | |
279 { | |
280 snprintf( psz_buffer, PATH_MAX, "%s/dvdcss", psz_home ); | |
281 psz_buffer[PATH_MAX-1] = '\0'; | |
282 psz_cache = psz_buffer; | |
283 } | |
284 #else | |
285 char *psz_home = NULL; | |
286 # ifdef HAVE_PWD_H | |
287 struct passwd *p_pwd; | |
288 | |
289 /* Try looking in password file for home dir. */ | |
290 p_pwd = getpwuid(getuid()); | |
291 if( p_pwd ) | |
292 { | |
293 psz_home = p_pwd->pw_dir; | |
294 } | |
295 # endif | |
296 | |
297 if( psz_home == NULL ) | |
298 { | |
299 psz_home = getenv( "HOME" ); | |
300 } | |
301 if( psz_home == NULL ) | |
302 { | |
303 psz_home = getenv( "USERPROFILE" ); | |
304 } | |
305 | |
306 /* Cache our keys in ${HOME}/.dvdcss/ */ | |
307 if( psz_home ) | |
308 { | |
309 snprintf( psz_buffer, PATH_MAX, "%s/.dvdcss", psz_home ); | |
310 psz_buffer[PATH_MAX-1] = '\0'; | |
311 psz_cache = psz_buffer; | |
312 } | |
313 #endif | |
314 } | |
315 | |
316 /* | |
317 * Find cache dir from the DVDCSS_CACHE environment variable | |
318 */ | |
319 if( psz_cache != NULL ) | |
320 { | |
321 if( psz_cache[0] == '\0' || !strcmp( psz_cache, "off" ) ) | |
322 { | |
323 psz_cache = NULL; | |
324 } | |
325 /* Check that we can add the ID directory and the block filename */ | |
326 else if( strlen( psz_cache ) + 1 + 32 + 1 + (KEY_SIZE * 2) + 10 + 1 | |
327 > PATH_MAX ) | |
328 { | |
329 print_error( dvdcss, "cache directory name is too long" ); | |
330 psz_cache = NULL; | |
331 } | |
332 } | |
333 | |
334 /* | |
335 * Open device | |
336 */ | |
337 _dvdcss_check( dvdcss ); | |
338 i_ret = _dvdcss_open( dvdcss ); | |
339 if( i_ret < 0 ) | |
340 { | |
341 free( dvdcss->psz_device ); | |
342 free( dvdcss ); | |
343 return NULL; | |
344 } | |
345 | |
346 dvdcss->b_scrambled = 1; /* Assume the worst */ | |
347 dvdcss->b_ioctls = _dvdcss_use_ioctls( dvdcss ); | |
348 | |
349 if( dvdcss->b_ioctls ) | |
350 { | |
351 i_ret = _dvdcss_test( dvdcss ); | |
352 if( i_ret < 0 ) | |
353 { | |
354 /* Disable the CSS ioctls and hope that it works? */ | |
355 print_debug( dvdcss, | |
356 "could not check whether the disc was scrambled" ); | |
357 dvdcss->b_ioctls = 0; | |
358 } | |
359 else | |
360 { | |
361 print_debug( dvdcss, i_ret ? "disc is scrambled" | |
362 : "disc is unscrambled" ); | |
363 dvdcss->b_scrambled = i_ret; | |
364 } | |
365 } | |
366 | |
367 /* If disc is CSS protected and the ioctls work, authenticate the drive */ | |
368 if( dvdcss->b_scrambled && dvdcss->b_ioctls ) | |
369 { | |
370 i_ret = _dvdcss_disckey( dvdcss ); | |
371 | |
372 if( i_ret < 0 ) | |
373 { | |
374 _dvdcss_close( dvdcss ); | |
375 free( dvdcss->psz_device ); | |
376 free( dvdcss ); | |
377 return NULL; | |
378 } | |
379 } | |
380 | |
381 /* If the cache is enabled, write the cache directory tag */ | |
382 if( psz_cache ) | |
383 { | |
384 char *psz_tag = "Signature: 8a477f597d28d172789f06886806bc55\r\n" | |
385 "# This file is a cache directory tag created by libdvdcss.\r\n" | |
386 "# For information about cache directory tags, see:\r\n" | |
387 "# http://www.brynosaurus.com/cachedir/\r\n"; | |
388 char psz_tagfile[PATH_MAX + 1 + 12 + 1]; | |
389 int i_fd; | |
390 | |
391 sprintf( psz_tagfile, "%s/CACHEDIR.TAG", psz_cache ); | |
392 i_fd = open( psz_tagfile, O_RDWR|O_CREAT, 0644 ); | |
393 if( i_fd >= 0 ) | |
394 { | |
395 write( i_fd, psz_tag, strlen(psz_tag) ); | |
396 close( i_fd ); | |
397 } | |
398 } | |
399 | |
400 /* If the cache is enabled, extract a unique disc ID */ | |
401 if( psz_cache ) | |
402 { | |
403 uint8_t p_sector[DVDCSS_BLOCK_SIZE]; | |
404 char psz_debug[PATH_MAX + 30]; | |
405 char psz_key[1 + KEY_SIZE * 2 + 1]; | |
23708 | 406 char *psz_title; |
407 uint8_t *psz_serial; | |
20613 | 408 int i; |
409 | |
410 /* We read sector 0. If it starts with 0x000001ba (BE), we are | |
411 * reading a VOB file, and we should not cache anything. */ | |
412 | |
413 i_ret = dvdcss->pf_seek( dvdcss, 0 ); | |
414 if( i_ret != 0 ) | |
415 { | |
416 goto nocache; | |
417 } | |
418 | |
419 i_ret = dvdcss->pf_read( dvdcss, p_sector, 1 ); | |
420 if( i_ret != 1 ) | |
421 { | |
422 goto nocache; | |
423 } | |
424 | |
425 if( p_sector[0] == 0x00 && p_sector[1] == 0x00 | |
426 && p_sector[2] == 0x01 && p_sector[3] == 0xba ) | |
427 { | |
428 goto nocache; | |
429 } | |
430 | |
431 /* The data we are looking for is at sector 16 (32768 bytes): | |
432 * - offset 40: disc title (32 uppercase chars) | |
433 * - offset 813: manufacturing date + serial no (16 digits) */ | |
434 | |
435 i_ret = dvdcss->pf_seek( dvdcss, 16 ); | |
436 if( i_ret != 16 ) | |
437 { | |
438 goto nocache; | |
439 } | |
440 | |
441 i_ret = dvdcss->pf_read( dvdcss, p_sector, 1 ); | |
442 if( i_ret != 1 ) | |
443 { | |
444 goto nocache; | |
445 } | |
446 | |
447 /* Get the disc title */ | |
448 psz_title = (char *)p_sector + 40; | |
449 psz_title[32] = '\0'; | |
450 | |
451 for( i = 0 ; i < 32 ; i++ ) | |
452 { | |
453 if( psz_title[i] <= ' ' ) | |
454 { | |
455 psz_title[i] = '\0'; | |
456 break; | |
457 } | |
458 else if( psz_title[i] == '/' || psz_title[i] == '\\' ) | |
459 { | |
460 psz_title[i] = '-'; | |
461 } | |
462 } | |
463 | |
464 /* Get the date + serial */ | |
23708 | 465 psz_serial = p_sector + 813; |
20613 | 466 psz_serial[16] = '\0'; |
467 | |
468 /* Check that all characters are digits, otherwise convert. */ | |
469 for( i = 0 ; i < 16 ; i++ ) | |
470 { | |
471 if( psz_serial[i] < '0' || psz_serial[i] > '9' ) | |
472 { | |
473 char psz_tmp[16 + 1]; | |
474 sprintf( psz_tmp, | |
23707
552963611d77
Fix CSS format strings, they could print more than two digits for
reimar
parents:
20613
diff
changeset
|
475 "%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"", |
20613 | 476 psz_serial[0], psz_serial[1], psz_serial[2], |
477 psz_serial[3], psz_serial[4], psz_serial[5], | |
478 psz_serial[6], psz_serial[7] ); | |
479 memcpy( psz_serial, psz_tmp, 16 ); | |
480 break; | |
481 } | |
482 } | |
483 | |
484 /* Get disk key, since some discs have got same title, manufacturing | |
485 * date and serial number, but different keys */ | |
486 if( dvdcss->b_scrambled ) | |
487 { | |
488 psz_key[0] = '-'; | |
489 for( i = 0; i < KEY_SIZE; i++ ) | |
490 { | |
23707
552963611d77
Fix CSS format strings, they could print more than two digits for
reimar
parents:
20613
diff
changeset
|
491 sprintf( &psz_key[1+i*2], "%.2"PRIx8, dvdcss->css.p_disc_key[i] ); |
20613 | 492 } |
493 psz_key[1 + KEY_SIZE * 2] = '\0'; | |
494 } | |
495 else | |
496 { | |
497 psz_key[0] = 0; | |
498 } | |
499 | |
500 /* We have a disc name or ID, we can create the cache dir */ | |
501 i = sprintf( dvdcss->psz_cachefile, "%s", psz_cache ); | |
502 #if !defined( WIN32 ) || defined( SYS_CYGWIN ) | |
503 i_ret = mkdir( dvdcss->psz_cachefile, 0755 ); | |
504 #else | |
505 i_ret = mkdir( dvdcss->psz_cachefile ); | |
506 #endif | |
507 if( i_ret < 0 && errno != EEXIST ) | |
508 { | |
509 print_error( dvdcss, "failed creating cache directory" ); | |
510 dvdcss->psz_cachefile[0] = '\0'; | |
511 goto nocache; | |
512 } | |
513 | |
514 i += sprintf( dvdcss->psz_cachefile + i, "/%s-%s%s", psz_title, | |
515 psz_serial, psz_key ); | |
516 #if !defined( WIN32 ) || defined( SYS_CYGWIN ) | |
517 i_ret = mkdir( dvdcss->psz_cachefile, 0755 ); | |
518 #else | |
519 i_ret = mkdir( dvdcss->psz_cachefile ); | |
520 #endif | |
521 if( i_ret < 0 && errno != EEXIST ) | |
522 { | |
523 print_error( dvdcss, "failed creating cache subdirectory" ); | |
524 dvdcss->psz_cachefile[0] = '\0'; | |
525 goto nocache; | |
526 } | |
527 i += sprintf( dvdcss->psz_cachefile + i, "/"); | |
528 | |
529 /* Pointer to the filename we will use. */ | |
530 dvdcss->psz_block = dvdcss->psz_cachefile + i; | |
531 | |
532 sprintf( psz_debug, "using CSS key cache dir: %s", | |
533 dvdcss->psz_cachefile ); | |
534 print_debug( dvdcss, psz_debug ); | |
535 } | |
536 nocache: | |
537 | |
538 #ifndef WIN32 | |
539 if( psz_raw_device != NULL ) | |
540 { | |
541 _dvdcss_raw_open( dvdcss, psz_raw_device ); | |
542 } | |
543 #endif | |
544 | |
545 /* Seek at the beginning, just for safety. */ | |
546 dvdcss->pf_seek( dvdcss, 0 ); | |
547 | |
548 return dvdcss; | |
549 } | |
550 | |
551 /** | |
552 * \brief Return a string containing the latest error that occurred in the | |
553 * given \e libdvdcss instance. | |
554 * | |
555 * \param dvdcss a \e libdvdcss instance. | |
556 * \return a null-terminated string containing the latest error message. | |
557 * | |
558 * This function returns a constant string containing the latest error that | |
559 * occurred in \e libdvdcss. It can be used to format error messages at your | |
560 * convenience in your application. | |
561 */ | |
562 LIBDVDCSS_EXPORT char * dvdcss_error ( dvdcss_t dvdcss ) | |
563 { | |
564 return dvdcss->psz_error; | |
565 } | |
566 | |
567 /** | |
568 * \brief Seek in the disc and change the current key if requested. | |
569 * | |
570 * \param dvdcss a \e libdvdcss instance. | |
571 * \param i_blocks an absolute block offset to seek to. | |
572 * \param i_flags #DVDCSS_NOFLAGS, optionally ored with one of #DVDCSS_SEEK_KEY | |
573 * or #DVDCSS_SEEK_MPEG. | |
574 * \return the new position in blocks, or a negative value in case an error | |
575 * happened. | |
576 * | |
577 * This function seeks to the requested position, in logical blocks. | |
578 * | |
579 * You typically set \p i_flags to #DVDCSS_NOFLAGS when seeking in a .IFO. | |
580 * | |
581 * If #DVDCSS_SEEK_MPEG is specified in \p i_flags and if \e libdvdcss finds it | |
582 * reasonable to do so (ie, if the dvdcss method is not "title"), the current | |
583 * title key will be checked and a new one will be calculated if necessary. | |
584 * This flag is typically used when reading data from a VOB. | |
585 * | |
586 * If #DVDCSS_SEEK_KEY is specified, the title key will be always checked, | |
587 * even with the "title" method. This is equivalent to using the now | |
588 * deprecated dvdcss_title() call. This flag is typically used when seeking | |
589 * in a new title. | |
590 */ | |
591 LIBDVDCSS_EXPORT int dvdcss_seek ( dvdcss_t dvdcss, int i_blocks, int i_flags ) | |
592 { | |
593 /* title cracking method is too slow to be used at each seek */ | |
594 if( ( ( i_flags & DVDCSS_SEEK_MPEG ) | |
595 && ( dvdcss->i_method != DVDCSS_METHOD_TITLE ) ) | |
596 || ( i_flags & DVDCSS_SEEK_KEY ) ) | |
597 { | |
598 /* check the title key */ | |
599 if( _dvdcss_title( dvdcss, i_blocks ) ) | |
600 { | |
601 return -1; | |
602 } | |
603 } | |
604 | |
605 return dvdcss->pf_seek( dvdcss, i_blocks ); | |
606 } | |
607 | |
608 /** | |
609 * \brief Read from the disc and decrypt data if requested. | |
610 * | |
611 * \param dvdcss a \e libdvdcss instance. | |
612 * \param p_buffer a buffer that will contain the data read from the disc. | |
613 * \param i_blocks the amount of blocks to read. | |
614 * \param i_flags #DVDCSS_NOFLAGS, optionally ored with #DVDCSS_READ_DECRYPT. | |
615 * \return the amount of blocks read, or a negative value in case an | |
616 * error happened. | |
617 * | |
618 * This function reads \p i_blocks logical blocks from the DVD. | |
619 * | |
620 * You typically set \p i_flags to #DVDCSS_NOFLAGS when reading data from a | |
621 * .IFO file on the DVD. | |
622 * | |
623 * If #DVDCSS_READ_DECRYPT is specified in \p i_flags, dvdcss_read() will | |
624 * automatically decrypt scrambled sectors. This flag is typically used when | |
625 * reading data from a .VOB file on the DVD. It has no effect on unscrambled | |
626 * discs or unscrambled sectors, and can be safely used on those. | |
627 * | |
628 * \warning dvdcss_read() expects to be able to write \p i_blocks * | |
629 * #DVDCSS_BLOCK_SIZE bytes in \p p_buffer. | |
630 */ | |
631 LIBDVDCSS_EXPORT int dvdcss_read ( dvdcss_t dvdcss, void *p_buffer, | |
632 int i_blocks, | |
633 int i_flags ) | |
634 { | |
635 int i_ret, i_index; | |
636 | |
637 i_ret = dvdcss->pf_read( dvdcss, p_buffer, i_blocks ); | |
638 | |
639 if( i_ret <= 0 | |
640 || !dvdcss->b_scrambled | |
641 || !(i_flags & DVDCSS_READ_DECRYPT) ) | |
642 { | |
643 return i_ret; | |
644 } | |
645 | |
646 if( ! memcmp( dvdcss->css.p_title_key, "\0\0\0\0\0", 5 ) ) | |
647 { | |
648 /* For what we believe is an unencrypted title, | |
649 * check that there are no encrypted blocks */ | |
650 for( i_index = i_ret; i_index; i_index-- ) | |
651 { | |
652 if( ((uint8_t*)p_buffer)[0x14] & 0x30 ) | |
653 { | |
654 print_error( dvdcss, "no key but found encrypted block" ); | |
655 /* Only return the initial range of unscrambled blocks? */ | |
656 /* or fail completely? return 0; */ | |
657 break; | |
658 } | |
659 p_buffer = (void *) ((uint8_t *)p_buffer + DVDCSS_BLOCK_SIZE); | |
660 } | |
661 } | |
662 else | |
663 { | |
664 /* Decrypt the blocks we managed to read */ | |
665 for( i_index = i_ret; i_index; i_index-- ) | |
666 { | |
667 _dvdcss_unscramble( dvdcss->css.p_title_key, p_buffer ); | |
668 ((uint8_t*)p_buffer)[0x14] &= 0x8f; | |
669 p_buffer = (void *) ((uint8_t *)p_buffer + DVDCSS_BLOCK_SIZE); | |
670 } | |
671 } | |
672 | |
673 return i_ret; | |
674 } | |
675 | |
676 /** | |
677 * \brief Read from the disc into multiple buffers and decrypt data if | |
678 * requested. | |
679 * | |
680 * \param dvdcss a \e libdvdcss instance. | |
681 * \param p_iovec a pointer to an array of iovec structures that will contain | |
682 * the data read from the disc. | |
683 * \param i_blocks the amount of blocks to read. | |
684 * \param i_flags #DVDCSS_NOFLAGS, optionally ored with #DVDCSS_READ_DECRYPT. | |
685 * \return the amount of blocks read, or a negative value in case an | |
686 * error happened. | |
687 * | |
688 * This function reads \p i_blocks logical blocks from the DVD and writes them | |
689 * to an array of iovec structures. | |
690 * | |
691 * You typically set \p i_flags to #DVDCSS_NOFLAGS when reading data from a | |
692 * .IFO file on the DVD. | |
693 * | |
694 * If #DVDCSS_READ_DECRYPT is specified in \p i_flags, dvdcss_readv() will | |
695 * automatically decrypt scrambled sectors. This flag is typically used when | |
696 * reading data from a .VOB file on the DVD. It has no effect on unscrambled | |
697 * discs or unscrambled sectors, and can be safely used on those. | |
698 * | |
699 * \warning dvdcss_readv() expects to be able to write \p i_blocks * | |
700 * #DVDCSS_BLOCK_SIZE bytes in the buffers pointed by \p p_iovec. | |
701 * Moreover, all iov_len members of the iovec structures should be | |
702 * multiples of #DVDCSS_BLOCK_SIZE. | |
703 */ | |
704 LIBDVDCSS_EXPORT int dvdcss_readv ( dvdcss_t dvdcss, void *p_iovec, | |
705 int i_blocks, | |
706 int i_flags ) | |
707 { | |
708 struct iovec *_p_iovec = (struct iovec *)p_iovec; | |
709 int i_ret, i_index; | |
710 void *iov_base; | |
711 size_t iov_len; | |
712 | |
713 i_ret = dvdcss->pf_readv( dvdcss, _p_iovec, i_blocks ); | |
714 | |
715 if( i_ret <= 0 | |
716 || !dvdcss->b_scrambled | |
717 || !(i_flags & DVDCSS_READ_DECRYPT) ) | |
718 { | |
719 return i_ret; | |
720 } | |
721 | |
722 /* Initialize loop for decryption */ | |
723 iov_base = _p_iovec->iov_base; | |
724 iov_len = _p_iovec->iov_len; | |
725 | |
726 /* Decrypt the blocks we managed to read */ | |
727 for( i_index = i_ret; i_index; i_index-- ) | |
728 { | |
729 /* Check that iov_len is a multiple of 2048 */ | |
730 if( iov_len & 0x7ff ) | |
731 { | |
732 return -1; | |
733 } | |
734 | |
735 while( iov_len == 0 ) | |
736 { | |
737 _p_iovec++; | |
738 iov_base = _p_iovec->iov_base; | |
739 iov_len = _p_iovec->iov_len; | |
740 } | |
741 | |
742 _dvdcss_unscramble( dvdcss->css.p_title_key, iov_base ); | |
743 ((uint8_t*)iov_base)[0x14] &= 0x8f; | |
744 | |
745 iov_base = (void *) ((uint8_t*)iov_base + DVDCSS_BLOCK_SIZE); | |
746 iov_len -= DVDCSS_BLOCK_SIZE; | |
747 } | |
748 | |
749 return i_ret; | |
750 } | |
751 | |
752 /** | |
753 * \brief Close the DVD and clean up the library. | |
754 * | |
755 * \param dvdcss a \e libdvdcss instance. | |
756 * \return zero in case of success, a negative value otherwise. | |
757 * | |
758 * This function closes the DVD device and frees all the memory allocated | |
759 * by \e libdvdcss. On return, the #dvdcss_t is invalidated and may not be | |
760 * used again. | |
761 */ | |
762 LIBDVDCSS_EXPORT int dvdcss_close ( dvdcss_t dvdcss ) | |
763 { | |
764 dvd_title_t *p_title; | |
765 int i_ret; | |
766 | |
767 /* Free our list of keys */ | |
768 p_title = dvdcss->p_titles; | |
769 while( p_title ) | |
770 { | |
771 dvd_title_t *p_tmptitle = p_title->p_next; | |
772 free( p_title ); | |
773 p_title = p_tmptitle; | |
774 } | |
775 | |
776 i_ret = _dvdcss_close( dvdcss ); | |
777 | |
778 if( i_ret < 0 ) | |
779 { | |
780 return i_ret; | |
781 } | |
782 | |
783 free( dvdcss->psz_device ); | |
784 free( dvdcss ); | |
785 | |
786 return 0; | |
787 } | |
788 | |
789 /* | |
790 * Deprecated. See dvdcss_seek(). | |
791 */ | |
792 #undef dvdcss_title | |
793 LIBDVDCSS_EXPORT int dvdcss_title ( dvdcss_t dvdcss, int i_block ) | |
794 { | |
795 return _dvdcss_title( dvdcss, i_block ); | |
796 } | |
797 |