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     int64_t i_offset;
  63     int64_t i_size;
  64     int64_t i_cummulated_size;
  65 } rar_file_chunk_t;
  66 typedef struct
  67 {
  68     char     *psz_name;
  69     int64_t  i_size;
  70     bool     b_complete;
  71
  72     int              i_chunk;
  73     rar_file_chunk_t **pp_chunk;
  74     int64_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     int64_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, int64_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' %lld(expected %lld) 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 int64_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     if( p_sys->p_peek_alloc )
 242         free( p_sys->p_peek_alloc );
 243
 244     p_sys->p_peek_alloc =
 245     p_sys->p_peek       = p_peek;
 246     p_sys->i_peek       = i_read;
 247
 248     *pp_peek = p_sys->p_peek;
 249     return p_sys->i_peek;
 250 }
 251
 252 static int Control( stream_t *s, int i_query, va_list args )
 253 {
 254     stream_sys_t *p_sys = s->p_sys;
 255
 256     switch( i_query )
 257     {
 258     /* */
 259     case STREAM_SET_POSITION:
 260     {
 261         int64_t i_position = (int64_t)va_arg( args, int64_t );
 262         return Seek( s, i_position );
 263     }
 264
 265     case STREAM_GET_POSITION:
 266     {
 267         int64_t *pi_position = (int64_t*)va_arg( args, int64_t* );
 268         *pi_position = p_sys->i_position - p_sys->i_peek;
 269         return VLC_SUCCESS;
 270     }
 271
 272     case STREAM_GET_SIZE:
 273     {
 274         int64_t *pi_size = (int64_t*)va_arg( args, int64_t* );
 275         *pi_size = p_sys->p_file->i_real_size;
 276         return VLC_SUCCESS;
 277     }
 278
 279     /* */
 280     case STREAM_GET_CONTENT_TYPE: /* arg1= char ** */
 281         return VLC_EGENERIC;
 282
 283     case STREAM_UPDATE_SIZE: /* TODO maybe we should update i_real_size from file size and chunk offset ? */
 284     case STREAM_CONTROL_ACCESS:
 285     case STREAM_CAN_SEEK:
 286     case STREAM_CAN_FASTSEEK:
 287     case STREAM_SET_RECORD_STATE:
 288         return stream_vaControl( s->p_source, i_query, args );
 289     default:
 290         return VLC_EGENERIC;
 291     }
 292 }
 293
 294 /****************************************************************************
 295  * Helpers
 296  ****************************************************************************/
 297 static int Seek( stream_t *s, int64_t i_position )
 298 {
 299     stream_sys_t *p_sys = s->p_sys;
 300
 301     if( i_position < 0 )
 302         i_position = 0;
 303     else if( i_position > p_sys->p_file->i_real_size )
 304         i_position = p_sys->p_file->i_real_size;
 305
 306     /* Search the chunk */
 307     const rar_file_t *p_file = p_sys->p_file;
 308     for( int i = 0; i < p_file->i_chunk; i++ )
 309     {
 310         p_sys->p_chunk = p_file->pp_chunk[i];
 311         if( i_position < p_sys->p_chunk->i_cummulated_size + p_sys->p_chunk->i_size )
 312             break;
 313     }
 314     p_sys->i_position = i_position;
 315     p_sys->i_peek     = 0;
 316
 317     const int64_t i_seek = p_sys->p_chunk->i_offset +
 318                            ( i_position - p_sys->p_chunk->i_cummulated_size );
 319     return stream_Seek( s->p_source, i_seek );
 320 }
 321
 322 static void RarFileDelete( rar_file_t *p_file )
 323 {
 324     for( int i = 0; i < p_file->i_chunk; i++ )
 325         free( p_file->pp_chunk[i] );
 326     free( p_file->pp_chunk );
 327     free( p_file->psz_name );
 328     free( p_file );
 329 }
 330
 331 typedef struct
 332 {
 333     uint16_t i_crc;
 334     uint8_t  i_type;
 335     uint16_t i_flags;
 336     uint16_t i_size;
 337     uint32_t i_add_size;
 338 } rar_block_t;
 339
 340 enum
 341 {
 342     RAR_BLOCK_MARKER = 0x72,
 343     RAR_BLOCK_ARCHIVE = 0x73,
 344     RAR_BLOCK_FILE = 0x74,
 345     RAR_BLOCK_END = 0x7b,
 346 };
 347 enum
 348 {
 349     RAR_BLOCK_END_HAS_NEXT = 0x0001,
 350 };
 351 enum
 352 {
 353     RAR_BLOCK_FILE_HAS_PREVIOUS = 0x0001,
 354     RAR_BLOCK_FILE_HAS_NEXT     = 0x0002,
 355     RAR_BLOCK_FILE_HAS_HIGH     = 0x0100,
 356 };
 357
 358 static int PeekBlock( stream_t *s, rar_block_t *p_hdr )
 359 {
 360     const uint8_t *p_peek;
 361     int i_peek = stream_Peek( s->p_source, &p_peek, 11 );
 362
 363     if( i_peek < 7 )
 364         return VLC_EGENERIC;
 365
 366     p_hdr->i_crc   = GetWLE( &p_peek[0] );
 367     p_hdr->i_type  = p_peek[2];
 368     p_hdr->i_flags = GetWLE( &p_peek[3] );
 369     p_hdr->i_size  = GetWLE( &p_peek[5] );
 370     p_hdr->i_add_size = 0;
 371     if( p_hdr->i_flags & 0x8000 )
 372     {
 373         if( i_peek < 11 )
 374             return VLC_EGENERIC;
 375         p_hdr->i_add_size = GetDWLE( &p_peek[7] );
 376     }
 377
 378     if( p_hdr->i_size < 7 )
 379         return VLC_EGENERIC;
 380     return VLC_SUCCESS;
 381 }
 382 static int SkipBlock( stream_t *s, const rar_block_t *p_hdr )
 383 {
 384     int64_t i_size = (int64_t)p_hdr->i_size + p_hdr->i_add_size;
 385
 386     assert( i_size >= 0 );
 387     while( i_size > 0 )
 388     {
 389         int i_skip = __MIN( i_size, INT_MAX );
 390         if( stream_Read( s->p_source, NULL, i_skip ) < i_skip )
 391             return VLC_EGENERIC;
 392
 393         i_size -= i_skip;
 394     }
 395     return VLC_SUCCESS;
 396 }
 397
 398 static int IgnoreBlock( stream_t *s, int i_block )
 399 {
 400     /* */
 401     rar_block_t bk;
 402     if( PeekBlock( s, &bk ) || bk.i_type != i_block )
 403         return VLC_EGENERIC;
 404     return SkipBlock( s, &bk );
 405 }
 406
 407 static int SkipEnd( stream_t *s, const rar_block_t *p_hdr )
 408 {
 409     if( !(p_hdr->i_flags & RAR_BLOCK_END_HAS_NEXT) )
 410         return VLC_EGENERIC;
 411
 412     if( SkipBlock( s, p_hdr ) )
 413         return VLC_EGENERIC;
 414
 415     /* Now, we need to look for a marker block,
 416      * It seems that there is garbage at EOF */
 417     for( ;; )
 418     {
 419         const uint8_t *p_peek;
 420
 421         if( stream_Peek( s->p_source, &p_peek, i_rar_marker ) < i_rar_marker )
 422             return VLC_EGENERIC;
 423
 424         if( !memcmp( p_peek, p_rar_marker, i_rar_marker ) )
 425             break;
 426
 427         if( stream_Read( s->p_source, NULL, 1 ) != 1 )
 428             return VLC_EGENERIC;
 429     }
 430
 431     /* Skip marker and archive blocks */
 432     if( IgnoreBlock( s, RAR_BLOCK_MARKER ) )
 433         return VLC_EGENERIC;
 434     if( IgnoreBlock( s, RAR_BLOCK_ARCHIVE ) )
 435         return VLC_EGENERIC;
 436
 437     return VLC_SUCCESS;
 438 }
 439
 440 static int SkipFile( stream_t *s,const rar_block_t *p_hdr )
 441 {
 442     stream_sys_t *p_sys = s->p_sys;
 443     const uint8_t *p_peek;
 444
 445     if( stream_Peek( s->p_source, &p_peek, p_hdr->i_size ) < p_hdr->i_size )
 446         return VLC_EGENERIC;
 447
 448     int i_min_size = 7+21;
 449     if( p_hdr->i_flags & RAR_BLOCK_FILE_HAS_HIGH )
 450         i_min_size += 8;
 451     if( p_hdr->i_size < i_min_size )
 452         return VLC_EGENERIC;
 453
 454     /* */
 455     uint32_t i_file_size_low = GetDWLE( &p_peek[7+4] );
 456     uint8_t  i_method = p_peek[7+18];
 457     uint16_t i_name_size = GetWLE( &p_peek[7+19] );
 458     uint32_t i_file_size_high = 0;
 459     if( p_hdr->i_flags & RAR_BLOCK_FILE_HAS_HIGH )
 460         i_file_size_high = GetDWLE( &p_peek[7+25] );
 461
 462     char *psz_name = calloc( 1, i_name_size + 1 );
 463     if( !psz_name )
 464         return VLC_EGENERIC;
 465
 466     const int i_name_offset = (p_hdr->i_flags & RAR_BLOCK_FILE_HAS_HIGH) ? (7+33) : (7+25);
 467     if( i_name_offset + i_name_size <= p_hdr->i_size )
 468         memcpy( psz_name, &p_peek[i_name_offset], i_name_size );
 469
 470     if( i_method != 0x30 )
 471     {
 472         msg_Warn( s, "Ignoring compressed file %s (method=0x%2.2x)", psz_name, i_method );
 473         goto exit;
 474     }
 475
 476     /* Ignore smaller files */
 477     const int64_t i_file_size = ((int64_t)i_file_size_high << 32) | i_file_size_low;
 478     if( p_sys->p_file &&
 479         p_sys->p_file->i_size < i_file_size )
 480     {
 481         RarFileDelete( p_sys->p_file );
 482         p_sys->p_file = NULL;
 483     }
 484     /* */
 485     rar_file_t *p_current = p_sys->p_file;
 486     if( !p_current )
 487     {
 488         p_sys->p_file = p_current = malloc( sizeof( *p_sys->p_file ) );
 489         if( !p_current )
 490             goto exit;
 491
 492         /* */
 493         p_current->psz_name = psz_name;
 494         p_current->i_size = i_file_size;
 495         p_current->b_complete = false;
 496         p_current->i_real_size = 0;
 497         TAB_INIT( p_current->i_chunk, p_current->pp_chunk );
 498
 499         psz_name = NULL;
 500     }
 501
 502     /* Append chunks */
 503     if( !p_current->b_complete )
 504     {
 505         bool b_append = false;
 506         /* Append if first chunk */
 507         if( p_current->i_chunk <= 0 )
 508             b_append = true;
 509         /* Append if it is really a continuous chunck */
 510         if( p_current->i_size == i_file_size &&
 511             ( !psz_name || !strcmp( p_current->psz_name, psz_name ) ) &&
 512             ( p_hdr->i_flags & RAR_BLOCK_FILE_HAS_PREVIOUS ) )
 513             b_append = true;
 514
 515         if( b_append )
 516         {
 517             rar_file_chunk_t *p_chunk = malloc( sizeof( *p_chunk ) );
 518             if( p_chunk )
 519             {
 520                 p_chunk->i_offset = stream_Tell( s->p_source );
 521                 p_chunk->i_size = p_hdr->i_add_size;
 522                 p_chunk->i_cummulated_size = 0;
 523                 if( p_current->i_chunk > 0 )
 524                 {
 525                     rar_file_chunk_t *p_previous = p_current->pp_chunk[p_current->i_chunk-1];
 526
 527                     p_chunk->i_cummulated_size += p_previous->i_cummulated_size +
 528                                                   p_previous->i_size;
 529                 }
 530
 531                 TAB_APPEND( p_current->i_chunk, p_current->pp_chunk, p_chunk );
 532
 533                 p_current->i_real_size += p_hdr->i_add_size;
 534             }
 535         }
 536
 537         if( !(p_hdr->i_flags & RAR_BLOCK_FILE_HAS_NEXT ) )
 538             p_current->b_complete = true;
 539     }
 540
 541 exit:
 542     /* */
 543     free( psz_name );
 544
 545     /* We stop on the first non empty file if we cannot seek */
 546     if( p_sys->p_file )
 547     {
 548         bool b_can_seek = false;
 549         stream_Control( s->p_source, STREAM_CAN_SEEK, &b_can_seek );
 550         if( !b_can_seek && p_current->i_size > 0 )
 551             return VLC_EGENERIC;
 552     }
 553
 554     if( SkipBlock( s, p_hdr ) )
 555         return VLC_EGENERIC;
 556     return VLC_SUCCESS;
 557 }
 558
 559 static int Parse( stream_t *s )
 560 {
 561     /* Skip marker */
 562     if( IgnoreBlock( s, RAR_BLOCK_MARKER ) )
 563         return VLC_EGENERIC;
 564
 565     /* Skip archive  */
 566     if( IgnoreBlock( s, RAR_BLOCK_ARCHIVE ) )
 567         return VLC_EGENERIC;
 568
 569     /* */
 570     for( ;; )
 571     {
 572         rar_block_t bk;
 573         int i_ret;
 574
 575         if( PeekBlock( s, &bk ) )
 576             break;
 577
 578         switch( bk.i_type )
 579         {
 580         case RAR_BLOCK_END:
 581             i_ret = SkipEnd( s, &bk );
 582             break;
 583         case RAR_BLOCK_FILE:
 584             i_ret = SkipFile( s, &bk );
 585             break;
 586         default:
 587             i_ret = SkipBlock( s, &bk );
 588             break;
 589         }
 590         if( i_ret )
 591             break;
 592     }
 593
 594     return VLC_SUCCESS;
 595 }