git.sesse.net Git - vlc/blob - modules/stream_filter/rar.c

   1 /*****************************************************************************
   2  * rar.c: uncompressed RAR stream filter (only the biggest file is extracted)
   3  *****************************************************************************
   4  * Copyright (C) 2008 Laurent Aimar
   5  * $Id$
   6  *
   7  * Author: Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <vlc_common.h>
  32 #include <vlc_plugin.h>
  33 #include <vlc_stream.h>
  34
  35 #include <assert.h>
  36 #include <limits.h>
  37
  38 /*****************************************************************************
  39  * Module descriptor
  40  *****************************************************************************/
  41 static int  Open ( vlc_object_t * );
  42 static void Close( vlc_object_t * );
  43
  44 vlc_module_begin()
  45     set_category( CAT_INPUT )
  46     set_subcategory( SUBCAT_INPUT_STREAM_FILTER )
  47     set_description( N_("Uncompressed RAR") )
  48     set_capability( "stream_filter", 1 )
  49     set_callbacks( Open, Close )
  50 vlc_module_end()
  51
  52 /*****************************************************************************
  53  *
  54  *****************************************************************************/
  55 static const uint8_t p_rar_marker[] = {
  56     0x52, 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00
  57 };
  58 static const int i_rar_marker = sizeof(p_rar_marker);
  59
  60 typedef struct
  61 {
  62     uint64_t i_offset;
  63     uint64_t i_size;
  64     uint64_t i_cummulated_size;
  65 } rar_file_chunk_t;
  66 typedef struct
  67 {
  68     char     *psz_name;
  69     uint64_t i_size;
  70     bool     b_complete;
  71
  72     int              i_chunk;
  73     rar_file_chunk_t **pp_chunk;
  74     uint64_t         i_real_size;  /* Gathered size */
  75 } rar_file_t;
  76
  77 static void RarFileDelete( rar_file_t * );
  78
  79 struct stream_sys_t
  80 {
  81     rar_file_t *p_file;
  82     const rar_file_chunk_t *p_chunk;
  83
  84     uint64_t i_position;
  85
  86     uint8_t *p_peek_alloc;
  87     uint8_t *p_peek;
  88     unsigned int i_peek;
  89 };
  90
  91
  92 /****************************************************************************
  93  * Local prototypes
  94  ****************************************************************************/
  95 static int  Read   ( stream_t *, void *p_read, unsigned int i_read );
  96 static int  Peek   ( stream_t *, const uint8_t **pp_peek, unsigned int i_peek );
  97 static int  Control( stream_t *, int i_query, va_list );
  98
  99 static int  Parse  ( stream_t * );
 100 static int  Seek   ( stream_t *s, uint64_t i_position );
 101
 102 /****************************************************************************
 103  * Open
 104  ****************************************************************************/
 105 static int Open ( vlc_object_t *p_this )
 106 {
 107     stream_t *s = (stream_t*)p_this;
 108     stream_sys_t *p_sys;
 109
 110     /* */
 111     const uint8_t *p_peek;
 112     if( stream_Peek( s->p_source, &p_peek, i_rar_marker ) < i_rar_marker )
 113         return VLC_EGENERIC;
 114     if( memcmp( p_peek, p_rar_marker, i_rar_marker ) )
 115         return VLC_EGENERIC;
 116
 117     /* */
 118     s->pf_read = Read;
 119     s->pf_peek = Peek;
 120     s->pf_control = Control;
 121
 122     s->p_sys = p_sys = malloc( sizeof( *p_sys ) );
 123     if( !p_sys )
 124         return VLC_ENOMEM;
 125
 126     /* */
 127     p_sys->p_file = NULL;
 128     p_sys->i_position = 0;
 129     p_sys->p_chunk = NULL;
 130
 131     p_sys->p_peek_alloc = NULL;
 132     p_sys->p_peek = NULL;
 133     p_sys->i_peek = 0;
 134
 135     /* */
 136     if( Parse( s ) || !p_sys->p_file || p_sys->p_file->i_chunk <= 0 )
 137     {
 138         msg_Err( s, "Invalid or unsupported RAR archive" );
 139         if( p_sys->p_file )
 140             RarFileDelete( p_sys->p_file );
 141         free( p_sys );
 142         return VLC_EGENERIC;
 143     }
 144
 145     /* */
 146     Seek( s, 0 );
 147
 148     /* */
 149     const rar_file_t *p_file = p_sys->p_file;
 150     msg_Dbg( s, "Using RAR stream filter for '%s' %"PRId64"(expected %"PRId64") bytes in %d chunks",
 151              p_file->psz_name, p_file->i_real_size, p_file->i_size, p_file->i_chunk );
 152
 153     return VLC_SUCCESS;
 154 }
 155
 156 /****************************************************************************
 157  * Close
 158  ****************************************************************************/
 159 static void Close( vlc_object_t *p_this )
 160 {
 161     stream_t *s = (stream_t*)p_this;
 162     stream_sys_t *p_sys = s->p_sys;
 163
 164     RarFileDelete( p_sys->p_file );
 165     free( p_sys->p_peek_alloc );
 166     free( p_sys );
 167 }
 168
 169 /****************************************************************************
 170  * Stream filters functions
 171  ****************************************************************************/
 172 static int Read( stream_t *s, void *p_read, unsigned int i_read )
 173 {
 174     stream_sys_t *p_sys = s->p_sys;
 175     uint8_t *p_data = p_read;
 176     unsigned int i_total = 0;
 177
 178     if( p_sys->i_peek > 0 && i_read > 0 )
 179     {
 180         const unsigned int i_copy = __MIN( i_read, p_sys->i_peek );
 181
 182         if( p_data )
 183         {
 184             memcpy( p_data, p_sys->p_peek, i_copy );
 185             p_data += i_copy;
 186         }
 187
 188         p_sys->i_peek -= i_copy;
 189         p_sys->p_peek += i_copy;
 190         i_total += i_copy;
 191     }
 192
 193     while( i_total < i_read )
 194     {
 195         const uint64_t i_chunk_end = p_sys->p_chunk->i_cummulated_size + p_sys->p_chunk->i_size;
 196
 197         int i_max = __MIN( i_read - i_total, i_chunk_end - p_sys->i_position );
 198         if( i_max <= 0 )
 199             break;
 200
 201         int i_real = stream_Read( s->p_source, p_data, i_max );
 202         if( i_real <= 0 )
 203             break;
 204
 205         i_total += i_real;
 206         if( p_data )
 207             p_data += i_real;
 208         p_sys->i_position += i_real;
 209         if( p_sys->i_position >= i_chunk_end )
 210         {
 211             if( Seek( s, p_sys->i_position ) )
 212                 break;
 213         }
 214     }
 215     return i_total;
 216 }
 217
 218 static int Peek( stream_t *s, const uint8_t **pp_peek, unsigned int i_peek )
 219 {
 220     stream_sys_t *p_sys = s->p_sys;
 221
 222     if( i_peek <= p_sys->i_peek )
 223     {
 224         *pp_peek = p_sys->p_peek;
 225         return i_peek;
 226     }
 227
 228     /* */
 229     uint8_t *p_peek = malloc( i_peek );
 230     if( !p_peek )
 231         return 0;
 232
 233     /* XXX yes stream_Read on ourself */
 234     int i_read = stream_Read( s, p_peek, i_peek );
 235     if( i_read <= 0 )
 236     {
 237         free( p_peek );
 238         return i_read;
 239     }
 240
 241     free( p_sys->p_peek_alloc );
 242
 243     p_sys->p_peek_alloc =
 244     p_sys->p_peek       = p_peek;
 245     p_sys->i_peek       = i_read;
 246
 247     *pp_peek = p_sys->p_peek;
 248     return p_sys->i_peek;
 249 }
 250
 251 static int Control( stream_t *s, int i_query, va_list args )
 252 {
 253     stream_sys_t *p_sys = s->p_sys;
 254
 255     switch( i_query )
 256     {
 257     /* */
 258     case STREAM_SET_POSITION:
 259     {
 260         uint64_t i_position = va_arg( args, uint64_t );
 261         return Seek( s, i_position );
 262     }
 263
 264     case STREAM_GET_POSITION:
 265     {
 266         uint64_t *pi_position = va_arg( args, uint64_t* );
 267         *pi_position = p_sys->i_position - p_sys->i_peek;
 268         return VLC_SUCCESS;
 269     }
 270
 271     case STREAM_GET_SIZE:
 272     {
 273         uint64_t *pi_size = (uint64_t*)va_arg( args, uint64_t* );
 274         *pi_size = p_sys->p_file->i_real_size;
 275         return VLC_SUCCESS;
 276     }
 277
 278     /* */
 279     case STREAM_GET_CONTENT_TYPE: /* arg1= char ** */
 280         return VLC_EGENERIC;
 281
 282     case STREAM_UPDATE_SIZE: /* TODO maybe we should update i_real_size from file size and chunk offset ? */
 283     case STREAM_CONTROL_ACCESS:
 284     case STREAM_CAN_SEEK:
 285     case STREAM_CAN_FASTSEEK:
 286     case STREAM_SET_RECORD_STATE:
 287         return stream_vaControl( s->p_source, i_query, args );
 288     default:
 289         return VLC_EGENERIC;
 290     }
 291 }
 292
 293 /****************************************************************************
 294  * Helpers
 295  ****************************************************************************/
 296 static int Seek( stream_t *s, uint64_t i_position )
 297 {
 298     stream_sys_t *p_sys = s->p_sys;
 299
 300     if( i_position > p_sys->p_file->i_real_size )
 301         i_position = p_sys->p_file->i_real_size;
 302
 303     /* Search the chunk */
 304     const rar_file_t *p_file = p_sys->p_file;
 305     for( int i = 0; i < p_file->i_chunk; i++ )
 306     {
 307         p_sys->p_chunk = p_file->pp_chunk[i];
 308         if( i_position < p_sys->p_chunk->i_cummulated_size + p_sys->p_chunk->i_size )
 309             break;
 310     }
 311     p_sys->i_position = i_position;
 312     p_sys->i_peek     = 0;
 313
 314     const uint64_t i_seek = p_sys->p_chunk->i_offset +
 315                             ( i_position - p_sys->p_chunk->i_cummulated_size );
 316     return stream_Seek( s->p_source, i_seek );
 317 }
 318
 319 static void RarFileDelete( rar_file_t *p_file )
 320 {
 321     for( int i = 0; i < p_file->i_chunk; i++ )
 322         free( p_file->pp_chunk[i] );
 323     free( p_file->pp_chunk );
 324     free( p_file->psz_name );
 325     free( p_file );
 326 }
 327
 328 typedef struct
 329 {
 330     uint16_t i_crc;
 331     uint8_t  i_type;
 332     uint16_t i_flags;
 333     uint16_t i_size;
 334     uint32_t i_add_size;
 335 } rar_block_t;
 336
 337 enum
 338 {
 339     RAR_BLOCK_MARKER = 0x72,
 340     RAR_BLOCK_ARCHIVE = 0x73,
 341     RAR_BLOCK_FILE = 0x74,
 342     RAR_BLOCK_END = 0x7b,
 343 };
 344 enum
 345 {
 346     RAR_BLOCK_END_HAS_NEXT = 0x0001,
 347 };
 348 enum
 349 {
 350     RAR_BLOCK_FILE_HAS_PREVIOUS = 0x0001,
 351     RAR_BLOCK_FILE_HAS_NEXT     = 0x0002,
 352     RAR_BLOCK_FILE_HAS_HIGH     = 0x0100,
 353 };
 354
 355 static int PeekBlock( stream_t *s, rar_block_t *p_hdr )
 356 {
 357     const uint8_t *p_peek;
 358     int i_peek = stream_Peek( s->p_source, &p_peek, 11 );
 359
 360     if( i_peek < 7 )
 361         return VLC_EGENERIC;
 362
 363     p_hdr->i_crc   = GetWLE( &p_peek[0] );
 364     p_hdr->i_type  = p_peek[2];
 365     p_hdr->i_flags = GetWLE( &p_peek[3] );
 366     p_hdr->i_size  = GetWLE( &p_peek[5] );
 367     p_hdr->i_add_size = 0;
 368     if( p_hdr->i_flags & 0x8000 )
 369     {
 370         if( i_peek < 11 )
 371             return VLC_EGENERIC;
 372         p_hdr->i_add_size = GetDWLE( &p_peek[7] );
 373     }
 374
 375     if( p_hdr->i_size < 7 )
 376         return VLC_EGENERIC;
 377     return VLC_SUCCESS;
 378 }
 379 static int SkipBlock( stream_t *s, const rar_block_t *p_hdr )
 380 {
 381     uint64_t i_size = (uint64_t)p_hdr->i_size + p_hdr->i_add_size;
 382
 383     while( i_size > 0 )
 384     {
 385         int i_skip = __MIN( i_size, INT_MAX );
 386         if( stream_Read( s->p_source, NULL, i_skip ) < i_skip )
 387             return VLC_EGENERIC;
 388
 389         i_size -= i_skip;
 390     }
 391     return VLC_SUCCESS;
 392 }
 393
 394 static int IgnoreBlock( stream_t *s, int i_block )
 395 {
 396     /* */
 397     rar_block_t bk;
 398     if( PeekBlock( s, &bk ) || bk.i_type != i_block )
 399         return VLC_EGENERIC;
 400     return SkipBlock( s, &bk );
 401 }
 402
 403 static int SkipEnd( stream_t *s, const rar_block_t *p_hdr )
 404 {
 405     if( !(p_hdr->i_flags & RAR_BLOCK_END_HAS_NEXT) )
 406         return VLC_EGENERIC;
 407
 408     if( SkipBlock( s, p_hdr ) )
 409         return VLC_EGENERIC;
 410
 411     /* Now, we need to look for a marker block,
 412      * It seems that there is garbage at EOF */
 413     for( ;; )
 414     {
 415         const uint8_t *p_peek;
 416
 417         if( stream_Peek( s->p_source, &p_peek, i_rar_marker ) < i_rar_marker )
 418             return VLC_EGENERIC;
 419
 420         if( !memcmp( p_peek, p_rar_marker, i_rar_marker ) )
 421             break;
 422
 423         if( stream_Read( s->p_source, NULL, 1 ) != 1 )
 424             return VLC_EGENERIC;
 425     }
 426
 427     /* Skip marker and archive blocks */
 428     if( IgnoreBlock( s, RAR_BLOCK_MARKER ) )
 429         return VLC_EGENERIC;
 430     if( IgnoreBlock( s, RAR_BLOCK_ARCHIVE ) )
 431         return VLC_EGENERIC;
 432
 433     return VLC_SUCCESS;
 434 }
 435
 436 static int SkipFile( stream_t *s,const rar_block_t *p_hdr )
 437 {
 438     stream_sys_t *p_sys = s->p_sys;
 439     const uint8_t *p_peek;
 440
 441     int i_min_size = 7+21;
 442     if( p_hdr->i_flags & RAR_BLOCK_FILE_HAS_HIGH )
 443         i_min_size += 8;
 444     if( p_hdr->i_size < (unsigned)i_min_size )
 445         return VLC_EGENERIC;
 446
 447     if( stream_Peek( s->p_source, &p_peek, i_min_size ) < i_min_size )
 448         return VLC_EGENERIC;
 449
 450     /* */
 451     uint32_t i_file_size_low = GetDWLE( &p_peek[7+4] );
 452     uint8_t  i_method = p_peek[7+18];
 453     uint16_t i_name_size = GetWLE( &p_peek[7+19] );
 454     uint32_t i_file_size_high = 0;
 455     if( p_hdr->i_flags & RAR_BLOCK_FILE_HAS_HIGH )
 456         i_file_size_high = GetDWLE( &p_peek[7+25] );
 457
 458     char *psz_name = calloc( 1, i_name_size + 1 );
 459     if( !psz_name )
 460         return VLC_EGENERIC;
 461
 462     const int i_name_offset = (p_hdr->i_flags & RAR_BLOCK_FILE_HAS_HIGH) ? (7+33) : (7+25);
 463     if( i_name_offset + i_name_size <= p_hdr->i_size )
 464     {
 465         const int i_max_size = i_name_offset + i_name_size;
 466         if( stream_Peek( s->p_source, &p_peek, i_max_size ) < i_max_size )
 467         {
 468             free( psz_name );
 469             return VLC_EGENERIC;
 470         }
 471         memcpy( psz_name, &p_peek[i_name_offset], i_name_size );
 472     }
 473
 474     if( i_method != 0x30 )
 475     {
 476         msg_Warn( s, "Ignoring compressed file %s (method=0x%2.2x)", psz_name, i_method );
 477         goto exit;
 478     }
 479
 480     /* Ignore smaller files */
 481     const uint64_t i_file_size = ((uint64_t)i_file_size_high << 32) | i_file_size_low;
 482     if( p_sys->p_file &&
 483         p_sys->p_file->i_size < i_file_size )
 484     {
 485         RarFileDelete( p_sys->p_file );
 486         p_sys->p_file = NULL;
 487     }
 488     /* */
 489     rar_file_t *p_current = p_sys->p_file;
 490     if( !p_current )
 491     {
 492         p_sys->p_file = p_current = malloc( sizeof( *p_sys->p_file ) );
 493         if( !p_current )
 494             goto exit;
 495
 496         /* */
 497         p_current->psz_name = psz_name;
 498         p_current->i_size = i_file_size;
 499         p_current->b_complete = false;
 500         p_current->i_real_size = 0;
 501         TAB_INIT( p_current->i_chunk, p_current->pp_chunk );
 502
 503         psz_name = NULL;
 504     }
 505
 506     /* Append chunks */
 507     if( !p_current->b_complete )
 508     {
 509         bool b_append = false;
 510         /* Append if first chunk */
 511         if( p_current->i_chunk <= 0 )
 512             b_append = true;
 513         /* Append if it is really a continuous chunck */
 514         if( p_current->i_size == i_file_size &&
 515             ( !psz_name || !strcmp( p_current->psz_name, psz_name ) ) &&
 516             ( p_hdr->i_flags & RAR_BLOCK_FILE_HAS_PREVIOUS ) )
 517             b_append = true;
 518
 519         if( b_append )
 520         {
 521             rar_file_chunk_t *p_chunk = malloc( sizeof( *p_chunk ) );
 522             if( p_chunk )
 523             {
 524                 p_chunk->i_offset = stream_Tell( s->p_source ) + p_hdr->i_size;
 525                 p_chunk->i_size = p_hdr->i_add_size;
 526                 p_chunk->i_cummulated_size = 0;
 527                 if( p_current->i_chunk > 0 )
 528                 {
 529                     rar_file_chunk_t *p_previous = p_current->pp_chunk[p_current->i_chunk-1];
 530
 531                     p_chunk->i_cummulated_size += p_previous->i_cummulated_size +
 532                                                   p_previous->i_size;
 533                 }
 534
 535                 TAB_APPEND( p_current->i_chunk, p_current->pp_chunk, p_chunk );
 536
 537                 p_current->i_real_size += p_hdr->i_add_size;
 538             }
 539         }
 540
 541         if( !(p_hdr->i_flags & RAR_BLOCK_FILE_HAS_NEXT ) )
 542             p_current->b_complete = true;
 543     }
 544
 545 exit:
 546     /* */
 547     free( psz_name );
 548
 549     /* We stop on the first non empty file if we cannot seek */
 550     if( p_sys->p_file )
 551     {
 552         bool b_can_seek = false;
 553         stream_Control( s->p_source, STREAM_CAN_SEEK, &b_can_seek );
 554         if( !b_can_seek && p_current->i_size > 0 )
 555             return VLC_EGENERIC;
 556     }
 557
 558     if( SkipBlock( s, p_hdr ) )
 559         return VLC_EGENERIC;
 560     return VLC_SUCCESS;
 561 }
 562
 563 static int Parse( stream_t *s )
 564 {
 565     /* Skip marker */
 566     if( IgnoreBlock( s, RAR_BLOCK_MARKER ) )
 567         return VLC_EGENERIC;
 568
 569     /* Skip archive  */
 570     if( IgnoreBlock( s, RAR_BLOCK_ARCHIVE ) )
 571         return VLC_EGENERIC;
 572
 573     /* */
 574     for( ;; )
 575     {
 576         rar_block_t bk;
 577         int i_ret;
 578
 579         if( PeekBlock( s, &bk ) )
 580             break;
 581
 582         switch( bk.i_type )
 583         {
 584         case RAR_BLOCK_END:
 585             i_ret = SkipEnd( s, &bk );
 586             break;
 587         case RAR_BLOCK_FILE:
 588             i_ret = SkipFile( s, &bk );
 589             break;
 590         default:
 591             i_ret = SkipBlock( s, &bk );
 592             break;
 593         }
 594         if( i_ret )
 595             break;
 596     }
 597
 598     return VLC_SUCCESS;
 599 }