Mercurial > mplayer.hg
annotate libdvdcss/libdvdcss.c @ 27409:e2de11109139
If (has outline) blur(outline) else blur(glyph).
If there is an outline, the glyph itself should not be blurred. Keeps
the border between glyph and outline clear (unblurred), which is
probably how it should be.
Patch by Diogo Franco (diogomfranco gmail com).
author | eugeni |
---|---|
date | Thu, 07 Aug 2008 22:20:58 +0000 |
parents | f0788169e503 |
children | afa2cc0166be |
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 { | |
26234
f0788169e503
Ignore if we fail to get disc key, fixes playback of one of my DVDs which
reimar
parents:
24534
diff
changeset
|
374 print_debug( dvdcss, |
f0788169e503
Ignore if we fail to get disc key, fixes playback of one of my DVDs which
reimar
parents:
24534
diff
changeset
|
375 "could not get disc key" ); |
20613 | 376 } |
377 } | |
378 | |
379 /* If the cache is enabled, write the cache directory tag */ | |
380 if( psz_cache ) | |
381 { | |
382 char *psz_tag = "Signature: 8a477f597d28d172789f06886806bc55\r\n" | |
383 "# This file is a cache directory tag created by libdvdcss.\r\n" | |
384 "# For information about cache directory tags, see:\r\n" | |
385 "# http://www.brynosaurus.com/cachedir/\r\n"; | |
386 char psz_tagfile[PATH_MAX + 1 + 12 + 1]; | |
387 int i_fd; | |
388 | |
389 sprintf( psz_tagfile, "%s/CACHEDIR.TAG", psz_cache ); | |
390 i_fd = open( psz_tagfile, O_RDWR|O_CREAT, 0644 ); | |
391 if( i_fd >= 0 ) | |
392 { | |
393 write( i_fd, psz_tag, strlen(psz_tag) ); | |
394 close( i_fd ); | |
395 } | |
396 } | |
397 | |
398 /* If the cache is enabled, extract a unique disc ID */ | |
399 if( psz_cache ) | |
400 { | |
401 uint8_t p_sector[DVDCSS_BLOCK_SIZE]; | |
402 char psz_debug[PATH_MAX + 30]; | |
403 char psz_key[1 + KEY_SIZE * 2 + 1]; | |
23708 | 404 char *psz_title; |
405 uint8_t *psz_serial; | |
20613 | 406 int i; |
407 | |
408 /* We read sector 0. If it starts with 0x000001ba (BE), we are | |
409 * reading a VOB file, and we should not cache anything. */ | |
410 | |
411 i_ret = dvdcss->pf_seek( dvdcss, 0 ); | |
412 if( i_ret != 0 ) | |
413 { | |
414 goto nocache; | |
415 } | |
416 | |
417 i_ret = dvdcss->pf_read( dvdcss, p_sector, 1 ); | |
418 if( i_ret != 1 ) | |
419 { | |
420 goto nocache; | |
421 } | |
422 | |
423 if( p_sector[0] == 0x00 && p_sector[1] == 0x00 | |
424 && p_sector[2] == 0x01 && p_sector[3] == 0xba ) | |
425 { | |
426 goto nocache; | |
427 } | |
428 | |
429 /* The data we are looking for is at sector 16 (32768 bytes): | |
430 * - offset 40: disc title (32 uppercase chars) | |
431 * - offset 813: manufacturing date + serial no (16 digits) */ | |
432 | |
433 i_ret = dvdcss->pf_seek( dvdcss, 16 ); | |
434 if( i_ret != 16 ) | |
435 { | |
436 goto nocache; | |
437 } | |
438 | |
439 i_ret = dvdcss->pf_read( dvdcss, p_sector, 1 ); | |
440 if( i_ret != 1 ) | |
441 { | |
442 goto nocache; | |
443 } | |
444 | |
445 /* Get the disc title */ | |
446 psz_title = (char *)p_sector + 40; | |
447 psz_title[32] = '\0'; | |
448 | |
449 for( i = 0 ; i < 32 ; i++ ) | |
450 { | |
451 if( psz_title[i] <= ' ' ) | |
452 { | |
453 psz_title[i] = '\0'; | |
454 break; | |
455 } | |
456 else if( psz_title[i] == '/' || psz_title[i] == '\\' ) | |
457 { | |
458 psz_title[i] = '-'; | |
459 } | |
460 } | |
461 | |
462 /* Get the date + serial */ | |
23708 | 463 psz_serial = p_sector + 813; |
20613 | 464 psz_serial[16] = '\0'; |
465 | |
466 /* Check that all characters are digits, otherwise convert. */ | |
467 for( i = 0 ; i < 16 ; i++ ) | |
468 { | |
469 if( psz_serial[i] < '0' || psz_serial[i] > '9' ) | |
470 { | |
471 char psz_tmp[16 + 1]; | |
472 sprintf( psz_tmp, | |
23707
552963611d77
Fix CSS format strings, they could print more than two digits for
reimar
parents:
20613
diff
changeset
|
473 "%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"%.2"PRIx8"", |
20613 | 474 psz_serial[0], psz_serial[1], psz_serial[2], |
475 psz_serial[3], psz_serial[4], psz_serial[5], | |
476 psz_serial[6], psz_serial[7] ); | |
477 memcpy( psz_serial, psz_tmp, 16 ); | |
478 break; | |
479 } | |
480 } | |
481 | |
482 /* Get disk key, since some discs have got same title, manufacturing | |
483 * date and serial number, but different keys */ | |
484 if( dvdcss->b_scrambled ) | |
485 { | |
486 psz_key[0] = '-'; | |
487 for( i = 0; i < KEY_SIZE; i++ ) | |
488 { | |
23707
552963611d77
Fix CSS format strings, they could print more than two digits for
reimar
parents:
20613
diff
changeset
|
489 sprintf( &psz_key[1+i*2], "%.2"PRIx8, dvdcss->css.p_disc_key[i] ); |
20613 | 490 } |
491 psz_key[1 + KEY_SIZE * 2] = '\0'; | |
492 } | |
493 else | |
494 { | |
495 psz_key[0] = 0; | |
496 } | |
497 | |
498 /* We have a disc name or ID, we can create the cache dir */ | |
499 i = sprintf( dvdcss->psz_cachefile, "%s", psz_cache ); | |
500 #if !defined( WIN32 ) || defined( SYS_CYGWIN ) | |
501 i_ret = mkdir( dvdcss->psz_cachefile, 0755 ); | |
502 #else | |
503 i_ret = mkdir( dvdcss->psz_cachefile ); | |
504 #endif | |
505 if( i_ret < 0 && errno != EEXIST ) | |
506 { | |
507 print_error( dvdcss, "failed creating cache directory" ); | |
508 dvdcss->psz_cachefile[0] = '\0'; | |
509 goto nocache; | |
510 } | |
511 | |
512 i += sprintf( dvdcss->psz_cachefile + i, "/%s-%s%s", psz_title, | |
513 psz_serial, psz_key ); | |
514 #if !defined( WIN32 ) || defined( SYS_CYGWIN ) | |
515 i_ret = mkdir( dvdcss->psz_cachefile, 0755 ); | |
516 #else | |
517 i_ret = mkdir( dvdcss->psz_cachefile ); | |
518 #endif | |
519 if( i_ret < 0 && errno != EEXIST ) | |
520 { | |
521 print_error( dvdcss, "failed creating cache subdirectory" ); | |
522 dvdcss->psz_cachefile[0] = '\0'; | |
523 goto nocache; | |
524 } | |
525 i += sprintf( dvdcss->psz_cachefile + i, "/"); | |
526 | |
527 /* Pointer to the filename we will use. */ | |
528 dvdcss->psz_block = dvdcss->psz_cachefile + i; | |
529 | |
530 sprintf( psz_debug, "using CSS key cache dir: %s", | |
531 dvdcss->psz_cachefile ); | |
532 print_debug( dvdcss, psz_debug ); | |
533 } | |
534 nocache: | |
535 | |
536 #ifndef WIN32 | |
537 if( psz_raw_device != NULL ) | |
538 { | |
539 _dvdcss_raw_open( dvdcss, psz_raw_device ); | |
540 } | |
541 #endif | |
542 | |
543 /* Seek at the beginning, just for safety. */ | |
544 dvdcss->pf_seek( dvdcss, 0 ); | |
545 | |
546 return dvdcss; | |
547 } | |
548 | |
549 /** | |
550 * \brief Return a string containing the latest error that occurred in the | |
551 * given \e libdvdcss instance. | |
552 * | |
553 * \param dvdcss a \e libdvdcss instance. | |
554 * \return a null-terminated string containing the latest error message. | |
555 * | |
556 * This function returns a constant string containing the latest error that | |
557 * occurred in \e libdvdcss. It can be used to format error messages at your | |
558 * convenience in your application. | |
559 */ | |
560 LIBDVDCSS_EXPORT char * dvdcss_error ( dvdcss_t dvdcss ) | |
561 { | |
562 return dvdcss->psz_error; | |
563 } | |
564 | |
565 /** | |
566 * \brief Seek in the disc and change the current key if requested. | |
567 * | |
568 * \param dvdcss a \e libdvdcss instance. | |
569 * \param i_blocks an absolute block offset to seek to. | |
570 * \param i_flags #DVDCSS_NOFLAGS, optionally ored with one of #DVDCSS_SEEK_KEY | |
571 * or #DVDCSS_SEEK_MPEG. | |
572 * \return the new position in blocks, or a negative value in case an error | |
573 * happened. | |
574 * | |
575 * This function seeks to the requested position, in logical blocks. | |
576 * | |
577 * You typically set \p i_flags to #DVDCSS_NOFLAGS when seeking in a .IFO. | |
578 * | |
579 * If #DVDCSS_SEEK_MPEG is specified in \p i_flags and if \e libdvdcss finds it | |
580 * reasonable to do so (ie, if the dvdcss method is not "title"), the current | |
581 * title key will be checked and a new one will be calculated if necessary. | |
582 * This flag is typically used when reading data from a VOB. | |
583 * | |
584 * If #DVDCSS_SEEK_KEY is specified, the title key will be always checked, | |
585 * even with the "title" method. This is equivalent to using the now | |
586 * deprecated dvdcss_title() call. This flag is typically used when seeking | |
587 * in a new title. | |
588 */ | |
589 LIBDVDCSS_EXPORT int dvdcss_seek ( dvdcss_t dvdcss, int i_blocks, int i_flags ) | |
590 { | |
591 /* title cracking method is too slow to be used at each seek */ | |
592 if( ( ( i_flags & DVDCSS_SEEK_MPEG ) | |
593 && ( dvdcss->i_method != DVDCSS_METHOD_TITLE ) ) | |
594 || ( i_flags & DVDCSS_SEEK_KEY ) ) | |
595 { | |
596 /* check the title key */ | |
597 if( _dvdcss_title( dvdcss, i_blocks ) ) | |
598 { | |
599 return -1; | |
600 } | |
601 } | |
602 | |
603 return dvdcss->pf_seek( dvdcss, i_blocks ); | |
604 } | |
605 | |
606 /** | |
607 * \brief Read from the disc and decrypt data if requested. | |
608 * | |
609 * \param dvdcss a \e libdvdcss instance. | |
610 * \param p_buffer a buffer that will contain the data read from the disc. | |
611 * \param i_blocks the amount of blocks to read. | |
612 * \param i_flags #DVDCSS_NOFLAGS, optionally ored with #DVDCSS_READ_DECRYPT. | |
613 * \return the amount of blocks read, or a negative value in case an | |
614 * error happened. | |
615 * | |
616 * This function reads \p i_blocks logical blocks from the DVD. | |
617 * | |
618 * You typically set \p i_flags to #DVDCSS_NOFLAGS when reading data from a | |
619 * .IFO file on the DVD. | |
620 * | |
621 * If #DVDCSS_READ_DECRYPT is specified in \p i_flags, dvdcss_read() will | |
622 * automatically decrypt scrambled sectors. This flag is typically used when | |
623 * reading data from a .VOB file on the DVD. It has no effect on unscrambled | |
624 * discs or unscrambled sectors, and can be safely used on those. | |
625 * | |
626 * \warning dvdcss_read() expects to be able to write \p i_blocks * | |
627 * #DVDCSS_BLOCK_SIZE bytes in \p p_buffer. | |
628 */ | |
629 LIBDVDCSS_EXPORT int dvdcss_read ( dvdcss_t dvdcss, void *p_buffer, | |
630 int i_blocks, | |
631 int i_flags ) | |
632 { | |
633 int i_ret, i_index; | |
634 | |
635 i_ret = dvdcss->pf_read( dvdcss, p_buffer, i_blocks ); | |
636 | |
637 if( i_ret <= 0 | |
638 || !dvdcss->b_scrambled | |
639 || !(i_flags & DVDCSS_READ_DECRYPT) ) | |
640 { | |
641 return i_ret; | |
642 } | |
643 | |
644 if( ! memcmp( dvdcss->css.p_title_key, "\0\0\0\0\0", 5 ) ) | |
645 { | |
646 /* For what we believe is an unencrypted title, | |
647 * check that there are no encrypted blocks */ | |
648 for( i_index = i_ret; i_index; i_index-- ) | |
649 { | |
650 if( ((uint8_t*)p_buffer)[0x14] & 0x30 ) | |
651 { | |
652 print_error( dvdcss, "no key but found encrypted block" ); | |
653 /* Only return the initial range of unscrambled blocks? */ | |
654 /* or fail completely? return 0; */ | |
655 break; | |
656 } | |
657 p_buffer = (void *) ((uint8_t *)p_buffer + DVDCSS_BLOCK_SIZE); | |
658 } | |
659 } | |
660 else | |
661 { | |
662 /* Decrypt the blocks we managed to read */ | |
663 for( i_index = i_ret; i_index; i_index-- ) | |
664 { | |
665 _dvdcss_unscramble( dvdcss->css.p_title_key, p_buffer ); | |
666 ((uint8_t*)p_buffer)[0x14] &= 0x8f; | |
667 p_buffer = (void *) ((uint8_t *)p_buffer + DVDCSS_BLOCK_SIZE); | |
668 } | |
669 } | |
670 | |
671 return i_ret; | |
672 } | |
673 | |
674 /** | |
675 * \brief Read from the disc into multiple buffers and decrypt data if | |
676 * requested. | |
677 * | |
678 * \param dvdcss a \e libdvdcss instance. | |
679 * \param p_iovec a pointer to an array of iovec structures that will contain | |
680 * the data read from the disc. | |
681 * \param i_blocks the amount of blocks to read. | |
682 * \param i_flags #DVDCSS_NOFLAGS, optionally ored with #DVDCSS_READ_DECRYPT. | |
683 * \return the amount of blocks read, or a negative value in case an | |
684 * error happened. | |
685 * | |
686 * This function reads \p i_blocks logical blocks from the DVD and writes them | |
687 * to an array of iovec structures. | |
688 * | |
689 * You typically set \p i_flags to #DVDCSS_NOFLAGS when reading data from a | |
690 * .IFO file on the DVD. | |
691 * | |
692 * If #DVDCSS_READ_DECRYPT is specified in \p i_flags, dvdcss_readv() will | |
693 * automatically decrypt scrambled sectors. This flag is typically used when | |
694 * reading data from a .VOB file on the DVD. It has no effect on unscrambled | |
695 * discs or unscrambled sectors, and can be safely used on those. | |
696 * | |
697 * \warning dvdcss_readv() expects to be able to write \p i_blocks * | |
698 * #DVDCSS_BLOCK_SIZE bytes in the buffers pointed by \p p_iovec. | |
699 * Moreover, all iov_len members of the iovec structures should be | |
700 * multiples of #DVDCSS_BLOCK_SIZE. | |
701 */ | |
702 LIBDVDCSS_EXPORT int dvdcss_readv ( dvdcss_t dvdcss, void *p_iovec, | |
703 int i_blocks, | |
704 int i_flags ) | |
705 { | |
706 struct iovec *_p_iovec = (struct iovec *)p_iovec; | |
707 int i_ret, i_index; | |
708 void *iov_base; | |
709 size_t iov_len; | |
710 | |
711 i_ret = dvdcss->pf_readv( dvdcss, _p_iovec, i_blocks ); | |
712 | |
713 if( i_ret <= 0 | |
714 || !dvdcss->b_scrambled | |
715 || !(i_flags & DVDCSS_READ_DECRYPT) ) | |
716 { | |
717 return i_ret; | |
718 } | |
719 | |
720 /* Initialize loop for decryption */ | |
721 iov_base = _p_iovec->iov_base; | |
722 iov_len = _p_iovec->iov_len; | |
723 | |
724 /* Decrypt the blocks we managed to read */ | |
725 for( i_index = i_ret; i_index; i_index-- ) | |
726 { | |
727 /* Check that iov_len is a multiple of 2048 */ | |
728 if( iov_len & 0x7ff ) | |
729 { | |
730 return -1; | |
731 } | |
732 | |
733 while( iov_len == 0 ) | |
734 { | |
735 _p_iovec++; | |
736 iov_base = _p_iovec->iov_base; | |
737 iov_len = _p_iovec->iov_len; | |
738 } | |
739 | |
740 _dvdcss_unscramble( dvdcss->css.p_title_key, iov_base ); | |
741 ((uint8_t*)iov_base)[0x14] &= 0x8f; | |
742 | |
743 iov_base = (void *) ((uint8_t*)iov_base + DVDCSS_BLOCK_SIZE); | |
744 iov_len -= DVDCSS_BLOCK_SIZE; | |
745 } | |
746 | |
747 return i_ret; | |
748 } | |
749 | |
750 /** | |
751 * \brief Close the DVD and clean up the library. | |
752 * | |
753 * \param dvdcss a \e libdvdcss instance. | |
754 * \return zero in case of success, a negative value otherwise. | |
755 * | |
756 * This function closes the DVD device and frees all the memory allocated | |
757 * by \e libdvdcss. On return, the #dvdcss_t is invalidated and may not be | |
758 * used again. | |
759 */ | |
760 LIBDVDCSS_EXPORT int dvdcss_close ( dvdcss_t dvdcss ) | |
761 { | |
762 dvd_title_t *p_title; | |
763 int i_ret; | |
764 | |
765 /* Free our list of keys */ | |
766 p_title = dvdcss->p_titles; | |
767 while( p_title ) | |
768 { | |
769 dvd_title_t *p_tmptitle = p_title->p_next; | |
770 free( p_title ); | |
771 p_title = p_tmptitle; | |
772 } | |
773 | |
774 i_ret = _dvdcss_close( dvdcss ); | |
775 | |
776 if( i_ret < 0 ) | |
777 { | |
778 return i_ret; | |
779 } | |
780 | |
781 free( dvdcss->psz_device ); | |
782 free( dvdcss ); | |
783 | |
784 return 0; | |
785 } | |
786 | |
787 /* | |
788 * Deprecated. See dvdcss_seek(). | |
789 */ | |
790 #undef dvdcss_title | |
791 LIBDVDCSS_EXPORT int dvdcss_title ( dvdcss_t dvdcss, int i_block ) | |
792 { | |
793 return _dvdcss_title( dvdcss, i_block ); | |
794 } | |
795 |