src/input/stream.c

   1 /*****************************************************************************
   2  * stream.c
   3  *****************************************************************************
   4  * Copyright (C) 1999-2004 VLC authors and VideoLAN
   5  * Copyright 2008-2015 Rémi Denis-Courmont
   6  * $Id$
   7  *
   8  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <assert.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <limits.h>
  33 #include <errno.h>
  34
  35 #include <vlc_common.h>
  36 #include <vlc_block.h>
  37 #include <vlc_memory.h>
  38 #include <vlc_access.h>
  39 #include <vlc_charset.h>
  40 #include <vlc_interrupt.h>
  41 #include <vlc_stream_extractor.h>
  42
  43 #include <libvlc.h>
  44 #include "stream.h"
  45 #include "mrl_helpers.h"
  46
  47 typedef struct stream_priv_t
  48 {
  49     stream_t stream;
  50     void (*destroy)(stream_t *);
  51     block_t *block;
  52     block_t *peek;
  53     uint64_t offset;
  54     bool eof;
  55
  56     /* UTF-16 and UTF-32 file reading */
  57     struct {
  58         vlc_iconv_t   conv;
  59         unsigned char char_width;
  60         bool          little_endian;
  61     } text;
  62 } stream_priv_t;
  63
  64 /**
  65  * Allocates a VLC stream object
  66  */
  67 stream_t *vlc_stream_CommonNew(vlc_object_t *parent,
  68                                void (*destroy)(stream_t *))
  69 {
  70     stream_priv_t *priv = vlc_custom_create(parent, sizeof (*priv), "stream");
  71     if (unlikely(priv == NULL))
  72         return NULL;
  73
  74     stream_t *s = &priv->stream;
  75
  76     s->p_module = NULL;
  77     s->psz_url = NULL;
  78     s->p_source = NULL;
  79     s->pf_read = NULL;
  80     s->pf_block = NULL;
  81     s->pf_readdir = NULL;
  82     s->pf_seek = NULL;
  83     s->pf_control = NULL;
  84     s->p_sys = NULL;
  85     s->p_input = NULL;
  86     assert(destroy != NULL);
  87     priv->destroy = destroy;
  88     priv->block = NULL;
  89     priv->peek = NULL;
  90     priv->offset = 0;
  91     priv->eof = false;
  92
  93     /* UTF16 and UTF32 text file conversion */
  94     priv->text.conv = (vlc_iconv_t)(-1);
  95     priv->text.char_width = 1;
  96     priv->text.little_endian = false;
  97
  98     return s;
  99 }
 100
 101 void stream_CommonDelete(stream_t *s)
 102 {
 103     stream_priv_t *priv = (stream_priv_t *)s;
 104
 105     if (priv->text.conv != (vlc_iconv_t)(-1))
 106         vlc_iconv_close(priv->text.conv);
 107
 108     if (priv->peek != NULL)
 109         block_Release(priv->peek);
 110     if (priv->block != NULL)
 111         block_Release(priv->block);
 112
 113     free(s->psz_url);
 114     vlc_object_release(s);
 115 }
 116
 117 /**
 118  * Destroy a stream
 119  */
 120 void vlc_stream_Delete(stream_t *s)
 121 {
 122     stream_priv_t *priv = (stream_priv_t *)s;
 123
 124     priv->destroy(s);
 125     stream_CommonDelete(s);
 126 }
 127
 128 stream_t *(vlc_stream_NewURL)(vlc_object_t *p_parent, const char *psz_url)
 129 {
 130     if( !psz_url )
 131         return NULL;
 132
 133     stream_t *s = stream_AccessNew( p_parent, NULL, false, psz_url );
 134     if( s == NULL )
 135         msg_Err( p_parent, "no suitable access module for `%s'", psz_url );
 136     return s;
 137 }
 138
 139 stream_t *(vlc_stream_NewMRL)(vlc_object_t* parent, const char* mrl )
 140 {
 141     stream_t* stream = vlc_stream_NewURL( parent, mrl );
 142
 143     if( stream == NULL )
 144         return NULL;
 145
 146     char const* anchor = strchr( mrl, '#' );
 147
 148     if( anchor == NULL )
 149         return stream;
 150
 151     char const* extra;
 152     if( stream_extractor_AttachParsed( &stream, anchor + 1, &extra ) )
 153     {
 154         msg_Err( parent, "unable to open %s", mrl );
 155         vlc_stream_Delete( stream );
 156         return NULL;
 157     }
 158
 159     if( extra && *extra )
 160         msg_Warn( parent, "ignoring extra fragment data: %s", extra );
 161
 162     return stream;
 163 }
 164
 165 /**
 166  * Read from the stream until first newline.
 167  * \param s Stream handle to read from
 168  * \return A pointer to the allocated output string. You need to free this when you are done.
 169  */
 170 #define STREAM_PROBE_LINE 2048
 171 #define STREAM_LINE_MAX (2048*100)
 172 char *vlc_stream_ReadLine( stream_t *s )
 173 {
 174     stream_priv_t *priv = (stream_priv_t *)s;
 175     char *p_line = NULL;
 176     int i_line = 0, i_read = 0;
 177
 178     /* Let's fail quickly if this is a readdir access */
 179     if( s->pf_read == NULL && s->pf_block == NULL )
 180         return NULL;
 181
 182     for( ;; )
 183     {
 184         char *psz_eol;
 185         const uint8_t *p_data;
 186         int i_data;
 187         int64_t i_pos;
 188
 189         /* Probe new data */
 190         i_data = vlc_stream_Peek( s, &p_data, STREAM_PROBE_LINE );
 191         if( i_data <= 0 ) break; /* No more data */
 192
 193         /* BOM detection */
 194         i_pos = vlc_stream_Tell( s );
 195         if( i_pos == 0 && i_data >= 2 )
 196         {
 197             const char *psz_encoding = NULL;
 198
 199             if( unlikely(priv->text.conv != (vlc_iconv_t)-1) )
 200             {   /* seek back to beginning? reset */
 201                 vlc_iconv_close( priv->text.conv );
 202                 priv->text.conv = (vlc_iconv_t)-1;
 203             }
 204
 205             if( !memcmp( p_data, "\xFF\xFE", 2 ) )
 206             {
 207                 psz_encoding = "UTF-16LE";
 208                 priv->text.little_endian = true;
 209             }
 210             else if( !memcmp( p_data, "\xFE\xFF", 2 ) )
 211             {
 212                 psz_encoding = "UTF-16BE";
 213             }
 214
 215             /* Open the converter if we need it */
 216             if( psz_encoding != NULL )
 217             {
 218                 msg_Dbg( s, "UTF-16 BOM detected" );
 219                 priv->text.conv = vlc_iconv_open( "UTF-8", psz_encoding );
 220                 if( unlikely(priv->text.conv == (vlc_iconv_t)-1) )
 221                 {
 222                     msg_Err( s, "iconv_open failed" );
 223                     goto error;
 224                 }
 225                 priv->text.char_width = 2;
 226             }
 227         }
 228
 229         if( i_data % priv->text.char_width )
 230         {
 231             /* keep i_char_width boundary */
 232             i_data = i_data - ( i_data % priv->text.char_width );
 233             msg_Warn( s, "the read is not i_char_width compatible");
 234         }
 235
 236         if( i_data == 0 )
 237             break;
 238
 239         /* Check if there is an EOL */
 240         if( priv->text.char_width == 1 )
 241         {
 242             /* UTF-8: 0A <LF> */
 243             psz_eol = memchr( p_data, '\n', i_data );
 244             if( psz_eol == NULL )
 245                 /* UTF-8: 0D <CR> */
 246                 psz_eol = memchr( p_data, '\r', i_data );
 247         }
 248         else
 249         {
 250             const uint8_t *p_last = p_data + i_data - priv->text.char_width;
 251             uint16_t eol = priv->text.little_endian ? 0x0A00 : 0x00A0;
 252
 253             assert( priv->text.char_width == 2 );
 254             psz_eol = NULL;
 255             /* UTF-16: 000A <LF> */
 256             for( const uint8_t *p = p_data; p <= p_last; p += 2 )
 257             {
 258                 if( U16_AT( p ) == eol )
 259                 {
 260                      psz_eol = (char *)p + 1;
 261                      break;
 262                 }
 263             }
 264
 265             if( psz_eol == NULL )
 266             {   /* UTF-16: 000D <CR> */
 267                 eol = priv->text.little_endian ? 0x0D00 : 0x00D0;
 268                 for( const uint8_t *p = p_data; p <= p_last; p += 2 )
 269                 {
 270                     if( U16_AT( p ) == eol )
 271                     {
 272                         psz_eol = (char *)p + 1;
 273                         break;
 274                     }
 275                 }
 276             }
 277         }
 278
 279         if( psz_eol )
 280         {
 281             i_data = (psz_eol - (char *)p_data) + 1;
 282             p_line = realloc_or_free( p_line,
 283                         i_line + i_data + priv->text.char_width ); /* add \0 */
 284             if( !p_line )
 285                 goto error;
 286             i_data = vlc_stream_Read( s, &p_line[i_line], i_data );
 287             if( i_data <= 0 ) break; /* Hmmm */
 288             i_line += i_data - priv->text.char_width; /* skip \n */;
 289             i_read += i_data;
 290
 291             /* We have our line */
 292             break;
 293         }
 294
 295         /* Read data (+1 for easy \0 append) */
 296         p_line = realloc_or_free( p_line,
 297                           i_line + STREAM_PROBE_LINE + priv->text.char_width );
 298         if( !p_line )
 299             goto error;
 300         i_data = vlc_stream_Read( s, &p_line[i_line], STREAM_PROBE_LINE );
 301         if( i_data <= 0 ) break; /* Hmmm */
 302         i_line += i_data;
 303         i_read += i_data;
 304
 305         if( i_read >= STREAM_LINE_MAX )
 306             goto error; /* line too long */
 307     }
 308
 309     if( i_read > 0 )
 310     {
 311         if( priv->text.char_width > 1 )
 312         {
 313             int i_new_line = 0;
 314             size_t i_in = 0, i_out = 0;
 315             const char * p_in = NULL;
 316             char * p_out = NULL;
 317             char * psz_new_line = NULL;
 318
 319             /* iconv */
 320             /* UTF-8 needs at most 150% of the buffer as many as UTF-16 */
 321             i_new_line = i_line * 3 / 2;
 322             psz_new_line = malloc( i_new_line );
 323             if( psz_new_line == NULL )
 324                 goto error;
 325             i_in = (size_t)i_line;
 326             i_out = (size_t)i_new_line;
 327             p_in = p_line;
 328             p_out = psz_new_line;
 329
 330             if( vlc_iconv( priv->text.conv, &p_in, &i_in, &p_out, &i_out ) == (size_t)-1 )
 331             {
 332                 msg_Err( s, "conversion error: %s", vlc_strerror_c( errno ) );
 333                 msg_Dbg( s, "original: %d, in %zu, out %zu", i_line, i_in, i_out );
 334             }
 335             free( p_line );
 336             p_line = psz_new_line;
 337             i_line = (size_t)i_new_line - i_out; /* does not include \0 */
 338         }
 339
 340         /* Remove trailing LF/CR */
 341         while( i_line >= 1 &&
 342                (p_line[i_line - 1] == '\r' || p_line[i_line - 1] == '\n') )
 343             i_line--;
 344
 345         /* Make sure the \0 is there */
 346         p_line[i_line] = '\0';
 347
 348         return p_line;
 349     }
 350
 351 error:
 352     /* We failed to read any data, probably EOF */
 353     free( p_line );
 354
 355     /* */
 356     if( priv->text.conv != (vlc_iconv_t)(-1) )
 357     {
 358         vlc_iconv_close( priv->text.conv );
 359         priv->text.conv = (vlc_iconv_t)(-1);
 360     }
 361     return NULL;
 362 }
 363
 364 static ssize_t vlc_stream_CopyBlock(block_t **restrict pp,
 365                                     void *buf, size_t len)
 366 {
 367     block_t *block = *pp;
 368
 369     if (block == NULL)
 370         return -1;
 371
 372     if (len > block->i_buffer)
 373         len = block->i_buffer;
 374
 375     if (buf != NULL)
 376         memcpy(buf, block->p_buffer, len);
 377
 378     block->p_buffer += len;
 379     block->i_buffer -= len;
 380
 381     if (block->i_buffer == 0)
 382     {
 383         block_Release(block);
 384         *pp = NULL;
 385     }
 386
 387     return likely(len > 0) ? (ssize_t)len : -1;
 388 }
 389
 390 static ssize_t vlc_stream_ReadRaw(stream_t *s, void *buf, size_t len)
 391 {
 392     stream_priv_t *priv = (stream_priv_t *)s;
 393     ssize_t ret;
 394
 395     assert(len <= SSIZE_MAX);
 396
 397     if (vlc_killed())
 398         return 0;
 399
 400     if (s->pf_read != NULL)
 401     {
 402         assert(priv->block == NULL);
 403         if (buf == NULL)
 404         {
 405             if (unlikely(len == 0))
 406                 return 0;
 407
 408             char dummy[(len <= 256 ? len : 256)];
 409             ret = s->pf_read(s, dummy, sizeof (dummy));
 410         }
 411         else
 412             ret = s->pf_read(s, buf, len);
 413         return ret;
 414     }
 415
 416     ret = vlc_stream_CopyBlock(&priv->block, buf, len);
 417     if (ret >= 0)
 418         return ret;
 419
 420     if (s->pf_block != NULL)
 421     {
 422         bool eof = false;
 423
 424         priv->block = s->pf_block(s, &eof);
 425         ret = vlc_stream_CopyBlock(&priv->block, buf, len);
 426         if (ret >= 0)
 427             return ret;
 428         return eof ? 0 : -1;
 429     }
 430
 431     return 0;
 432 }
 433
 434 ssize_t vlc_stream_ReadPartial(stream_t *s, void *buf, size_t len)
 435 {
 436     stream_priv_t *priv = (stream_priv_t *)s;
 437     ssize_t ret;
 438
 439     ret = vlc_stream_CopyBlock(&priv->peek, buf, len);
 440     if (ret >= 0)
 441     {
 442         priv->offset += ret;
 443         assert(ret <= (ssize_t)len);
 444         return ret;
 445     }
 446
 447     ret = vlc_stream_ReadRaw(s, buf, len);
 448     if (ret > 0)
 449         priv->offset += ret;
 450     if (ret == 0)
 451         priv->eof = len != 0;
 452     assert(ret <= (ssize_t)len);
 453     return ret;
 454 }
 455
 456 ssize_t vlc_stream_Read(stream_t *s, void *buf, size_t len)
 457 {
 458     size_t copied = 0;
 459
 460     while (len > 0)
 461     {
 462         ssize_t ret = vlc_stream_ReadPartial(s, buf, len);
 463         if (ret < 0)
 464             continue;
 465         if (ret == 0)
 466             break;
 467
 468         if (buf != NULL)
 469             buf = (char *)buf + ret;
 470         assert(len >= (size_t)ret);
 471         len -= ret;
 472         copied += ret;
 473     }
 474
 475     return copied;
 476 }
 477
 478 ssize_t vlc_stream_Peek(stream_t *s, const uint8_t **restrict bufp, size_t len)
 479 {
 480     stream_priv_t *priv = (stream_priv_t *)s;
 481     block_t *peek;
 482
 483     peek = priv->peek;
 484     if (peek == NULL)
 485     {
 486         peek = priv->block;
 487         priv->peek = peek;
 488         priv->block = NULL;
 489     }
 490
 491     if (peek == NULL)
 492     {
 493         peek = block_Alloc(len);
 494         if (unlikely(peek == NULL))
 495             return VLC_ENOMEM;
 496
 497         peek->i_buffer = 0;
 498     }
 499     else
 500     if (peek->i_buffer < len)
 501     {
 502         size_t avail = peek->i_buffer;
 503
 504         peek = block_TryRealloc(peek, 0, len);
 505         if (unlikely(peek == NULL))
 506             return VLC_ENOMEM;
 507
 508         peek->i_buffer = avail;
 509     }
 510
 511     priv->peek = peek;
 512     *bufp = peek->p_buffer;
 513
 514     while (peek->i_buffer < len)
 515     {
 516         size_t avail = peek->i_buffer;
 517         ssize_t ret;
 518
 519         ret = vlc_stream_ReadRaw(s, peek->p_buffer + avail, len - avail);
 520         if (ret < 0)
 521             continue;
 522
 523         peek->i_buffer += ret;
 524
 525         if (ret == 0)
 526             return peek->i_buffer;
 527     }
 528
 529     return len;
 530 }
 531
 532 block_t *vlc_stream_ReadBlock(stream_t *s)
 533 {
 534     stream_priv_t *priv = (stream_priv_t *)s;
 535     block_t *block;
 536
 537     if (vlc_killed())
 538     {
 539         priv->eof = true;
 540         return NULL;
 541     }
 542
 543     if (priv->peek != NULL)
 544     {
 545         block = priv->peek;
 546         priv->peek = NULL;
 547     }
 548     else if (priv->block != NULL)
 549     {
 550         block = priv->block;
 551         priv->block = NULL;
 552     }
 553     else if (s->pf_block != NULL)
 554     {
 555         priv->eof = false;
 556         block = s->pf_block(s, &priv->eof);
 557     }
 558     else
 559     {
 560         block = block_Alloc(4096);
 561         if (unlikely(block == NULL))
 562             return NULL;
 563
 564         ssize_t ret = s->pf_read(s, block->p_buffer, block->i_buffer);
 565         if (ret > 0)
 566             block->i_buffer = ret;
 567         else
 568         {
 569             block_Release(block);
 570             block = NULL;
 571         }
 572
 573         priv->eof = !ret;
 574     }
 575
 576     if (block != NULL)
 577         priv->offset += block->i_buffer;
 578
 579     return block;
 580 }
 581
 582 uint64_t vlc_stream_Tell(const stream_t *s)
 583 {
 584     const stream_priv_t *priv = (const stream_priv_t *)s;
 585
 586     return priv->offset;
 587 }
 588
 589 bool vlc_stream_Eof(const stream_t *s)
 590 {
 591     const stream_priv_t *priv = (const stream_priv_t *)s;
 592
 593     return priv->eof;
 594 }
 595
 596 int vlc_stream_Seek(stream_t *s, uint64_t offset)
 597 {
 598     stream_priv_t *priv = (stream_priv_t *)s;
 599
 600     priv->eof = false;
 601
 602     block_t *peek = priv->peek;
 603     if (peek != NULL)
 604     {
 605         if (offset >= priv->offset
 606          && offset <= (priv->offset + peek->i_buffer))
 607         {   /* Seeking within the peek buffer */
 608             size_t fwd = offset - priv->offset;
 609
 610             peek->p_buffer += fwd;
 611             peek->i_buffer -= fwd;
 612             priv->offset = offset;
 613
 614             if (peek->i_buffer == 0)
 615             {
 616                 priv->peek = NULL;
 617                 block_Release(peek);
 618             }
 619
 620             return VLC_SUCCESS;
 621         }
 622     }
 623     else
 624     {
 625         if (priv->offset == offset)
 626             return VLC_SUCCESS; /* Nothing to do! */
 627     }
 628
 629     if (s->pf_seek == NULL)
 630         return VLC_EGENERIC;
 631
 632     int ret = s->pf_seek(s, offset);
 633     if (ret != VLC_SUCCESS)
 634         return ret;
 635
 636     priv->offset = offset;
 637
 638     if (peek != NULL)
 639     {
 640         priv->peek = NULL;
 641         block_Release(peek);
 642     }
 643
 644     if (priv->block != NULL)
 645     {
 646         block_Release(priv->block);
 647         priv->block = NULL;
 648     }
 649
 650     return VLC_SUCCESS;
 651 }
 652
 653 /**
 654  * Use to control the "stream_t *". Look at #stream_query_e for
 655  * possible "i_query" value and format arguments.  Return VLC_SUCCESS
 656  * if ... succeed ;) and VLC_EGENERIC if failed or unimplemented
 657  */
 658 int vlc_stream_vaControl(stream_t *s, int cmd, va_list args)
 659 {
 660     stream_priv_t *priv = (stream_priv_t *)s;
 661
 662     switch (cmd)
 663     {
 664         case STREAM_SET_TITLE:
 665         case STREAM_SET_SEEKPOINT:
 666         {
 667             int ret = s->pf_control(s, cmd, args);
 668             if (ret != VLC_SUCCESS)
 669                 return ret;
 670
 671             priv->offset = 0;
 672
 673             if (priv->peek != NULL)
 674             {
 675                 block_Release(priv->peek);
 676                 priv->peek = NULL;
 677             }
 678
 679             if (priv->block != NULL)
 680             {
 681                 block_Release(priv->block);
 682                 priv->block = NULL;
 683             }
 684
 685             return VLC_SUCCESS;
 686         }
 687     }
 688     return s->pf_control(s, cmd, args);
 689 }
 690
 691 /**
 692  * Read data into a block.
 693  *
 694  * @param s stream to read data from
 695  * @param size number of bytes to read
 696  * @return a block of data, or NULL on error
 697  @ note The block size may be shorter than requested if the end-of-stream was
 698  * reached.
 699  */
 700 block_t *vlc_stream_Block( stream_t *s, size_t size )
 701 {
 702     if( unlikely(size > SSIZE_MAX) )
 703         return NULL;
 704
 705     block_t *block = block_Alloc( size );
 706     if( unlikely(block == NULL) )
 707         return NULL;
 708
 709     ssize_t val = vlc_stream_Read( s, block->p_buffer, size );
 710     if( val <= 0 )
 711     {
 712         block_Release( block );
 713         return NULL;
 714     }
 715
 716     block->i_buffer = val;
 717     return block;
 718 }
 719
 720 /**
 721  * Returns a node containing all the input_item of the directory pointer by
 722  * this stream. returns VLC_SUCCESS on success.
 723  */
 724 int vlc_stream_ReadDir( stream_t *s, input_item_node_t *p_node )
 725 {
 726     return s->pf_readdir( s, p_node );
 727 }